pandas一维系列Series和二维数据帧DataFrame的创建、索引、切片、查询、缺失值以及二维数据帧的分组、合并和聚合

pandas

一. Series一维数组

1. 创建一维数组

方法一：
pd.Series(列表，index=列表,columns=列表)
pd.Series(numpy一维数组，index=列表,columns=列表)
返回 类型的一维数组

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 ---------------返回
s.values -----------------返回类型
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