pandas
一. Series一维数组
1. 创建一维数组
方法一：
pd.Series(列表，index=列表,columns=列表)
pd.Series(numpy一维数组，index=列表,columns=列表)
返回<class ‘pandas.core.series.Series’> 类型的一维数组
import pandas as pd
t1 = pd.Series([8,6,3,4])
print(t1)
t2 = pd.Series([1,2,3,4],index=list('ABCD'))
print(t2)
# 运行结果
0 8
1 6
2 3
3 4
dtype: int64
A 1
B 2
C 3
D 4
dtype: int64
<class 'pandas.core.series.Series'>
方法二：
pd.Series(dict)
import pandas as pd
t1 = pd.Series({"A":7,'B':2,'C':3,'D':4})
print(t1)
#运行结果
A 7
B 2
C 3
D 4
dtype: int64
2. astype修改数据类型
df = pd.Series(…)
df.astype(数据类型)
原数组中的数据类型保持不变
import pandas as pd
df = pd.Series({"A":6,'B':2,'C':3,'D':4})
print(df)
df1 = df.astype(float)
print(df1)
# 运行结果
A 6
B 2
C 3
D 4
dtype: int64
A 1.0
B 2.0
C 3.0
D 4.0
dtype: float64
3. 切片/索引（index值索引、位置索引、布尔索引）
import pandas as pd
t1 = pd.Series({"A":5,'B':8,'C':3,'D':4})
#index值索引
print(t1['A'])
print(t1['C'])
#位置索引
print(t1[1])
print(t1[2])
#布尔索引
print(t1[t1>1])
# 运行结果
5
3
# 运行结果
8
3
4. 获取所有索引值和数据值
s = pd.Series(…)
s.index ---------------返回<class’pandas.core.indexes.base.Index’>
s.values -----------------返回<class ‘numpy.ndarray’>类型
s.index可使用for循环取值，也可使用list强制转换为列表
import pandas as pd
s = pd.Series({"A":1,'B':2,'C':3,'D':4})
print(s.index)
print(type(s.index))
print(list(s.index))
print(s.values)
# 运行结果
Index(['A', 'B', 'C', 'D'], dtype='object')
<class 'pandas.core.indexes.base.Index'>
['A', 'B', 'C', 'D']
[1 2 3 4]
<class 'numpy.ndarray'>
二、DataFrame二维数组
1. 创建DataFrame二维数组
数据帧(DataFrame)是二维数据结构，即数据以行和列的表格方式排列
pd.DataFrame( data, index, columns, dtype, copy)
data 可以使用多种形式表示，ndarray，Series， list，dict，constants
index 同Series，默认使用np.arrange(n)表示
columns 列标签，默认命名是np.arrange(n),可以自定义设置
dtype 每一列的数据类型
copy 默认false，不进行复制
方式一
import pandas as pd
data={
'Name':['Ella','Leo','Mark','Lily'],
'Sex':['f','m','m','f'],
'MScore':[99,88,92,85]
}
dataframe=pd.DataFrame(data,['a','b','c','d'])
print(dataframe)
#运行结果
Name Sex MScore
a Ella f 99
b Leo m 88
c Mark m 92
d Lily f 85
方式二
d1 = pd.DataFrame([{},{},{}])
import pandas as pd
import numpy as np
data=[{'Name':'Ella','sex':'f','Mscore':99},
{'Name':'Leo','sex':'m','Mscore':88},
{'Name':'Mark','sex':'m','Mscore':92},
{'Name':'MScore','sex':'f','Mscore':85}
]
dataframe=pd.DataFrame(data,['a','b','c','d'])
print(dataframe)
# 运行结果
Name Sex MScore
a Ella f 99
b Leo m 88
c Mark m 92
d Lily f 85
注：使用字典创建DateFrame数组时，对缺失字段进行Nan值填充
2. DataFrame数组基本属性
df.index 行索引值
df.columns 列索引值
df.values 数组值
df.shape 行数 列数
df.dtype 每列数据类型
df.ndim 数组维度
df.describe() 数组统计信息
df.info() 数组信息
import pandas as pd
data=[{'Name':'Ella','sex':'f','Mscore':99},
{'Name':'Leo','sex':'m','Mscore':88},
{'Name':'Mark','sex':'m','Mscore':92},
{'Name':'MScore','sex':'f','Mscore':85}
]
df=pd.DataFrame(data,['a','b','c','d'])
print(df)
print('行索引',list(df.index))
print('列索引',df.columns)
print('数据',df.values)
print('行列数',df.shape)
print('数据类型',df.dtypes)
print('数组维度',df.ndim)
print('数组信息')
print(df.info())
print('数组统计信息',df.describe())
3. DataFrame数据查询
df.head([n]) 查询数组前几行，默认查询前5行
df.tail([n]) 查询数组后几行，默认查询后5行
df.info() 数组相关信息：行/列索引，列非空值个数，列类型，内存占用
df.describe() 快速综合统计结果。个数，均值，标准差，最大值，四位分数，最小值
import pandas as pd
import numpy as np
data={
'Name':['Ella','Leo','Mark','Lily'],
'Sex':['f','m','m','f'],
'MScore':[99,88,92,85]
}
df=pd.DataFrame(data,['a','b','c','d'])
print(df)
print('前5行数据')
print(df.head())
print('后5行数据')
print(df.tail())
4. DataFrame列排序
df.sort_values(by=‘列名’,ascending=True) ----默认升序
df.sort_values(by=‘列名’，ascending=False) ----降序
import pandas as pd
data={
'Name':['Ella','Leo','Mark','Lily'],
'Sex':['f','m','m','f'],
'MScore':[99,88,92,85]
'age':[34,27,53,17]
}
df=pd.DataFrame(data,['a','b','c','d'])
print(df)
print('升序')
print(df.sort_values(by='age'))
print('倒序')
print(df.sort_values(by='age',ascending=False))
5. 切片/索引（index值索引、位置索引、布尔索引）
5.1.通过index值索引获取数据
获取一个值
df.loc[行索引,列索引]
获取一行数据
df.loc[行索引]
获取多个不连续的值
df.loc[[行索引1,行索引2，行索引3],[列索引1,列索引2]]
df.loc[行索引,[列索引1,列索引2，列索引3]]
df.loc[[行索引1,行索引2,行索引3],列索引1]
获取多个连续的值
df.loc[行索引1:,[列索引1,列索引2，列索引3]]
df.loc[行索引1:行索引2,[列索引1,列索引2,列索引3]]
df.loc[[行索引1:行索引2],[列索引1:列索引2]]
df.loc[行索引,列索引]
获取多个不连续的值
df.loc[[行索引1,行索引2,行索引3],[列索引1,列索引2]]
df.loc[行索引,[列索引1,列索引2，列索引3]]
df.loc[[行索引1,行索引2,行索引3],列索引1]
import pandas as pd
data={
'Name':['Ella','Leo','Mark','Lily'],
'Sex':['f','m','m','f'],
'MScore':[99,88,92,85],
'age':[30,41,18,27]
}
df=pd.DataFrame(data,index=['a','b','c','d'])
print(df)
print(df)
print(df.loc['a','Sex'])
print(df.loc[['c','d'],'MScore'])
print(df.loc[['a','c'],['Sex','Name']])
print(df.loc['a':'c','Sex':'age'])
5.2. 通过位置索引获取数据(用法类似于df.loc())
df.iloc[行索引值，列索引值]
import pandas as pd
import numpy as np
data={
'Name':['Ella','Leo','Mark','Lily'],
'Sex':['f','m','m','f'],
'MScore':[99,88,92,85],
'age':[30,41,18,27]
}
df=pd.DataFrame(data,index=['a','b','c','d'])
print(df)
print(df.iloc[1,1])
print(df.iloc[[1,2],2])
print(df.iloc[[1,1],[1,2]])
print(df.iloc[1:3,1:3])
5.3. DataFrame赋值操作
可以对上述所有的索引结果进行赋值
import pandas as pd
data={
'Name':['Ella','Leo','Mark','Lily'],
'Sex':['f','m','m','f'],
'MScore':[99,88,92,85],
'age':[30,41,18,27]
}
df=pd.DataFrame(data,index=['a','b','c','d'])
print(df)
df.loc['c','MScore'] =99
df.iloc[0,2] = 100
print(df)
5.4. DataFrame数组的布尔索引
5.4.1 普通布尔索引
import pandas as pd
import numpy as np
d1 = pd.DataFrame(np.arange(9).reshape(3,3),\
index=list('ABC'),columns=list('XYZ'))
print(d1)
print(d1['X']<3)
print(d1[d1['X']<3])
# 运行结果
X Y Z
A 0 1 2
B 3 4 5
C 6 7 8
A True
B False
C False
Name: X, dtype: bool
X Y Z
A 0 1 2
5.4.2 多条件布尔索引
import pandas as pd
import numpy as np
d1 = pd.DataFrame(np.arange(9).reshape(3,3),\
index=list('ABC'),columns=list('XYZ'))
print(d1)
print((d1['X']>0) & (d1['X']<5) )
# 运行结果
X Y Z
A 0 1 2
B 3 4 5
C 6 7 8
A False
B True
C False
6. 缺失值的处理
pd.isnull(t) 判断数组t中的NaN值
pd.notnull(t) 判断数组t中的不为NaN的值
方式一：删除NaN数据所在的行或列
pd.dropna(axis=0,how=“any”,inplace=False])
axis = 0 删除NaN值所在的行
axis=1 删除NaN值所在的列
how=“any”/“all” —选择只要存在一个或者全部为NaN值才进行删除
inplace=False —是否在原数组中进行修改
import pandas as pd
import numpy as np
df = pd.DataFrame([[0,1,2],[np.nan,4,5],[9,10,np.nan]])
print(df)
print(df.dropna(axis=0))
# 运行结果
0 1 2
0 0.0 1 2.0
1 NaN 4 5.0
2 9.0 10 NaN
0 1 2
0 0.0 1 2.0
方式二：使用统计数值替换NaN值
df.fillna(number /t.mean()/…)
可用具体数值或者平均值填充
import pandas as pd
import numpy as np
df = pd.DataFrame([[0,1,2],[np.nan,4,5],[9,10,np.nan]])
print(df)
print(df.fillna(df[0].mean())) # 对所有的NaN值使用第一行的平均值填充
print(df[0].fillna(df[0].mean())) # 只对第一行的NaN值使用第一行的平均值填充
# 运行结果
0 1 2
0 0.0 1 2.0
1 NaN 4 5.0
2 9.0 10 NaN
0 1 2
0 0.0 1 2.0
7. DataFrame数据表合并
7.1 join合并（并集）
df1.join(df2), 默认情况下将行索引相同的合并到一起，不改变原数组
相同行索引显示值，行索引不同显示NaN值
data1={'name':['wang','zhang','li','gong','ling'],
'age':[12,45,43,61,34],
'sex':['women','man','man','women','man'],
'birth':[1995,2001,2011,2013,2015]
}
df1=pd.DataFrame(data1,index=['a','b','c','d','e'])
data2={
'nation':['中国','美国','俄罗斯','泰国','意大利'],
'民族':['汉族','傣族','伊拉克族','美族','维吾尔族'],
}
df2=pd.DataFrame(data2,index=['a','b','c','d','e'])
print(df1)
print(df2)
# join拼接
dfa=df1.join(df2)
print(dfa)
7.2 merge合并
merge()是对DataFrame进行行连接的，对于两个DataFrame，可以用参数on指定用来merge的共同列，也可以利用left_on和right_on分别指定用来merge的列，还可以利用how参数指定merge的方式。
how可以为inner、outer、left、right，默认为inner。
inner表示以两者交集方式merge;
outer表示并集;
left表示以左边的df为准;
right表示以右边的df为准；
如果指定merge的列元素不是唯一的，是多对多的，则以笛卡尔积的形式merge，保证merge后不遗漏数据；此外，还可以利用left_index和right_index布尔参数进行索引merge，利用sort布尔参数选择是否merge排序等。
如果是直接根据索引进行合并的话，DataFrame有一个直接的join()方法，默认按索引合并
| 操作 | 执行代码 |
|---|---|
| pd.merge(df,df1,how=‘inner’) | 匹配合并，交集，默认是两个数据集相同的字段 |
| pd.merge(df,df1,how=‘left’) ) | 左连接 |
| pd.merge(df,df1,how=‘right’) | 右连接 |
| pd.merge(df,df1,how=‘outer’) | 并集 |
| df1.merge(df2,left_on=‘on’,right_on=‘on’, how=‘inner’) | 交集 |
| df1.merge(df2,left_on=‘on’,right_on=‘on’, how=‘outer’) | 并集 |
| df1.merge(df2,left_on=‘on’,right_on=‘on’, how=‘left’) | 左连接 |
| df1.merge(df2,left_on=‘on’,right_on=‘on’, how=‘right’) | 右连接 |
| left.join(right, on=‘key’) | 左连接 |
import pandas as pd
data1={'name':['wang','zhang','li','gong','ling'],
'age':[12,45,43,61,34],
'sex':['women','man','man','women','man'],
'birth':[1995,2001,2011,2013,2015]
}
df1=pd.DataFrame(data1,index=['a','b','c','d','e'])
data2={
'nation':['中国','美国','俄罗斯','泰国','意大利'],
'民族':['汉族','傣族','伊拉克族','美族','维吾尔族'],
'age':[12,45,43,74,34]
}
df2=pd.DataFrame(data2,index=['a','b','c','d','e'])
print(df1)
print(df2)
merge合并左连接
#merge左连接
dfa1=df1.merge(df2,left_on='age',right_on='age',how='left')
print(dfa1)
dfa2=df1.merge(df2,how='left')
print(dfa2)
dfa3=pd.merge(df1,df2,left_on='age',right_on='age',how='left')
print(dfa3)
dfa4=pd.merge(df1,df2,how='left')
print(dfa4)
merge合并右连接
#右连接
dfb1=df1.merge(df2,left_on='age',right_on='age',how='right')
print(dfb1)
dfb2=df1.merge(df2,how='right')
print(dfb2)
dfb3=pd.merge(df1,df2,left_on='age',right_on='age',how='right')
print(dfb3)
dfb4=pd.merge(df1,df2,how='right')
print(dfb4)
merge合并内连接
#内连接
dfc1=df1.merge(df2,left_on='age',right_on='age',how='inner')
print(dfc1)
dfc2=df1.merge(df2,how='inner')
print(dfc2)
dfc3=pd.merge(df1,df2,left_on='age',right_on='age',how='inner')
print(dfc3)
dfc4=pd.merge(df1,df2,how='inner')
print(dfc4)
merge合并外连接
#外连接
dfd1=df1.merge(df2,left_on='age',right_on='age',how='outer')
print(dfd1)
dfd2=df1.merge(df2,how='outer')
print(dfd2)
dfd3=pd.merge(df1,df2,left_on='age',right_on='age',how='outer')
print(dfd3)
dfd4=pd.merge(df1,df2,how='outer')
print(dfd4)
7.3 轴向连接
轴向连接，就是直接将多个Series或者DataFrame按某个轴的方向进行连接。这不同于merge和join，轴向连接不是指定某个列进行合并，而是直接将多个对象沿着指定的轴进行堆叠，不管这个轴的索引上多个对象是否有重复值。
concat()实际上就是沿着某个轴进行堆叠。此外concat()还有一个比较重要的参数是join，值可为inner和outer，默认为outer，表示除了指定堆叠的轴外的其他轴上的合并方式，默认为并集。
import pandas as pd
data1={'name':['wang','zhang','li','gong','ling'],
'age':[12,45,43,61,34],
'sex':['women','man','man','women','man'],
'birth':[1995,2001,2011,2013,2015]
}
df1=pd.DataFrame(data1,index=['a','b','c','d','e'])
data2={
'nation':['中国','美国','俄罗斯','泰国','意大利'],
'民族':['汉族','傣族','伊拉克族','美族','维吾尔族'],
'age':[12,45,43,74,34]
}
df2=pd.DataFrame(data2,index=['a','b','c','d','e'])
print(df1)
print(df2)
# 1.axis为1进行concat
df4=pd.concat([df1,df2],axis=1,keys=['df1','df2'])
print(df4)
# 2.axis为0进行concat
df5=pd.concat([df1,df2],axis=0,keys=['df1','df2'])
print(df5)
# 3.axis为0进行concat，但axis为1合并方式为交集
df6=pd.concat([df1,df2],axis=0,keys=['df1','df2'],join='inner')
print(df6)
7.4 纵向合并
df1.append(df2)
import pandas as pd
data1={'name':['wang','zhang','li','gong','ling'],
'age':[12,45,43,61,34],
'sex':['women','man','man','women','man'],
'birth':[1995,2001,2011,2013,2015]
}
df1=pd.DataFrame(data1,index=['a','b','c','d','e'])
data2={
'name':['xiaoming','zhanghua','lishi','gongsheng','lining'],
'age':[12,54,43,71,34],
'sex':['women','man','man','women','man'],
'birth':[1997,2101,2014,2013,2019]
}
df2=pd.DataFrame(data2,index=['a','b','c','d','e'])
#append纵向合并
dff=df1.append(df2)
print(dff)
DataFrame数组之groupby分组
df1.groupby(by=‘columns_name’) 返回DataFrameGroupBy类型数据，可对其进行遍历和聚合方法
注：对groupby类型数据遍历后，每次翻返回元组类型，元组中第一个元素是分组后每组的名称，第二个元素是DateFrame类型，存储改组对应的其他列数据
import numpy as np
import pandas as pd
df1 = pd.DataFrame([{"name":'sunwukon',"gender":'man',"age":18},\
{"name":'zhubajie',"gender":'woman',"age":22},\
{"name":'shaheshang',"gender":'man',"age":24}])
gr = df1.groupby(by='gender')
print(type(gr))
for temp in gr:
print(temp)
print(temp[0],type(temp[0]))
print(temp[1], type(temp[1]))
8. DataFrame数组之聚合方法
统计函数
count（） 统计个数或总数
sum() 求和
mean() 求均值
std() 标准差
var() 方差
min() 最小值
max() 最大值
import numpy as np
import pandas as pd
df1 = pd.DataFrame([{"name":'sunwukon',"gender":'man',"age":18},\
{"name":'zhubajie',"gender":'woman',"age":22},\
{"name":'shaheshang',"gender":'man',"age":24}])
gr = df1.groupby(by='gender')
print(gr.count()) # 统计每个组中的数据个数
print(gr['gender'].count()) # 统计分组后gender一列的数据个数
# 运行结果
age name
gender
man 2 2
woman 1 1
gender
man 2
woman 1
Name: gender, dtype: int64
补充
df[‘列名’] 返回值为Series类型
df[[‘列名’]] 返回值为DataFrame类型
import numpy as np
import pandas as pd
df1 = pd.DataFrame([{"name":'sunwukon',"gender":'man',"age":18},\
{"name":'zhubajie',"gender":'woman',"age":22},\
{"name":'shaheshang',"gender":'man',"age":24}])
print(df1['name'],type(df1['name']))
print(df1[['name']],type(df1[['name']]))
# 运行结果
0 sunwukon
1 zhubajie
2 shaheshang
Name: name, dtype: object <class 'pandas.core.series.Series'>
name
0 sunwukon
1 zhubajie
2 shaheshang <class 'pandas.core.frame.DataFrame'>
9. 索引和复合索引
df.index 获取df数组的所有行索引，返回Index类型，(可进行遍历和list()强制类型转换)
df.index=[‘name1’,‘name2’] 改变数组的行索引名，对原数组修改
df.reindex=[‘name1’,‘name2’,inplace=Falese] 若指定的索引名不是原数组的索引名，则新添加一行为NaN的数据，否则不改变原数组，返回新数组，默认不在原数组修改
df.set_index(‘列名’，drop=True，inplace=Falese) 指定某一列为行索引名替换原来的索引名，默认删除此列，且不在原数组修改
互换复合索引的位置(方便取值)
df.swaplevel() 返回新数组
import numpy as np
import pandas as pd
df1 = pd.DataFrame(np.arange(12).reshape(3,4),index=list('XYZ'),columns=list('ABCD'))
print(df1)
df1.index=list('OPQ')
print(df1)
df2 = df1.reindex(list('OXY'))
print(df1)
print(df2)
df3 = df1.set_index(['A','B'])
print(df1)
print(df3)
互换复合索引的位置(方便取值)
df.swaplevel() 返回新数组
#运行结果
A B C D
O 0 1 2 3
P 4 5 6 7
Q 8 9 10 11
A B C D
O 0.0 1.0 2.0 3.0
X NaN NaN NaN NaN
Y NaN NaN NaN NaN
A B C D
O 0 1 2 3
P 4 5 6 7
Q 8 9 10 11
C D
A B
0 1 2 3
4 5 6 7
8 9 10 11
互换复合索引的位置(方便取值)
df.swaplevel() 返回新数组
import numpy as np
import pandas as pd
df1 = pd.DataFrame(np.arange(12).reshape(3,4),index=list('XYZ'),columns=list('ABCD'))
df3 = df1.set_index(['A','B'])
df4 = df3.swaplevel()
print(df4)
# 运行结果
C D
B A
1 0 2 3
5 4 6 7
9 8 10 11
4825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
