Python基础15_读取CSV文件&绘图&数据结构：栈&链表

一、读取CSV文件

---

 CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）；

CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。

1、to_csv()

to_csv() 方法将 DataFrame 存储为 csv 文件

"""
读取CSV文件
  1、to_csv()
    将 DataFrame 存储为 csv 文件
    
    参数
      path：存储csv文件的路径，可以是相对路径，也可以是绝对路径
      index：True表示将行索引保存到csv文件，False表示不保存
      
"""
def pd_to_csv():
    data = {
        'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'Los Angeles', 'Chicago']
    }
    df = pd.DataFrame(data)

    # 将 DataFrame 导出为 CSV 文件
    df.to_csv('df1.csv',index=False)

2、read_csv()

read_csv() 表示从 CSV 文件中读取数据，并创建 DataFrame 对象。

    """
    2、read_csv()
      从 CSV 文件中读取数据，并创建 DataFrame 对象
      
      参数
         path：存储csv文件的路径
      
    """
    df1 = pd.read_csv('df1.csv')
    print(df1)

二、绘图

---

 Pandas 在数据分析、数据可视化方面有着较为广泛的应用，Pandas 对 Matplotlib 绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作；

Pandas 之所以能够实现了数据可视化，主要利用了 Matplotlib 库的 plot() 方法，它对 plot() 方法做了简单的封装，因此您可以直接调用该接口；

只用 pandas 绘制图片可能可以编译，但是不会显示图片，需要使用 matplotlib 库，调用 show() 方法显示图形。

"""
绘图
"""
def pd_img():
    data = {'A':[1,2,3,4,5],
            'B':[20,30,40,60,10]}
    df = pd.DataFrame(data)
    # 折线图
    df.plot(kind='line', x='A',y='B')
    plt.show()

    # 柱状图
    df.plot(kind='bar', x='A',y='B')
    plt.show()

    # 绘制直方图
    df['A'].plot(kind='hist')
    plt.show()

    # 绘制散点图
    df.plot(kind='scatter', x='A', y='B')
    plt.show()

三、数据结构

---

 数据结构是计算机科学中的一个核心概念，它是指数据的组织、管理和存储方式，以及数据元素之间的关系。数据结构通常用于允许高效的数据插入、删除和搜索操作。

数据结构大致分为几大类：

线性结构：数组、链表、栈、队列等。

非线性结构：树、二叉树、堆、图等。

散列：哈希表。

索引：B树、B+树等。

1、栈

栈（stack），它是一种运算受限的线性表，遵循后进先出（Last In First Out，LIFO）原则的数据结构。

• LIFO(last in first out)表示就是后进入的元素, 第一个弹出栈空间. 类似于自动餐托盘, 最后放上的托盘, 往往先把拿出去使用.

• 其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。

• 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；

• 从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素

常见操作

• push(element): 添加一个新元素到栈顶位置.

• pop()：移除栈顶的元素，同时返回被移除的元素。

• peek()：返回栈顶的元素，不对栈做任何修改（这个方法不会移除栈顶的元素，仅仅返回它）。

• isEmpty()：如果栈里没有任何元素就返回true，否则返回false。

• clear()：移除栈里的所有元素。

• size()：返回栈里的元素个数。这个方法和数组的length属性很类似。

代码分析

1. 使用数组来模拟栈

2. 定义一个空数组

3. 入栈的操作，当有数据加入到栈时，判断数组长度是否达到阈值，是则抛栈已满的异常，否则将数据追加到数组的尾部;

4. 出栈的操作，判断栈是否空，是则抛栈已空的异常，否则从数组尾部移除一个数据，并返回该数据;

"""
栈
"""
class stack:
    def __init__(self,size):
        # 初始化一个空数组作为栈
        self.items = []
        # 给数组设置一个容量阈值
        self.size = size

    # 判断栈是否为空 True为空
    def isEmpty(self):
        return  len(self.items) == 0

    # 判断栈是否已满 True为已满
    def isFull(self):
        return len(self.items) == self.size

    # push 入栈
    # 判断栈是否已满，已满则抛栈已满的异常，中断后边的代码执行
    # 否则向栈的尾部添加一个元素
    def push(self, item):
        if self.isFull():
            raise Exception('stack is full')

        self.items.append(item)

    # pop 出栈
    # 判断栈是否为空，是则抛栈已空的异常
    # 否则从数组胃部移除一个元素，并将该元素返回
    def pop(self):
        if self.isEmpty():
            raise Exception('stack is empty')

        return self.items.pop()

    # 从栈中获取栈顶的元素
    def peek(self):
        if self.isEmpty():
            raise Exception('stack is empty')

        return self.items[-1]

if __name__ == '__main__':
    s = stack(5)
    s.push(1)
    s.push(2)
    print(s.peek())  # 2

2、链表

链表是一条相互链接的数据节点表。每个节点由两部分组成：数据和指向下一个节点的指针。

1.优缺点

优点：

1. 物理存储单元上非连续，而且采用动态内存分配，能够有效的分配和利用内存资源；

2. 节点删除和插入简单，不需要内存空间的重组。

缺点：

1. 不能进行索引访问，只能从头结点开始顺序查找；

2. 数据结构较为复杂，需要大量的指针操作，容易出错。

2.单向链表

常见操作

• 插入

  尾插法

从头结点开始逐个遍历链表，直到找到next=null，表示为最后一个节点，再将最后节点的next指向新增节点。

  头插法

如果头节点的next=null表示链表为空，直接将头节点的next指向新增节点

如果头节点的next!=null，表示头节点后已存在后续节点，需要将新增节点插入到头节点和后续节点中间：

1.获取头节点的后续节点，定义一个临时节点，将该节点指向临时节点

2.将头节点的next指向新增节点

3.新增节点的next指向临时节点

• 遍历

从头结点开始，通过next遍历，直到next=null

• 删除

代码实现

"""
链表
"""
# 结点
class Node:
    def __init__(self, data=None):
        if data is not None:
            self.data = data
        self.next = None

# 链表
class LinkedList:
    # 初始化一个结点当作链表的头结点
    def __init__(self):
        head = Node()
        self.head = head


    # 尾插法
    def append(self,data):
        new_node = Node(data)
        # 判断头结点后是否有数据结点，没有则直接将新节点连接在头结点后
        if self.head.next is None:
            self.head.next = new_node

        # 如果头结点后有数据节点，则遍历链表
        # 找到next为None的数据结点(尾部结点)，将新结点连接到尾部结点
        else:
            node = self.head.next
            while node.next is not None:
                node = node.next
            node.next = new_node

    # 遍历
    def display(self):
        node = self.head.next
        while True:
            print(node.data)
            if node.next is None:
                break
            node = node.next

    # 头插法
    def prepend(self,data):
        new_node = Node(data)
        # 如果头节点后没有结点，则将新结点插入到头结点后
        if self.head.next is None:
            self.head.next = new_node

        # 如果头结点有结点数据，则先将新结点的next指针指向头结点的后一个结点
        # 再将头结点的next指针指向新结点
        else:
            new_node.next = self.head.next
            self.head.next = new_node

    # 删除
    def remove(self, data):
        node = self.head

        while node.next.data != data:
            node = node.next

        node.next = node.next.next