安装pandas

pip install pandas -i https://mirrors.aliyun.com/pypi/simple/

使用pandas

直接导入即可 import pandas as pd

pandas的数据结构

pandas提供了两种主要的数据结构：Series 和 DataFrame,类似于python提供list列表，dict字典，tuple元组等数据类型用于存储数据。

1. Series

Series 是一种一维的数组（类似于 Python 的列表），可以存储任何数据类型（整数、字符串、浮点数、Python对象等）。Series 是一种带有标签的数据结构，每个数据点都有一个索引。

创建 Series

创建的series结构，默认索引从0开始（像list的索引一样），但是可以指定索引。

1）从列表创建Series

import pandas as pd
data = [1, 2, 3, 4, 5]
s = pd.Series(data)
print(s)

2）从字典创建 Series，键作为索引

import pandas as pd
data_dict = {'a': 1, 'b': 2, 'c': 3}
s = pd.Series(data_dict)
print(s)

3）指定索引创建Series

import pandas as pd
data = [1, 2, 3, 4, 5]
s = pd.Series(data, index=['a', 'b', 'c', 'd', 'e'])
print(s)

Series的基本属性

• values：返回 Series 中的数据值。
• index：返回 Series 中的索引。
• dtype：返回 Series 中数据的数据类型。
• name：返回或设置 Series 的名称。

举例：定义一个series接口数据并指定索引和名称

data = [[1, 2, 3], [4, 5,6]]
s = pd.Series(data, name='一维数组',index=['a', 'b'])
print(f'值：{s.values}')
print(f'索引：{s.index}')
print(f'数据类型 {s.dtype}')
print(f'名称 {s.name}')

Series的函数

1）value_counts函数：对Series对象进行计数

1. normalize：默认为False。设置为True，则函数返回每个值占总数的比例，而不是计数。
2. sort：是否对结果进行排序。
3. ascending：默认为False，计数结果按降序排列；设置为True，则按升序对计数进行排序。
4. dropna：默认为True，表示从计数中排除NaN值。设置为False，则包含NaN值的计数也会被纳入统计。
5. bins：整数、字符串或序列。如果给定，则返回的Series将包含给定数量的bin（箱）的计数。这个参数主要用于数值型数据的分箱处理，我们通常使用cut()函数进行分箱。

举例：

1）定义Series数据，计数后按照升序排列：

data_list =  ['A', 'C', 'B', 'A', 'A', 'C', 'B', 'C','C']
se = pd.Series(data_list)
print(se.value_counts(ascending=True))

结果：

B 2

A 3

C 4

Name: count, dtype: int64

2）对数值型Series对象进行分箱后统计计数

data_list =  [1, 2,3,4,3,2,1,2,4,5,7,8,4,3,15,10]
se = pd.Series(data_list)
#bins=3 自动分了三个数据范围
print(se.value_counts(ascending=True,bins=3))

结果：

(10.333, 15.0] 1

(5.667, 10.333] 3

(0.985, 5.667] 12

Name: count, dtype: int64

3）使用pandas.cut()函数进行分箱处理

data_list =  [1, 2,3,4,3,2,1,2,4,5,7,8,4,3,15,10]
# 指定箱子的边界
bins = [0, 2, 4, 6, 8]
labels = ['0-2', '2-4', '4-6', '6-8']
cut_data = pd.cut(data_list, bins=bins, labels=labels)

# 使用value_counts()函数对分箱后的数据进行计数
counts = cut_data.value_counts()
# 打印结果
print(counts)

结果：

0-2 5

2-4 6

4-6 1

6-8 2

Name: count, dtype: int64

2. DataFrame

DataFrame 是一个二维的表格数据结构，具有标记的轴（行和列）。其中每一列相当于一个Series。

创建 DataFrame

和Series结构一样默认索引从0开始，当然也可以指定索引。

1）从字典创建 DataFrame，字典的键是列名

import pandas as pd
data_dict = {
'name': ['lilei', 'lili', 'wanglei'],
'age': [25, 30, 35],
'city': ['shanghai', 'shenzhen', 'nanjing']}
df = pd.DataFrame(data_dict)
print(df)

2）从列表的列表创建DataFrame

data = [
['lilei', 25],
['lili', 30],
['wanglei', 35]
]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)

3）从Numpy 数组创建DataFrame并指定列名和索引

import numpy as np
data = np.array([[1, 2], [3, 4], [5, 6]])
df = pd.DataFrame(data, columns=['A', 'B'],index=['a','b','c'])
print(df)

Series和DataFrame数据的常用函数和功能

head(n)：返回前 n 个元素,默认返回前5个

tail(n)：返回后 n 个元素，默认返回后5个。

unique()：返回 Series 中的唯一值（去掉重复的值）。

isnull()：返回一个布尔 Series，指示每个值是否为 NaN。

dropna()：删除所有 NaN值（numpy.nan）或者None值,返回一个新的数据

举例：定义一个series结构数据，打印下上面方法获取的数据

data = [1, 2, 3, 4, 5,[6,7],[8],None,{'a':10}]
s = pd.Series(data)
print(f'前3个元素\n {s.head(3)}')
print(f'后3个元素\n {s.tail(3)}')
print(f'判断是否为null\n {s.isnull()}')

举例：定义一个series结构数据，打印删除NaN值后的数据

import numpy as np
data = [1, 2, 3, 4, 5,None,np.nan]
s = pd.Series(data)
new_s =s.dropna()
print(f'删除NaN值\n {new_s}')

举例：定义一个series结构数据，打印去重后的数据

data = [1, 2, 3, 4, 5,4,5,6]
s = pd.Series(data)
print(f'唯一值 {s.unique()}')

to_dict函数：将DataFrame数据转换为字典

字典的键和值对应的是列名和列值

举例：读取csv文件内容，并转换为字典

import pandas as pd
dataframe = pd.read_csv("1.csv")
print(dataframe)
#将DataFrame数据格式转换为字典
print(dataframe.to_dict())

结果如下：

选择列数据

import pandas as pd
dataframe = pd.read_csv("1.csv")

• 选择某一列数据

#选择Nmae这一列
print(dataframe['zx`	Name']) 
#选择Age这一列
print(dataframe.age) 

#通过Ioc函数选择Name这一列
print(dataframe.loc[:,['Name']])

返回的某一列的数据类型是一个Series类型，对某列数据可以做循环打印该列的值。

for i in dataframe.Name:
   print(i)

• 选择多列

#选择Nmae,age这两列
print(dataframe[['Name','age']])
#通过loc()函数选择Name和age两列
print(dataframe.loc[:,['Name','age']])

选择行数据

使用方式类似于list的切片操作

#取前3行数据
print(dataframe[0:3]) 
 #取倒数第4行和第5行
print(dataframe[-4:-2])
#取前10行中每2行取1个
print(dataframe[0:10:2]) 

通过iIoc函数获取多行数据

#取前10行数据
print(dataframe.iloc[:10,:]) 

选择指定的行和列数据

通过Ioc函数取某些行和列数据

print(dataframe.loc[0:3,['Name']])
print(dataframe.loc[0:3,['Name','age']])

按条件选择

举例：筛选age列大于25的数据

print(dataframe[dataframe.age > 25])

举例：筛选性别为男的数据

print(dataframe[dataframe.sex == 'man'])

举例： 筛选索引等于0的数据

print(dataframe[dataframe.index == 0])

举例：筛选性别为男并age大于25的数据

print(dataframe[(dataframe.sex == 'man') & (dataframe.age > 25)])

举例：筛选年龄大于25的Name这一列的数据

print(dataframe[dataframe.age > 25].loc[:,['Name']])

sort_values函数：使用该函数进行排序

参数介绍

• by：传入单个字符串或字符串列表（1个或者多个列名），表示按照列名进行排序。
• axis：默认为0。0表示按列的值排序，1表示按行的值排序;一般不使用
• ascending：布尔值或布尔值列表，默认为True。True表示升序排序，False表示降序排序。如果是一个列表，则列表中的每个元素对应by参数中每个列的排序顺序。
• inplace：布尔值，默认为False。如果为True，则直接修改原DataFrame并返回None；如果为False，则返回一个新的排序后的DataFrame副本。
• kind：排序算法的选择，默认为'quicksort'。其他选项包括'mergesort'和'heapsort'。对于大数据集，'quicksort'通常是最快的，但不一定是最稳定的。
• na_position：{'first', 'last'}，默认为'last'。表示缺失值（NaN）应该被放在排序后的数组的开始还是结束。
• ignore_index：布尔值，默认为False。如果为True，则结果DataFrame的索引将被重置为默认的整数索引。

测试代码：

1）按列排序（升序）

print(dataframe.sort_values(by='Name'))
print(dataframe.sort_values(by=['Name','age']))

2）按列排序（倒序）

print(dataframe.sort_values(by='age',ascending=False))

3）不同列排列顺序不同（比如第一列正序，第二列倒序）

print(dataframe.sort_values(by=['Name','age'],ascending=[True,False]))

insert函数：插入列数据

插入某一列数据，参数介绍：

• loc： 传入整数，代表插入在第几列（0代表第1列）
• column：列名
• value：每列的值（单个值表示每一行值相同；传入列表，列表中的元素对应每一行的值）
• allow_duplicates：为True表示允许列名重复，否则不允许

测试代码：

#对DataFrame对象插入数据
dataframe.insert(2,'area','China')
dataframe.insert(3,'area',['China','America','korea','japan','China','America','korea','japan'],allow_duplicates=True)
print(dataframe)

结果：

groupby函数：分组聚合

支持对一个或多个列的值进行分组，应用聚合函数（如求和、平均值、最大值、最小值等）或其他操作。类似于大家使用sql查询数据库语句时通过group by分组聚合一样。

参数介绍：

1. by：指定要根据哪个字段进行分组。可以是一个列名或者包含多个列名的列表。默认值None，表示不分组。
2. axis：指定分组的方向。0或index表示按列分组（即沿着行的方向进行分组）。1或columns表示按行分组（即沿着列的方向进行分组）。默认情况下是0，即按列分组。
3. level：当DataFrame的索引为多重索引时，level参数指定用于分组的索引级别。可以传入多重索引中索引的下标（如0, 1, ...）或索引名。如果传入多个级别，则使用列表形式。level参数不能与by参数同时使用。
4. as_index：指定分组后的结果是否将分组列的值作为索引。如果按单列分组，结果默认是单索引；如果按多列分组，结果默认是多重索引。将as_index设置为False可以重置索引为默认的整数索引（0, 1, ...）。
5. sort：指定分组结果是否按照分组列的值进行排序。默认情况下是True，即按升序排列。将sort设置为False则不排序，这可能会提升性能。
6. observed：指定是否观察数据的层次结构。在某些情况下，当分组列包含大量唯一值时，设置observed=True可以提高性能，因为它只考虑在数据中出现的值。
7. dropna：默认情况下，分组列的NaN值在分组结果中不保留。将dropna设置为False可以保留NaN分组。

函数执行后返回的是DataFrameGrouyBy对象，该对象支持多个聚合函数，类似如下：

1. sum()：计算分组数据的总和。
2. mean()：计算分组数据的平均值。
3. max()：找出分组数据中的最大值。
4. min()：找出分组数据中的最小值。
5. median()：计算分组数据的中位数。
6. std()：计算分组数据的标准差，反映数据的离散程度。
7. var()：计算分组数据的方差，也是反映数据离散程度的一个指标。
8. count()：计算分组中非空（非NA/null）值的数量。
9. first()：返回分组中的第一个值。
10. last()：返回分组中的最后一个值。
11. nth(n)：返回分组中的第n个值，n可以是正数也可以是负数，负数表示从末尾开始计数。
12. size()：返回分组中的元素数量。
13. prod()：计算分组数据的乘积。
14. nunique()：计算分组中唯一值的数量。

此外，pandas的agg()函数允许你传入一个函数列表或字典，对分组数据应用多个聚合函数。例如：agg(['sum', 'mean', 'max']) 或者 agg({'某一列': ['sum', 'mean', 'max']})

举例：定义一个DataFrame的数据

import pandas as pd
data_dict = {'group': ['A', 'C', 'B', 'A', 'A', 'C', 'B', 'B', 'C'],
'name': ['lilei', 'lili', 'wanglei', 'wangning', 'wangling', 'wangming', 'wangyu', 'liyi', 'xiaolei'],
'age': [25, 30, 35,21,23,24,25,26,32],
'city': ['shanghai', 'shenzhen', 'nanjing','shanghai', 'shenzhen', 'nanjing','shanghai', 'shenzhen', 'nanjing']}
df = pd.DataFrame(data_dict)

1）按照单个group列分组，统计age列的汇总值

print(df.groupby(by='group')['age'].sum())

2）按照多个列分组后，统计age列汇总值，最大值，最小值等

#以下两种方式都可以
print(df.groupby(by=['group','city'])['age'].agg(['sum','max','min']))
print(df.groupby(by=['group','city']).agg({'age':['sum','max','min']}))

3）按照单个group列分组，统计age列的汇总值并添加为新的一列数据

我们可以使用transform函数对每个组应用一个聚合函数，该函数将返回与原始DataFrame形状相同的对象

#聚合后添加sum列
df['sum'] = df.groupby(by='group')['age'].transform('sum')
print(df)

4）按照单个group列分组，统计age列的汇总值，并使用filter函数过滤某些数据

# 只保留'age'列总和大于80的组
filtered =  df.groupby(by='group').filter(lambda x: (x['age'].sum() > 80))
print(filtered)

共勉： 东汉·班固《汉书·枚乘传》：“泰山之管穿石，单极之绠断干。水非石之钻，索非木之锯，渐靡使之然也。”

-----指水滴不断地滴，可以滴穿石头；

-----比喻坚持不懈，集细微的力量也能成就难能的功劳。

----感谢读者的阅读和学习，谢谢大家。