数据结构及操作

yanPython提供了多种基础数据结构，包括列表（List）、元组（Tuple）、集合（Set）和字典（Dictionary）。下面是这些数据结构及其常用操作方法的整理：

列表（List）：

  • 创建列表：使用方括号 [] 或 list() 函数。
  • 增加元素：使用 append() 方法在列表末尾添加元素，或使用 insert() 方法在指定位置插入元素。
  • 访问元素：使用索引访问列表中的元素，索引从0开始，或使用切片（slice）获取子列表。
  • 修改元素：通过索引重新赋值来修改列表中的元素。
  • 删除元素：使用 del 关键字删除指定位置的元素，或使用 remove() 方法删除指定值的元素。
  • 其他常用方法：len() 返回列表长度，sort() 对列表进行排序，reverse() 反转列表等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 创建列表
my_list = [1, 2, 3, 4, 5]

# 增加元素
my_list.append(6)
my_list.insert(0, 0)

# 访问元素
print(my_list[2])    # 输出: 3
print(my_list[1:4])  # 输出: [1, 2, 3, 4]

# 修改元素
my_list[3] = 7

# 删除元素
del my_list[2]
my_list.remove(5)

# 其他常用方法
print(len(my_list))  # 输出: 5
my_list.sort()
print(my_list)       # 输出: [0, 1, 4, 6, 7]
my_list.reverse()
print(my_list)       # 输出: [7, 6, 4, 1, 0]

元组（Tuple）：

  • 创建元组：使用圆括号 () 或 tuple() 函数。
  • 访问元素：使用索引访问元组中的元素，索引从0开始，或使用切片获取子元组。
  • 元组是不可变的，无法修改元素。
  • 其他常用方法：len() 返回元组长度，count() 统计指定值在元组中出现的次数，index() 查找指定值第一次出现的索引位置。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建元组
my_tuple = (1, 2, 3, 4, 5)

# 访问元素
print(my_tuple[2])       # 输出: 3
print(my_tuple[1:4])     # 输出: (2, 3, 4)

# 不可修改元素（元组是不可变的）

# 其他常用方法
print(len(my_tuple))     # 输出: 5
print(my_tuple.count(3)) # 输出: 1
print(my_tuple.index(4)) # 输出: 3

集合（Set）：

  • 创建集合：使用花括号 {} 或 set() 函数。
  • 添加元素：使用 add() 方法添加单个元素，或使用 update() 方法添加多个元素。
  • 删除元素：使用 remove() 方法删除指定元素，如果元素不存在会引发 KeyError 异常，或使用 discard() 方法删除元素，如果元素不存在不会引发异常。
  • 集合中的元素是唯一且无序的。
  • 其他常用方法：len() 返回集合中元素的个数，union() 返回两个集合的并集，intersection() 返回两个集合的交集，difference() 返回两个集合的差集等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 创建集合
my_set = {1, 2, 3, 4, 5}

# 添加元素
my_set.add(6)
my_set.update([7, 8, 9])

# 删除元素
my_set.remove(5)
my_set.discard(10)

# 其他常用方法
print(len(my_set))               # 输出: 8
print(my_set.union({9, 10, 11})) # 输出: {1, 2, 3, 4, 6, 7, 8, 9, 10, 11}
print(my_set.intersection({4, 5, 6}))  # 输出: {4, 6}

字典（Dictionary）：

  • 创建字典：使用花括号 {} 或 dict() 函数，或使用键值对的形式初始化字典。
  • 添加或修改键值对：通过键索引赋值来添加或修改字典中的键值对。
  • 访问值：使用键索引访问字典中的值，如果键不存在会引发 KeyError 异常，或使用 get() 方法访问值，如果键不存在会返回 None 或指定的默认值。
  • 删除键值对：使用 del 关键字删除指定键的键值对。
  • 其他常用方法：len() 返回字典中键值对的个数，keys() 返回字典中所有键的视图，values() 返回字典中所有值的视图，items() 返回字典中所有键值对的视图等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 创建字典
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

# 添加或修改键值对
my_dict['email'] = 'john@example.com'
my_dict['age'] = 31

# 访问值
print(my_dict['name'])             # 输出: John
print(my_dict.get('age', 0))       # 输出: 31
print(my_dict.get('address', ''))  # 输出: ''

# 删除键值对
del my_dict['city']

# 其他常用方法
print(len(my_dict))          # 输出: 3
print(my_dict.keys())       # 输出: dict_keys(['name', 'age', 'email'])
print(my_dict.values())     # 输出: dict_values(['John', 31, 'john@example.com'])
print(my_dict.items())      # 输出: dict_items([('name', 'John'), ('age', 31), ('email', 'john@example.com')])

DataFrame 操作

DataFrame是Pandas库中最常用的数据结构，它提供了灵活的数据处理和分析功能。下面是DataFrame的使用操作以及示意代码的整理：

创建DataFrame：

1
2
3
4
5
6
7
8
9
10
11
12
import pandas as pd

# 从列表创建DataFrame
data = [['Alice', 25], ['Bob', 30], ['Charlie', 35]]
df = pd.DataFrame(data, columns=['Name', 'Age'])

# 从字典创建DataFrame
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)

# 从CSV文件读取创建DataFrame
df = pd.read_csv('data.csv')

查看和操作DataFrame：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 查看DataFrame的前几行
df.head()

# 查看DataFrame的后几行
df.tail()

# 查看DataFrame的列名
df.columns

# 查看DataFrame的索引
df.index

# 查看DataFrame的统计信息
df.describe()

# 选择某列或多列
df['Name']
df[['Name', 'Age']]

# 选择某行或多行
df.loc[0]
df.loc[1:3]

# 条件筛选
df[df['Age'] > 30]

# 添加新列
df['City'] = ['New York', 'London', 'Paris']

# 删除列
df.drop('City', axis=1, inplace=True)

# 修改值
df.loc[0, 'Age'] = 26

# 排序
df.sort_values(by='Age')

# 合并DataFrame
df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'A': [7, 8, 9], 'B': [10, 11, 12]})
df = pd.concat([df1, df2])

数据处理和分析：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 缺失值处理
df.dropna()       # 删除包含缺失值的行
df.fillna(value)  # 用指定值填充缺失值

# 数据分组
grouped = df.groupby('City')
grouped.size()        # 每个城市的样本数量
grouped.mean()        # 每个城市的平均值
grouped['Age'].max()  # 每个城市年龄的最大值

# 数据聚合
df.groupby('City').agg({'Age': 'mean', 'Salary': 'sum'})

# 数据透视表
df.pivot_table(index='City', columns='Gender', values='Salary', aggfunc='mean')

# 数据排序和排名
df.sort_values(by='Salary', ascending=False)
df['Rank'] = df['Salary'].rank(ascending=False)

# 数据可视化
df.plot(x='Year', y='Salary', kind='line')
df.plot(x='Age', y='Salary', kind='scatter')