重庆建设工程交易中心官网zac博客seo

三、Pandas库

4.函数计算

3遍历

3.1.遍历Series对象

• 在讲解Series部分，有其他遍历方式

Series对象本身就是一个可迭代对象

• 示例：

import pandas as pd
s = pd.Series(['a','b','c','d','e','f',None])
for item in s:print(item, end=' ')#输出：a b c d e f None 

3.2.遍历DataFrame对象

3.2.1直接遍历会获取列标签

• 示例：

import pandas as pd
s = pd.DataFrame({'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),'two': pd.Series([1, 2, 3], index=['a', 'b', 'c'])
})
for item in s:print(item, end=' ')
# 输出: one two

3.2.2遍历行：itertuples()方法用于遍历 DataFrame 的行，返回一个包含行数据的命名元组

• 参数：index=False（默认True）,返回的数组是否包含行标签

• 示例：

import pandas as pd# 创建一个示例 DataFrame
data = {'A': [1, 2],'B': [4, 5]
}
df = pd.DataFrame(data, index=['a', 'b'])# 使用 itertuples() 遍历行-默认包含行标签
for row in df.itertuples():print(row)for i in row:print(i)# 忽略行标签
for row in df.itertuples(index=False):print(row)

• 输出

Pandas(Index='a', A=1, B=4)
a
1
4
Pandas(Index='b', A=2, B=5)
b
2
5Pandas(A=1, B=4)
Pandas(A=2, B=5)

3.2.3items()方法遍历

示例：
for key, value in df.items():for i in value:print(i)
解释：
key是列标签名，
value是列对应的值(是一个Series对象）-遍历value就是获取每个数据

4排序

4.1 sort_index

sort_index 方法把乱序的索引(行或列标签)进行排序

语法：

DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)

参数：

• axis：默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。

• ascending：指定是升序排序（默认True）还是降序排序（False）。

• inplace：如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

• 示例：

import pandas as pd
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3],'B': [4, 5, 6],'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])
print("原数组：")
print(df)
# 按行索引标签排序，不管值的大小
df_sorted = df.sort_index()
print("按行索引标签排序：")
print(df_sorted)

• 输出：

原数组：A  B  C
b  1  4  7
c  2  5  8
a  3  6  9
按行索引标签排序：A  B  C
a  3  6  9
b  1  4  7
c  2  5  8

4.2 sort_values

sort_values 方法用于根据指定列的值进行排序。

语法：

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')

参数：

• by：指定根据什么标签排序

• axis：指定标签是行还是列。默认为 0，表示行排序，如果设置为 1，就列排序。

• ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。

• inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

• kind：排序算法。默认为 ‘quicksort’，也可以选择 ‘mergesort’(归并排序) 或 ‘heapsort’(堆排序)。

• na_position：指定缺失值（NaN）的位置。可以是 ‘first’ 或 ‘last’。

• 示例：

import pandas as pd# 创建一个示例 DataFrame
data = {'A': [3, 2, 1],'B': [9, 5, 4],'C': [6, 8, 7]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])
print(df)
# 按列 'A' 排序,默认升序排序
df = df.sort_values(by='A',axis=0)
print(df)
# 输出--排序行的顺序，根据A的大小A  B  C
b  3  9  6
c  2  5  8
a  1  4  7A  B  C
a  1  4  7
c  2  5  8
b  3  9  6

5.去重drop_duplicates

drop_duplicates 方法用于删除 重复行

语法：

drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)

参数：

• by：指定判断哪些列有没有重复项。默认判断所有列。

• subset：与 by 类似，但用于指定列的子集。

• keep：如何处理重复项：

  • ‘first’：保留第一个出现的重复项（默认值）。
  • ‘last’：保留最后一个出现的重复项。
  • False：删除所有重复项。

• inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。

• 示例：

import pandas as pd
data = {'A': [1, 2, 2, 3],'B': [4, 5, 5, 6],'C': [7, 8, 8, 9]
}
df = pd.DataFrame(data)
print(df) # 原数据
# A列有重复的数据，就删除整行
df = df.drop_duplicates("A", keep="first")
print(df)
# 输出：A  B  C
0  1  4  7
1  2  5  8
2  2  5  8
3  3  6  9A  B  C
0  1  4  7
1  2  5  8
3  3  6  9

6.先分组在计算

6.1 groupby

groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。

语法：

DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

参数：

• by：用于分组的列名或列名列表。
• axis：指定沿着哪个轴进行分组。默认为 0，表示按行分组。
• level：用于分组的 MultiIndex 的级别。
• as_index：布尔值，指定分组后索引是否保留。如果为 True，则分组列将成为结果的索引；如果为 False，则返回一个列包含分组信息的 DataFrame。
• **sort：**布尔值，指定在分组操作中是否对数据进行排序。默认为 True。
• group_keys：布尔值，指定是否在结果中添加组键。
• squeeze：布尔值，如果为 True，并且分组结果返回一个元素，则返回该元素而不是单列 DataFrame。
• observed：布尔值，如果为 True，则只考虑数据中出现的标签。

示例：

import pandas as pd
# 创建一个示例 DataFrame
data = {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],'C': [1, 2, 3, 4, 5, 6, 7, 8],'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)
# 按列 'A' 分组
grouped = df.groupby('A')
# 查看分组结果
for name, group in grouped:print(f"Group: {name}")print(group)
#==================================
# 分组计算——分别计算两个组C列的平均值
mean = df.groupby('A')['C'].mean()
print(mean)
#==================================# transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。
# 平均值
mean = grouped['C'].transform(lambda x: x.mean())
df['C_mean'] = mean # 将转化的数据保持在数组中
# 正态分布标准化
normal = grouped['C'].transform(lambda x: (x-x.mean()) / x.std())
df['C_Normal'] = normal
print(df)

输出：

Group: barA      B  C   D
1  bar    one  2  20
3  bar  three  4  40
5  bar    two  6  60
Group: fooA      B  C   D
0  foo    one  1  10
2  foo    two  3  30
4  foo    two  5  50
6  foo    one  7  70
7  foo  three  8  80
#==================================
A
bar    4.0
foo    4.8
Name: C, dtype: float64
#==================================A      B  C   D  C_mean  C_Normal
0  foo    one  1  10     4.8 -1.327018
1  bar    one  2  20     4.0 -1.000000
2  foo    two  3  30     4.8 -0.628587
3  bar  three  4  40     4.0  0.000000
4  foo    two  5  50     4.8  0.069843
5  bar    two  6  60     4.0  1.000000
6  foo    one  7  70     4.8  0.768273
7  foo  three  8  80     4.8  1.117488

6.2 filter过滤

​ 通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集

示例：

import pandas as pd# 创建一个示例 DataFrame
data = {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],'C': [1, 2, 3, 4, 5, 6, 7, 8],'D': [10, 20, 30, 40, 50, 60, 70, 80]
}
df = pd.DataFrame(data)
# 按列 'A' 分组，并过滤掉列 'C' 的平均值大于 4 的组
filtered = df.groupby('A').filter(lambda x: x['C'].mean() > 4)
print(filtered) # bar组的C列平均值是4，所以被过滤了

输出：

     A      B  C   D
0  foo    one  1  10
2  foo    two  3  30
4  foo    two  5  50
6  foo    one  7  70
7  foo  three  8  80

7.合并

未完待续…