python的Pandas

1.筛选数据

import pandas as pd

data = {'co1': {'index1': 'a', 'index5': 'a', 'index2': 'a', 'index4': 'b', 'index3': 'b', 'index6': 'b'},
        'co2': {'index1': 0, 'index5': 1, 'index2': 2, 'index4': 3, 'index3': 4, 'index6': 5}}
df1 = pd.DataFrame(data=data)

1.1 按轴标签.loc

df.loc[<行表达式>, <列表达式>] 如列表达式部分不传,将返回所有列,Series仅支持行表达式进行索引的部分loc操作通过索引和列的条件筛选出数据.如果仅返回一条数据,则类型为Series

print(df1.loc["index1":"index5", ['co1', 'co2']])  # 代表index1～index5行,co1,co2两列
print(df1.loc["index1"])  # 选择索引为index1的行
print(df1.set_index('co2').loc[0])  # 将co2作为索引,选择co2等于0的值
print(df1.loc[["index1", "index2"]])
print(df1.loc["index1":"index5"])  # 索引切片，代表index1～index5行，包括index5,索引为数值时同理
print(df1.loc[:])

1.2按数字索引.iloc

利用df.iloc[<行表达式>, <列表达式>]格式可以使用数字索引,进行数据筛选只支持数字切片形式

1.3 取具体值.at/.iat

at类似于locdf.at[<索引>,<列名>]如果是一个Series,可以直接值入索引取到该索引的值iat和iloc一样,仅支持数字索引

print(df1.at["index1", 'co1'])  # 注：索引是字符，需要加引号
print(df1.set_index('co2').at[1, 'index1'])  # 将co2作为索引,获取新的具体值
print(df1.set_index('co2').co1.at[1])  # 指定列的值对应其他列的值
print(df1.co2.at["index1"])  # 指定列的对应索引的值

2.数据透视

数据透视表,顾名思义,是指它有“透视”数据的能力,可以找出大量复杂无关的数据的内在关系,将数据转化为有意义、有价值的信息,从而看到它所代表的事物的规律和本质

2.1 pivot()方法

index：作为新DataFrame的索引，取分组去重的值；如果不传入，则取现有索引。
columns：作为新DataFrame的列，取去重的值，当列和索引的组,合有多个值时会报错，需要使用pd.pivot_table()进行操作。
values：作为新DataFrame的值，如果指定多个，会形成多层索引；如果不指定，会默认为所有剩余的列

import pandas as pd

df = pd.DataFrame({
'A':['a1', 'a1', 'a1', 'a2', 'a2', 'a2'],
'B':['b2', 'b2', 'b1', 'b1', 'b1', 'b1'],
'C':['c1', 'c1', 'c2', 'c2', 'c1', 'c1'],
'D':[1, 2, 3, 4, 5, 6]
})
df
'''
A B C D
0 a1 b2 c1 1
1 a1 b2 c1 2
2 a1 b1 c2 3
3 a2 b1 c2 4
4 a2 b1 c1 5
5 a2 b1 c1 6
'''


# 透视，指定索引、列、值
df.pivot(index='A', columns='B', values='C')
'''
B  b1 b2 b3
A
a1 c1 c2 NaN
a2 c4 NaN c3
a3 NaN c5 c6
'''
# 不指定值内容
df.pivot(index='A', columns='B')
'''
C           D
B b1 b2 b3 b1 b2 b3
A
a1 c1 c2 NaN d1 d2 NaN
a2 c4 NaN c3 d4 NaN d3
a3 NaN c5 c6 NaN d5 d6
'''

2.2 pivot_table()

data：要透视的DataFrame对象。
index：在数据透视表索引上进行分组的列。
values：要聚合的一列或多列。
columns：在数据透视表列上进行分组的列。
aggfunc：用于聚合的函数，默认是平均数mean。
fill_value：透视会以空值填充值。
margins：是否增加汇总行列。

import pandas as pd

df = pd.DataFrame({
'A':['a1', 'a1', 'a1', 'a2', 'a2', 'a2'],
'B':['b2', 'b2', 'b1', 'b1', 'b1', 'b1'],
'C':['c1', 'c1', 'c2', 'c2', 'c1', 'c1'],
'D':[1, 2, 3, 4, 5, 6]
})
df
'''
A B C D
0 a1 b2 c1 1
1 a1 b2 c1 2
2 a1 b1 c2 3
3 a2 b1 c2 4
4 a2 b1 c1 5
5 a2 b1 c1 6
'''
# 透视
pd.pivot_table(df, index='A', columns='B', values='D')
'''
B b1 b2
A
a1 3.0 1.5
a2 5.0 NaN
'''

注意

如果对以上数据进行以A为索引,以B为列的整理透视df.pivot()操作,会报错,因为索引和列组合后有重复数据。需要将这些重复数据按一定的算法计算出来,pd.pivot_table()默认的算法是取平均值

# 高级聚合
pd.pivot_table(df, index=['A', 'B'],  # 指定多个索引
               columns=['C'],  # 指定列
               values='D',  # 指定数据值
               aggfunc=np.sum,  # 指定聚合方法为求和
               fill_value=0,  # 将聚合为空的值填充为0
               margins=True  # 增加行列汇总
               )
'''
C    c1 c2 All
A  B
a1 b1 0  3  3
   b2 3  0  3
a2 b1 11 4  15
All   14 7  21
'''

# 使用多个聚合计算
pd.pivot_table(df, index=['A', 'B'],  # 指定多个索引
               columns=['C'],  # 指定列
               values='D',  # 指定数据值
               aggfunc=[np.mean, np.sum]
               )
'''
mean sum
C c1 c2 c1 c2
A B
a1 b1 NaN 3.0 NaN 3.0
b2 1.5 NaN 3.0 NaN
a2 b1 5.5 4.0 11.0 4.0
'''
df = pd.DataFrame({
    'A': ['a1', 'a1', 'a1', 'a2', 'a2', 'a2'],
    'B': ['b2', 'b2', 'b1', 'b1', 'b1', 'b1'],
    'C': ['c1', 'c1', 'c2', 'c2', 'c1', 'c1'],
    'D': [1, 2, 3, 4, 5, 6],
    'E': [9, 8, 7, 6, 5, 4]
})
df
'''
A B C D E
0 a1 b2 c1 1 9
1 a1 b2 c1 2 8
2 a1 b1 c2 3 7
3 a2 b1 c2 4 6
4 a2 b1 c1 5 5
5 a2 b1 c1 6 4
'''
# 为各列分别指定计算方法
pd.pivot_table(df, index=['A', 'B'],
               columns=['C'],
               aggfunc={'D': np.mean, 'E': np.sum}
               )
'''
D E
C c1 c2 c1 c2
A B
a1 b1 NaN 3.0 NaN 7.0
b2 1.5 NaN 17.0 NaN
a2 b1 5.5 4.0 9.0 6.0
'''

3.交叉表

交叉表(cross tabulation)是一个很有用的分析工具,是用于统计 分组频率的特殊透视表.简单来说,交叉表就是将两列或多列中不重复 的元素组成一个新的DataFrame,新数据的行和列交叉部分的值为其组合在原数据中的数量

# 基本语法
pd.crosstab(index, columns, values=None, rownames=None,
colnames=None, aggfunc=None, margins=False,
margins_name: str = 'All', dropna: bool = True,
normalize=False)

参数说明如下。
index：传入列，如df['A']，作为新数据的索引。
columns：传入列，作为新数据的列，新数据的列为此列的去重
值。
values：可选，传入列，根据此列的数值进行计算，计算方法取
aggfunc参数指定的方法，此时aggfunc为必传。
aggfunc：函数，values列计算使用的计算方法。
rownames：新数据和行名，一个序列，默认值为None，必须与
传递的行数、组数匹配。
colnames：新数据和列名，一个序列，默认值为None；如果传
递，则必须与传递的列数、组数匹配。
margins：布尔值，默认值为False，添加行/列边距（小计）。
normalize：布尔值，{'all'，'index'，'columns'}或{0,1}，默认值为

# 原数据
df = pd.DataFrame({
'A':['a1', 'a1', 'a2', 'a2', 'a1'],
'B':['b2', 'b1', 'b2', 'b2', 'b1'],
'C':[1, 2, 3, 4, 5],
})
df
'''
A B C
0 a1 b2 1
1 a1 b1 2
2 a2 b2 3
3 a2 b2 4
4 a1 b1 5
'''
# 生成交叉表
pd.crosstab(df['A'], df['B'])
'''
B b1 b2
A
a1 2 1
a2 0 2

注意

a1,b1组合有两个值 ,默认取第一个值

# 交叉表，归一化
pd.crosstab(df['A'], df['B'], normalize=True)
'''
B b1 b2
A
a1 0.4 0.2
a2 0.0 0.4
'''
# 交叉表，按列归一化
pd.crosstab(df['A'], df['B'], normalize='columns')
'''
B b1 b2
A
a1 1.0 0.333333
a2 0.0 0.666667

注意

归一化指对应值除以所有值的总和,让数据处于0～1的范围

# 交叉表，按C列的和进行求和聚合
pd.crosstab(df['A'], df['B'], values=df['C'], aggfunc=np.sum)
'''
B b1 b2
A
a1 7.0 1.0
a2 NaN 7.0

注意

a1,b1组合有两个值 ,aggfunc指定为求和

# 交叉表，增加汇总
pd.crosstab(df['A'], df['B'],
values=df['C'],
aggfunc=np.sum,
margins=True,
margins_name='total')
'''
B b1 b2 total
A
a1 7.0 1.0 8
a2 NaN 7.0 7
total 7.0 8.0 15
'''