Day19 pandas文件读取和数据结构

读取csv文件

to_csv()

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

read_csv()

在 Pandas 中， 可以使用 `pandas.read_csv()` 函数来读取 CSV 文件。以下是一个简单的示例，展示了如何读取 CSV 文件并将其加载到一个 DataFrame 中：

import pandas as pd

# 读取 CSV 文件

df = pd.read_csv('your_file.csv')

print(df)

# 查看前几行数据

print(df.head())

 参数说明：

  filepath_or_buffer: 文件的路径或 URL。

  sep: 分隔符，默认是逗号 ,。

  header: 指定哪一行作为列名，默认是第一行（header=0）。如果数据没有列名，可以设置为 None。

  names: 如果数据没有列名，可以手动指定列名。

  index_col: 指定哪一列作为索引列。

  usecols: 指定要读取的列。

  dtype: 指定每一列的数据类型。

  skiprows: 跳过前几行。

  nrows: 只读取前几行。

  encoding: 指定文件的编码格式，例如 utf 8 或 latin1。

 示例：

假设有一个 CSV 文件 data.csv：

Name,Age,City

Alice,30,New York

Bob,25,Los Angeles

Charlie,35,Chicago

读取：

import pandas as pd

# 读取 CSV 文件

df = pd.read_csv('data.csv')

# 查看前几行数据

print(df.head())

输出：

      Name  Age         City

0    Alice   30     New York

1      Bob   25  Los Angeles

2  Charlie   35      Chicago

更多读取方式：

 1. 指定分隔符：

如果CSV 文件使用的是其他分隔符（例如 ;）， 可以这样读取：

df = pd.read_csv('data.csv', sep=';')

 2. 跳过前几行：

如果需要跳过文件的前几行，可以使用 skiprows 参数：

df = pd.read_csv('data.csv', skiprows=2)

 3. 指定编码格式：

如果文件编码不是 utf 8， 可以指定编码格式：

df = pd.read_csv('data.csv', encoding='latin1')

 4. 只读取部分列：

如果 只想读取部分列，可以使用 usecols 参数：

df = pd.read_csv('data.csv', usecols=['Name', 'Age'])

读取Excel文件

Excel操作需要安装第三方库

pip install openpyxl

1、read_excel()

read_excel() 读取 Excel 表格中的数据。

语法：

pd.read_excel(io, sheet_name=0, header=0, names=None, index_col=None,
              usecols=None, squeeze=False,dtype=None, engine=None,
              converters=None, true_values=None, false_values=None,
              skiprows=None, nrows=None, na_values=None, parse_dates=False,
              date_parser=None, thousands=None, comment=None, skipfooter=0,
              convert_float=True, **kwds)

参数说明：

io：文件的路径或URL。
sheet_name：指定要读取的工作表名称或索引，默认是第一个工作表（sheet_name=0）。
header：指定哪一行作为列名，默认是第一行（header=0）。如果数据没有列名，可以设置为None。
names：如果数据没有列名，可以手动指定列名。
index_col：指定哪一列作为索引列。
usecols：指定要读取的列。

squeeze：boolean，默认为False，如果解析的数据只包含一列，则返回一个Series。
converters：指定每一列的数据类型。
skiprows：跳过前几行数据。
nrows：只读取前几行数据。
skipfooter：接受一个列表，省略指定行数的数据，从尾部最后一行开始。

示例：

假设一个 Excel 文件 `data.xlsx`，内容如下：

  Name      Age   City                                    

  Alice     30    New York     

  Bob       25    Los Angeles  

  Charlie   35    Chicago      

读取：

import pandas as pd

# 读取 Excel 文件

df = pd.read_excel('data.xlsx')

# 查看前几行数据

print(df.head())

输出：

      Name  Age         City

0    Alice   30     New York

1      Bob   25  Los Angeles

2  Charlie   35      Chicago

 更多读取方式：

 1. 指定工作表：

如果  Excel 文件有多个工作表， 可以指定要读取的工作表名称或索引：

df = pd.read_excel('data.xlsx', sheet_name='Sheet2')

或者使用索引：

df = pd.read_excel('data.xlsx', sheet_name=1)

 2. 跳过前几行：

如果 需要跳过文件的前几行，可以使用 skiprows 参数：

df = pd.read_excel('data.xlsx', skiprows=2)

 3. 只读取部分列：

如果 只想读取部分列，可以使用 usecols参数：

df = pd.read_excel('data.xlsx', usecols=['Name', 'Age'])

 4. 指定缺失值：

如果 需要指定哪些值将被视为缺失值，可以使用 na_values 参数：

df = pd.read_excel('data.xlsx', na_values=['NA', 'N/A'])

数据结构

1.概念

数据结构是计算机科学中关于数据的组织、管理和存储方式，以及数据元素之间关系。它的核心目的是支持高效的数据插入、删除和搜索操作。数据结构主要分为以下几类：

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

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

散列 ：哈希表。

索引 ：B树、B+树等。

2. 常见数据结构

2.1 栈 (Stack)

栈是一种运算受限的线性表，遵循后进先出（LIFO）原则。

操作 ：

push(element)：将新元素添加到栈顶

pop()：移除栈顶元素并返回被移除的元素。

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

isEmpty()：检查栈是否为空如果栈里没有任何元素就返回true，否则返回false。

clear()：清空栈。

size()：返回栈中元素数量，类似于length属性。

2.1.1入栈

入栈（push）是将一个新元素添加到栈的顶部的过程。栈是一种后进先出（LIFO, Last In First Out）的数据结构，这意味着最后添加的元素将是第一个被移除的元素。在栈的上下文中，顶部通常指的是可以进行添加或移除操作的一端。

例如，如果 有一个空栈，并执行以下操作：

push(5)：将数字5入栈。

push(10)：将数字10入栈。

此时，栈的状态将是：

底部 <  [5, 10] <  顶部

在这个例子中，数字10是栈顶元素，因为它是最后被添加进来的。如果 接下来执行一个pop()操作，数字10将会被移除并返回，留下数字5作为新的栈顶元素。

2.1.2出栈（pop）

是从栈的顶部移除一个元素并返回该元素的过程。在栈这种后进先出（LIFO, Last In First Out)的数据结构中，最后入栈的元素将是第一个被出栈的元素。

继续前面的例子，假设 有一个栈，其状态如下：

底部 <  [5, 10] <  顶部

此时，栈顶元素是10。如果 执行一个pop()操作：

pop()：移除栈顶元素10并返回。

执行完这个操作后，栈的状态将变为：

底部 <  [5] <  顶部

数字10被移除，数字5成为了新的栈顶元素。这就是出栈操作的基本过程。如果再次执行pop()，数字5也会被移除，此时栈将变为空。

2.1.3代码分析

1.使用数组来模拟栈

2.定义一个 空数组

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

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

class Stack:

      def __init__(self, size):

          self.items = []

          self.size = size

      def isFull(self):

          return len(self.items) == self.size

      def push(self, element):

          if self.isFull():

              raise Exception('stack is full')

          self.items.append(element)

      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]

      def isEmpty(self):

          return len(self.items) == 0

      def clear(self):

          self.items.clear()

2.2 链表 (Linked List)

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

2.2.1 链表的优缺点

优点 ：

物理存储单元上非连续，动态内存分配。

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

缺点 ：

不能进行索引访问，只能顺序查找。

结构复杂，需要大量指针操作，容易出错。

2.2.2 单向链表

  单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。下面是单向链表的基本操作：插入（尾部插入和头部插入）、遍历和删除。

节点类

首先，定义一个节点类，每个节点包含数据和指向下一个节点的指针。

class Node:

    def __init__(self, data):

        self.data = data

定义单向链表类

插入

1.  尾部插入 (append) :

     创建一个新节点。

     如果链表为空，将新节点设置为头节点。

     否则，遍历链表直到最后一个节点，然后将新节点连接到最后一个节点的 `next`。

2.  头部插入 (prepend) :

     创建一个新节点。

     将新节点的 `next` 指向当前的头节点。

     将新节点设置为新的头节点。

3.  遍历链表 (traverse) :

     从头节点开始，遍历每个节点，打印节点的数据，直到 `next` 为 `None`。

4.  删除节点 (delete) :

     如果头节点就是要删除的节点，将头节点设置为下一个节点。

     否则，遍历链表找到要删除的节点，并将其前一个节点的 `next` 指向要删除节点的 `next`。

示例

# 创建链表

linked_list = LinkedList()

# 尾部插入

linked_list.append(1)

linked_list.append(2)

linked_list.append(3)

# 头部插入

linked_list.prepend(0)

# 遍历链表

linked_list.traverse()  # 输出: 0  > 1  > 2  > 3  > None

# 删除节点

linked_list.delete(2)

# 遍历链表

linked_list.traverse()  # 输出: 0  > 1  > 3  > None

代码实现：

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

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

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

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

        self.items.append(item)

    # 出栈操作
    # 判断栈是否为空，是则抛栈已空的异常
    # 否则从数组尾部移除一个元素，并将该元素返回
    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(3)
    s.push(4)
    s.push(1)
    s.push(2)
    s.push(5)
    # s.push(6)  # 这行代码会抛出栈已满的异常

    print(s.peek())  
    print(s.peek())  

    print(s.pop())  
    print(s.pop())  
    print(s.pop())  
    print(s.pop())  
    print(s.pop())  

    # 检查栈是否为空
    if not s.isEmpty():
        print(s.pop())
    else:
        print("Stack is empty")  

输出：

5
5
5
2
1
4
3
Stack is empty

进程已结束，退出代码为 0