Pandas之DataFrame——Part 3
'''
【课程2.】 数值计算和统计基础 常用数学、统计方法 '''
# 基本参数：axis、skipna import numpy as np
import pandas as pd df = pd.DataFrame({'key1':[,,,np.nan,],
'key2':[,,np.nan,,],
'key3':[,,,'j','k']},
index = ['a','b','c','d','e'])
print(df)
print(df['key1'].dtype,df['key2'].dtype,df['key3'].dtype)
print('-----') m1 = df.mean()
print(m1,type(m1))
print('单独统计一列:',df['key2'].mean())
print('-----')
# np.nan ：空值
# .mean()计算均值
# 只统计数字列
# 可以通过索引单独统计一列 m2 = df.mean(axis=)
print(m2)
print('-----')
# axis参数：默认为0，以列来计算，axis=，以行来计算，这里就按照行来汇总了 m3 = df.mean(skipna=False)
print(m3)
print('-----')
# skipna参数：是否忽略NaN，默认True，如False，有NaN的列统计结果仍未NaN
输出：
key1 key2 key3
a 4.0 1.0
b 5.0 2.0
c 3.0 NaN
d NaN 4.0 j
e 2.0 5.0 k
float64 float64 object
-----
key1 3.5
key2 3.0
dtype: float64 <class 'pandas.core.series.Series'>
单独统计一列: 3.0
-----
a 2.5
b 3.5
c 3.0
d 4.0
e 3.5
dtype: float64
-----
key1 NaN
key2 NaN
dtype: float64
-----
# 主要数学计算方法，可用于Series和DataFrame（）
df = pd.DataFrame({'key1':np.arange(),
'key2':np.random.rand()*})
print(df)
print('-----')
print(df.count(),'→ count统计非Na值的数量\n')
print(df.min(),'→ min统计最小值\n',df['key2'].max(),'→ max统计最大值\n')
print(df.quantile(q=0.75),'→ quantile统计分位数，参数q确定位置\n')
print(df.sum(),'→ sum求和\n')
print(df.mean(),'→ mean求平均值\n')
print(df.median(),'→ median求算数中位数，50%分位数\n')
print(df.std(),'\n',df.var(),'→ std,var分别求标准差，方差\n')
print(df.skew(),'→ skew样本的偏度\n')
print(df.kurt(),'→ kurt样本的峰度\n')
输出：
key1 key2
4.667989
4.336625
0.746852
9.670919
8.732045
0.013751
8.963752
0.279303
8.586821
8.899657
-----
key1
key2
dtype: int64 → count统计非Na值的数量 key1 0.000000
key2 0.013751
dtype: float64 → min统计最小值
9.67091932107 → max统计最大值 key1 6.750000
key2 8.857754
dtype: float64 → quantile统计分位数，参数q确定位置 key1 45.000000
key2 54.897714
dtype: float64 → sum求和 key1 4.500000
key2 5.489771
dtype: float64 → mean求平均值 key1 4.500000
key2 6.627405
dtype: float64 → median求算数中位数，%分位数 key1 3.027650
key2 3.984945
dtype: float64
key1 9.166667
key2 15.879783
dtype: float64 → std,var分别求标准差，方差 key1 0.000000
key2 -0.430166
dtype: float64 → skew样本的偏度 key1 -1.200000
key2 -1.800296
dtype: float64 → kurt样本的峰度
# 主要数学计算方法，可用于Series和DataFrame（） df['key1_s'] = df['key1'].cumsum()
df['key2_s'] = df['key2'].cumsum()
print(df,'→ cumsum样本的累计和\n') df['key1_p'] = df['key1'].cumprod()
df['key2_p'] = df['key2'].cumprod()
print(df,'→ cumprod样本的累计积\n') print(df.cummax(),'\n',df.cummin(),'→ cummax,cummin分别求累计最大值，累计最小值\n')
# 会填充key1，和key2的值
输出：
key1 key2 key1_s key2_s
4.667989 4.667989
4.336625 9.004614
0.746852 9.751466
9.670919 19.422386
8.732045 28.154431
0.013751 28.168182
8.963752 37.131934
0.279303 37.411236
8.586821 45.998057
8.899657 54.897714 → cumsum样本的累计和 key1 key2 key1_s key2_s key1_p key2_p
4.667989 4.667989 4.667989
4.336625 9.004614 20.243318
0.746852 9.751466 15.118767
9.670919 19.422386 146.212377
8.732045 28.154431 1276.733069
0.013751 28.168182 17.556729
8.963752 37.131934 157.374157
0.279303 37.411236 43.955024
8.586821 45.998057 377.433921
8.899657 54.897714 3359.032396 → cumprod样本的累计积 key1 key2 key1_s key2_s key1_p key2_p
0.0 4.667989 0.0 4.667989 0.0 4.667989
1.0 4.667989 1.0 9.004614 0.0 20.243318
2.0 4.667989 3.0 9.751466 0.0 20.243318
3.0 9.670919 6.0 19.422386 0.0 146.212377
4.0 9.670919 10.0 28.154431 0.0 1276.733069
5.0 9.670919 15.0 28.168182 0.0 1276.733069
6.0 9.670919 21.0 37.131934 0.0 1276.733069
7.0 9.670919 28.0 37.411236 0.0 1276.733069
8.0 9.670919 36.0 45.998057 0.0 1276.733069
9.0 9.670919 45.0 54.897714 0.0 3359.032396
key1 key2 key1_s key2_s key1_p key2_p
0.0 4.667989 0.0 4.667989 0.0 4.667989
0.0 4.336625 0.0 4.667989 0.0 4.667989
0.0 0.746852 0.0 4.667989 0.0 4.667989
0.0 0.746852 0.0 4.667989 0.0 4.667989
0.0 0.746852 0.0 4.667989 0.0 4.667989
0.0 0.013751 0.0 4.667989 0.0 4.667989
0.0 0.013751 0.0 4.667989 0.0 4.667989
0.0 0.013751 0.0 4.667989 0.0 4.667989
0.0 0.013751 0.0 4.667989 0.0 4.667989
0.0 0.013751 0.0 4.667989 0.0 4.667989 → cummax,cummin分别求累计最大值，累计最小值
# 唯一值：.unique()
s = pd.Series(list('asdvasdcfgg'))
sq = s.unique()
print(s)
print(sq,type(sq))
print(pd.Series(sq))
# 得到一个唯一值数组
# 通过pd.Series重新变成新的Series
sq.sort()
print(sq)
# 重新排序
输出：
a
s
d
v
a
s
d
c
f
g
g
dtype: object
['a' 's' 'd' 'v' 'c' 'f' 'g'] <class 'numpy.ndarray'>
a
s
d
v
c
f
g
dtype: object
['a' 'c' 'd' 'f' 'g' 's' 'v']
# 值计数：.value_counts() sc = s.value_counts(sort = False) # 也可以这样写：pd.value_counts(sc, sort = False)
print(sc)
# 得到一个新的Series，计算出不同值出现的频率
# sort参数：排序，默认为True
输出：
s
d
v
c
a
g
f
dtype: int64
# 成员资格：.isin() s = pd.Series(np.arange(,))
df = pd.DataFrame({'key1':list('asdcbvasd'),
'key2':np.arange(,)})
print(s)
print(df)
print('-----') print(s.isin([,]))
print(df.isin(['a','bc','',]))
# 用[]表示
# 得到一个布尔值的Series或者Dataframe
输出：
dtype: int32
key1 key2
a
s
d
c
b
v
a
s
d
-----
False
False
False
False
True
dtype: bool
key1 key2
True False
False False
False False
False False
False True
False False
True False
False False
False False
'''
【课程2.】 文本数据 Pandas针对字符串配备的一套方法，使其易于对数组的每个元素进行操作 '''
# 通过str访问，且自动排除丢失/ NA值 s = pd.Series(['A','b','C','bbhello','',np.nan,'hj'])
df = pd.DataFrame({'key1':list('abcdef'),
'key2':['hee','fv','w','hija','',np.nan]})
print(s)
print(df)
print('-----') print(s.str.count('b'))
print(df['key2'].str.upper())
print('-----')
# 直接通过.str调用字符串方法
# 可以对Series、Dataframe使用
# 自动过滤NaN值 df.columns = df.columns.str.upper()
print(df)
# df.columns是一个Index对象，也可使用.str
输出：
A
b
C
bbhello NaN
hj
dtype: object
key1 key2
a hee
b fv
c w
d hija
e
f NaN
-----
0.0
1.0
0.0
2.0
0.0
NaN
0.0
dtype: float64
HEE
FV
W
HIJA NaN
Name: key2, dtype: object
-----
KEY1 KEY2
a hee
b fv
c w
d hija
e
f NaN
# 字符串常用方法（） - lower，upper，len，startswith，endswith s = pd.Series(['A','b','bbhello','',np.nan]) print(s.str.lower(),'→ lower小写\n')
print(s.str.upper(),'→ upper大写\n')
print(s.str.len(),'→ len字符长度\n')
print(s.str.startswith('b'),'→ 判断起始是否为a\n')
print(s.str.endswith(''),'→ 判断结束是否为3\n')
输出：
a
b
bbhello NaN
dtype: object → lower小写 A
B
BBHELLO NaN
dtype: object → upper大写 1.0
1.0
7.0
3.0
NaN
dtype: float64 → len字符长度 False
True
True
False
NaN
dtype: object → 判断起始是否为a False
False
False
True
NaN
dtype: object → 判断结束是否为3
# 字符串常用方法（） - strip s = pd.Series([' jack', 'jill ', ' jesse ', 'frank'])
df = pd.DataFrame(np.random.randn(, ), columns=[' Column A ', ' Column B '],
index=range())
print(s)
print(df)
print('-----') print(s.str.strip()) # 去除字符串中的空格
print(s.str.lstrip()) # 去除字符串中的左空格
print(s.str.rstrip()) # 去除字符串中的右空格 df.columns = df.columns.str.strip()
print(df)
# 这里去掉了columns的前后空格，但没有去掉中间空格
输出：
jack
jill
jesse
frank
dtype: object
Column A Column B
0.647766 0.094747
0.342940 -0.660643
1.183315 -0.143729
-----
jack
jill
jesse
frank
dtype: object
jack
jill
jesse
frank
dtype: object
jack
jill
jesse
frank
dtype: object
Column A Column B
0.647766 0.094747
0.342940 -0.660643
1.183315 -0.143729
# 字符串常用方法（） - replace df = pd.DataFrame(np.random.randn(, ), columns=[' Column A ', ' Column B '],
index=range())
df.columns = df.columns.str.replace(' ','-')
print(df)
# 替换 df.columns = df.columns.str.replace('-','hehe',n=)
print(df)
# n：替换个数
输出：
-Column-A- -Column-B-
1.855227 -0.519479
-0.400376 -0.421383
-0.293797 -0.432481
heheColumn-A- heheColumn-B-
1.855227 -0.519479
-0.400376 -0.421383
-0.293797 -0.432481
# 字符串常用方法（） - split、rsplit s = pd.Series(['a,b,c','1,2,3',['a,,,c'],np.nan])
print(s.str.split(','))
print('-----')
# 类似字符串的split print(s.str.split(',')[])
print('-----')
# 直接索引得到一个list print(s.str.split(',').str[])
print(s.str.split(',').str.get())
print('-----')
# 可以使用get或[]符号访问拆分列表中的元素 print(s.str.split(',', expand=True))
print(s.str.split(',', expand=True, n = ))
print(s.str.rsplit(',', expand=True, n = ))
print('-----')
# 可以使用expand可以轻松扩展此操作以返回DataFrame
# n参数限制分割数
# rsplit类似于split，反向工作，即从字符串的末尾到字符串的开头 df = pd.DataFrame({'key1':['a,b,c','1,2,3',[':,., ']],
'key2':['a-b-c','1-2-3',[':-.- ']]})
print(df['key2'].str.split('-'))
# Dataframe使用split
输出：
[a, b, c]
[, , ]
NaN
NaN
dtype: object
-----
['a', 'b', 'c']
-----
a NaN
NaN
dtype: object
b NaN
NaN
dtype: object
----- a b c NaN None None
NaN None None a b,c
,
NaN None
NaN None a,b c
,
NaN None
NaN None
-----
[a, b, c]
[, , ]
NaN
Name: key2, dtype: object
# 字符串索引 s = pd.Series(['A','b','C','bbhello','',np.nan,'hj'])
df = pd.DataFrame({'key1':list('abcdef'),
'key2':['hee','fv','w','hija','',np.nan]}) print(s.str[]) # 取第一个字符串
print(s.str[:]) # 取前两个字符串
print(df['key2'].str[])
# str之后和字符串本身索引方式相同
输出：
A
b
C
b NaN
h
dtype: object
A
b
C
bb NaN
hj
dtype: object
h
f
w
h NaN
Name: key2, dtype: object
'''
【课程2.】 合并 merge、join Pandas具有全功能的，高性能内存中连接操作，与SQL等关系数据库非常相似 pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False) '''
# merge合并 → 类似excel的vlookup
df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
df3 = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
df4 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
print(pd.merge(df1, df2, on='key'))
print('------')
# left：第一个df
# right：第二个df
# on：参考键
print(pd.merge(df3, df4, on=['key1','key2']))
# 多个链接键
输出：
A B key C D
A0 B0 K0 C0 D0
A1 B1 K1 C1 D1
A2 B2 K2 C2 D2
A3 B3 K3 C3 D3
------
A B key1 key2 C D
A0 B0 K0 K0 C0 D0
A2 B2 K1 K0 C1 D1
A2 B2 K1 K0 C2 D2
# 参数how → 合并方式 print(pd.merge(df3, df4,on=['key1','key2'], how = 'inner'))
print('------')
# inner：默认，取交集 print(pd.merge(df3, df4, on=['key1','key2'], how = 'outer'))
print('------')
# outer：取并集，数据缺失范围NaN print(pd.merge(df3, df4, on=['key1','key2'], how = 'left'))
print('------')
# left：按照df3为参考合并，数据缺失范围NaN print(pd.merge(df3, df4, on=['key1','key2'], how = 'right'))
# right：按照df4为参考合并，数据缺失范围NaN
输出：
A B key1 key2 C D
A0 B0 K0 K0 C0 D0
A2 B2 K1 K0 C1 D1
A2 B2 K1 K0 C2 D2
------
A B key1 key2 C D
A0 B0 K0 K0 C0 D0
A1 B1 K0 K1 NaN NaN
A2 B2 K1 K0 C1 D1
A2 B2 K1 K0 C2 D2
A3 B3 K2 K1 NaN NaN
NaN NaN K2 K0 C3 D3
------
A B key1 key2 C D
A0 B0 K0 K0 C0 D0
A1 B1 K0 K1 NaN NaN
A2 B2 K1 K0 C1 D1
A2 B2 K1 K0 C2 D2
A3 B3 K2 K1 NaN NaN
------
A B key1 key2 C D
A0 B0 K0 K0 C0 D0
A2 B2 K1 K0 C1 D1
A2 B2 K1 K0 C2 D2
NaN NaN K2 K0 C3 D3
# 参数 left_on, right_on, left_index, right_index → 当键不为一个列时，可以单独设置左键与右键
df1 = pd.DataFrame({'lkey':list('bbacaab'),
'data1':range()})
df2 = pd.DataFrame({'rkey':list('abd'),
'date2':range()})
print(pd.merge(df1, df2, left_on='lkey', right_on='rkey'))
print('------')
# df1以‘lkey’为键，df2以‘rkey’为键
df1 = pd.DataFrame({'key':list('abcdfeg'),
'data1':range()})
df2 = pd.DataFrame({'date2':range(,)},
index = list('abcde'))
print(pd.merge(df1, df2, left_on='key', right_index=True))
# df1以‘key’为键，df2以index为键
# left_index：为True时，第一个df以index为键，默认False
# right_index：为True时，第二个df以index为键，默认False
# 所以left_on, right_on, left_index, right_index可以相互组合：
# left_on + right_on, left_on + right_index, left_index + right_on, left_index + right_index
输出：
data1 lkey date2 rkey
b b
b b
b b
a a
a a
a a
------
data1 key date2
a
b
c
d
e
# 参数 sort
df1 = pd.DataFrame({'key':list('bbacaab'),
'data1':[,,,,,,]})
df2 = pd.DataFrame({'key':list('abd'),
'date2':[,,]})
x1 = pd.merge(df1,df2, on = 'key', how = 'outer')
x2 = pd.merge(df1,df2, on = 'key', sort=True, how = 'outer')
print(x1)
print(x2)
print('------')
# sort：按照字典顺序通过 连接键 对结果DataFrame进行排序。默认为False，设置为False会大幅提高性能
print(x2.sort_values('data1'))
# 也可直接用Dataframe的排序方法：sort_values，sort_index
输出：
data1 key date2
1.0 b 2.0
3.0 b 2.0
7.0 b 2.0
2.0 a 11.0
5.0 a 11.0
9.0 a 11.0
4.0 c NaN
NaN d 33.0
data1 key date2
2.0 a 11.0
5.0 a 11.0
9.0 a 11.0
1.0 b 2.0
3.0 b 2.0
7.0 b 2.0
4.0 c NaN
NaN d 33.0
------
data1 key date2
1.0 b 2.0
2.0 a 11.0
3.0 b 2.0
4.0 c NaN
5.0 a 11.0
7.0 b 2.0
9.0 a 11.0
NaN d 33.0
# pd.join() → 直接通过索引链接
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
'D': ['D0', 'D2', 'D3']},
index=['K0', 'K2', 'K3'])
print(left)
print(right)
print(left.join(right))
print(left.join(right, how='outer'))
print('-----')
# 等价于：pd.merge(left, right, left_index=True, right_index=True, how='outer')
df1 = pd.DataFrame({'key':list('bbacaab'),
'data1':[,,,,,,]})
df2 = pd.DataFrame({'key':list('abd'),
'date2':[,,]})
print(df1)
print(df2)
print(pd.merge(df1, df2, left_index=True, right_index=True, suffixes=('_1', '_2')))
print(df1.join(df2['date2']))
print('-----')
# suffixes=('_x', '_y')默认
left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'key': ['K0', 'K1', 'K0', 'K1']})
right = pd.DataFrame({'C': ['C0', 'C1'],
'D': ['D0', 'D1']},
index=['K0', 'K1'])
print(left)
print(right)
print(left.join(right, on = 'key'))
# 等价于pd.merge(left, right, left_on='key', right_index=True, how='left', sort=False);
# left的‘key’和right的index
输出：
A B
K0 A0 B0
K1 A1 B1
K2 A2 B2
C D
K0 C0 D0
K2 C2 D2
K3 C3 D3
A B C D
K0 A0 B0 C0 D0
K1 A1 B1 NaN NaN
K2 A2 B2 C2 D2
A B C D
K0 A0 B0 C0 D0
K1 A1 B1 NaN NaN
K2 A2 B2 C2 D2
K3 NaN NaN C3 D3
-----
data1 key
b
b
a
c
a
a
b
date2 key
a
b
d
data1 key_1 date2 key_2
b a
b b
a d
data1 key date2
b 11.0
b 2.0
a 33.0
c NaN
a NaN
a NaN
b NaN
-----
A B key
A0 B0 K0
A1 B1 K1
A2 B2 K0
A3 B3 K1
C D
K0 C0 D0
K1 C1 D1
A B key C D
A0 B0 K0 C0 D0
A1 B1 K1 C1 D1
A2 B2 K0 C0 D0
A3 B3 K1 C1 D1
'''
【课程2.】 连接与修补 concat、combine_first 连接 - 沿轴执行连接操作 pd.concat(objs, axis=, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False,
copy=True) '''
# 连接：concat s1 = pd.Series([,,])
s2 = pd.Series([,,])
s3 = pd.Series([,,],index = ['a','c','h'])
s4 = pd.Series([,,],index = ['b','e','d'])
print(pd.concat([s1,s2]))
print(pd.concat([s3,s4]).sort_index())
print('-----')
# 默认axis=，行+行 print(pd.concat([s3,s4], axis=))
print('-----')
# axis=,列+列，成为一个Dataframe
输出：
dtype: int64
a
b
c
d
e
h
dtype: int64
----- a 1.0 NaN
b NaN 2.0
c 2.0 NaN
d NaN 4.0
e NaN 3.0
h 3.0 NaN
-----
# 连接方式：join，join_axes s5 = pd.Series([,,],index = ['a','b','c'])
s6 = pd.Series([,,],index = ['b','c','d'])
print(pd.concat([s5,s6], axis= ))
print(pd.concat([s5,s6], axis= , join='inner'))
print(pd.concat([s5,s6], axis= , join_axes=[['a','b','d']]))
# join：{'inner'，'outer'}，默认为“outer”。如何处理其他轴上的索引。outer为联合和inner为交集。
# join_axes：指定联合的index
输出：
a 1.0 NaN
b 2.0 2.0
c 3.0 3.0
d NaN 4.0 b
c a 1.0 NaN
b 2.0 2.0
d NaN 4.0
# 覆盖列名 sre = pd.concat([s5,s6], keys = ['one','two'])
print(sre,type(sre))
print(sre.index)
print('-----')
# keys：序列，默认值无。使用传递的键作为最外层构建层次索引 sre = pd.concat([s5,s6], axis=, keys = ['one','two'])
print(sre,type(sre))
# axis = , 覆盖列名
输出：
one a
b
c
two b
c
d
dtype: int64 <class 'pandas.core.series.Series'>
MultiIndex(levels=[['one', 'two'], ['a', 'b', 'c', 'd']],
labels=[[, , , , , ], [, , , , , ]])
-----
one two
a 1.0 NaN
b 2.0 2.0
c 3.0 3.0
d NaN 4.0 <class 'pandas.core.frame.DataFrame'>
# 修补 pd.combine_first() df1 = pd.DataFrame([[np.nan, ., .], [-4.6, np.nan, np.nan],[np.nan, ., np.nan]])
df2 = pd.DataFrame([[-42.6, np.nan, -8.2], [-., 1.6, ]],index=[, ])
print(df1)
print(df2)
print(df1.combine_first(df2))
print('-----')
# 根据index，df1的空值被df2替代
# 如果df2的index多于df1，则更新到df1上，比如index=['a',] df1.update(df2)
print(df1)
# update，直接df2覆盖df1，相同index位置
输出：
NaN 3.0 5.0
-4.6 NaN NaN
NaN 7.0 NaN -42.6 NaN -8.2
-5.0 1.6 4.0 NaN 3.0 5.0
-4.6 NaN -8.2
-5.0 7.0 4.0
----- NaN 3.0 5.0
-42.6 NaN -8.2
-5.0 1.6 4.0
'''
【课程2.】 去重及替换 .duplicated / .replace '''
# 去重 .duplicated s = pd.Series([,,,,,,,,,,,,])
print(s.duplicated())
print(s[s.duplicated() == False])
print('-----')
# 判断是否重复
# 通过布尔判断，得到不重复的值 s_re = s.drop_duplicates()
print(s_re)
print('-----')
# drop.duplicates移除重复
# inplace参数：是否替换原值，默认False df = pd.DataFrame({'key1':['a','a',,,],
'key2':['a','a','b','b','c']})
print(df.duplicated())
print(df['key2'].duplicated())
# Dataframe中使用duplicated
输出：
False
True
True
True
False
True
True
False
False
False
True
True
True
dtype: bool dtype: int64
----- dtype: int64
-----
False
True
False
False
False
dtype: bool
False
True
False
True
False
Name: key2, dtype: bool
# 替换 .replace
s = pd.Series(list('ascaazsd'))
print(s.replace('a', np.nan))
print(s.replace(['a','s'] ,np.nan))
print(s.replace({'a':'hello world!','s':}))
# 可一次性替换一个值或多个值
# 可传入列表或字典
输出：
NaN
s
c
NaN
NaN
z
s
d
dtype: object
NaN
NaN
c
NaN
NaN
z
NaN
d
dtype: object
hello world! c
hello world!
hello world!
z d
dtype: object
'''
【课程2.】 数据分组 分组统计 - groupby功能 ① 根据某些条件将数据拆分成组
② 对每个组独立应用函数
③ 将结果合并到一个数据结构中 Dataframe在行（axis=）或列（axis=）上进行分组，将一个函数应用到各个分组并产生一个新值，然后函数执行结果被合并到最终的结果对象中。 df.groupby(by=None, axis=, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs) '''
# 分组
df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],
'B' : ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C' : np.random.randn(),
'D' : np.random.randn()})
print(df)
print('------')
print(df.groupby('A'), type(df.groupby('A')))
print('------')
# 直接分组得到一个groupby对象，是一个中间数据，没有进行计算
a = df.groupby('A').mean()
b = df.groupby(['A','B']).mean()
c = df.groupby(['A'])['D'].mean() # 以A分组，算D的平均值
print(a,type(a),'\n',a.columns)
print(b,type(b),'\n',b.columns)
print(c,type(c))
# 通过分组后的计算，得到一个新的dataframe
# 默认axis = ，以行来分组
# 可单个或多个（[]）列分组
输出：
A B C D
foo one 0.891765 -1.121156
bar one -1.272769 1.188977
foo two 0.198131 0.543673
bar three -0.827655 -1.608699
foo two -1.114089 -0.696145
bar two -0.345336 0.718507
foo one -0.207091 -0.922269
foo three -0.431760 -0.123696
------
<pandas.core.groupby.DataFrameGroupBy object at 0x0000000004B65E10> <class 'pandas.core.groupby.DataFrameGroupBy'>
------
C D
A
bar -0.815253 0.099595
foo -0.132609 -0.463918 <class 'pandas.core.frame.DataFrame'>
Index(['C', 'D'], dtype='object')
C D
A B
bar one -1.272769 1.188977
three -0.827655 -1.608699
two -0.345336 0.718507
foo one 0.342337 -1.021713
three -0.431760 -0.123696
two -0.457979 -0.076236 <class 'pandas.core.frame.DataFrame'>
Index(['C', 'D'], dtype='object')
A
bar 0.099595
foo -0.463918
Name: D, dtype: float64 <class 'pandas.core.series.Series'>
# 分组 - 可迭代对象
df = pd.DataFrame({'X' : ['A', 'B', 'A', 'B'], 'Y' : [, , , ]})
print(df)
print(df.groupby('X'), type(df.groupby('X')))
print('-----')
print(list(df.groupby('X')), '→ 可迭代对象，直接生成list\n')
print(list(df.groupby('X'))[], '→ 以元祖形式显示\n')
for n,g in df.groupby('X'):
print(n)
print(g)
print('###')
print('-----')
# n是组名，g是分组后的Dataframe
print(df.groupby(['X']).get_group('A'),'\n')
print(df.groupby(['X']).get_group('B'),'\n')
print('-----')
# .get_group()提取分组后的组
grouped = df.groupby(['X'])
print(grouped.groups)
print(grouped.groups['A']) # 也可写：df.groupby('X').groups['A']
print('-----')
# .groups：将分组后的groups转为dict
# 可以字典索引方法来查看groups里的元素
sz = grouped.size()
print(sz,type(sz))
print('-----')
# .size()：查看分组后的长度
df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],
'B' : ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C' : np.random.randn(),
'D' : np.random.randn()})
grouped = df.groupby(['A','B']).groups
print(df)
print(grouped)
print(grouped[('foo', 'three')])
# 按照两个列进行分组
输出：
X Y
A
B
A
B
<pandas.core.groupby.DataFrameGroupBy object at 0x00000000091B6F28> <class 'pandas.core.groupby.DataFrameGroupBy'>
-----
[('A', X Y
A
A ), ('B', X Y
B
B )] → 可迭代对象，直接生成list ('A', X Y
A
A ) → 以元祖形式显示 A
X Y
A
A
###
B
X Y
B
B
###
-----
X Y
A
A X Y
B
B -----
{'B': [, ], 'A': [, ]}
[, ]
-----
X
A
B
dtype: int64 <class 'pandas.core.series.Series'>
-----
A B C D
foo one -0.668695 0.247781
bar one -0.125374 2.259134
foo two -0.112052 1.618603
bar three -0.098986 0.150488
foo two 0.912286 -1.260029
bar two 1.096757 -0.571223
foo one -0.090907 -1.671482
foo three 0.088176 -0.292702
{('bar', 'two'): [], ('foo', 'two'): [, ], ('bar', 'one'): [], ('foo', 'three'): [], ('bar', 'three'): [], ('foo', 'one'): [, ]}
[]
# 其他轴上的分组
df = pd.DataFrame({'data1':np.random.rand(),
'data2':np.random.rand(),
'key1':['a','b'],
'key2':['one','two']})
print(df)
print(df.dtypes)
print('-----')
for n,p in df.groupby(df.dtypes, axis=):
print(n)
print(p)
print('##')
# 按照值类型分列
输出：
data1 data2 key1 key2
0.454580 0.692637 a one
0.496928 0.214309 b two
data1 float64
data2 float64
key1 object
key2 object
dtype: object
-----
float64
data1 data2
0.454580 0.692637
0.496928 0.214309
##
object
key1 key2
a one
b two
##
# 通过字典或者Series分组 df = pd.DataFrame(np.arange().reshape(,),
columns = ['a','b','c','d'])
print(df)
print('-----') mapping = {'a':'one','b':'one','c':'two','d':'two','e':'three'}
by_column = df.groupby(mapping, axis = )
print(by_column.sum())
print('-----')
# mapping中，a、b列对应的为one，c、d列对应的为two，以字典来分组 s = pd.Series(mapping)
print(s,'\n')
print(s.groupby(s).count())
# s中，index中a、b对应的为one，c、d对应的为two，以Series来分组
输出：
a b c d -----
one two -----
a one
b one
c two
d two
e three
dtype: object one
three
two
dtype: int64
# 通过函数分组 df = pd.DataFrame(np.arange().reshape(,),
columns = ['a','b','c','d'],
index = ['abc','bcd','aa','b'])
print(df,'\n')
print(df.groupby(len).sum())
# 按照字母长度分组
输出：
a b c d
abc
bcd
aa
b a b c d
# 分组计算函数方法 s = pd.Series([, , , , , ], index = [, , , , , ])
grouped = s.groupby(level=) # 唯一索引用.groupby(level=)，将同一个index的分为一组
print(grouped)
print(grouped.first(),'→ first：非NaN的第一个值\n')
print(grouped.last(),'→ last：非NaN的最后一个值\n')
print(grouped.sum(),'→ sum：非NaN的和\n')
print(grouped.mean(),'→ mean：非NaN的平均值\n')
print(grouped.median(),'→ median：非NaN的算术中位数\n')
print(grouped.count(),'→ count：非NaN的值\n')
print(grouped.min(),'→ min、max：非NaN的最小值、最大值\n')
print(grouped.std(),'→ std，var：非NaN的标准差和方差\n')
print(grouped.prod(),'→ prod：非NaN的积\n')
输出：
<pandas.core.groupby.SeriesGroupBy object at 0x00000000091992B0>
dtype: int64 → first：非NaN的第一个值
dtype: int64 → last：非NaN的最后一个值
dtype: int64 → sum：非NaN的和
5.5
11.0
16.5
dtype: float64 → mean：非NaN的平均值
5.5
11.0
16.5
dtype: float64 → median：非NaN的算术中位数
dtype: int64 → count：非NaN的值
dtype: int64 → min、max：非NaN的最小值、最大值
6.363961
12.727922
19.091883
dtype: float64 → std，var：非NaN的标准差和方差
dtype: int64 → prod：非NaN的积
# 多函数计算：agg()
df = pd.DataFrame({'a':[,,,],
'b':np.random.rand(),
'c':np.random.rand(),
'd':np.random.rand(),})
print(df)
print(df.groupby('a').agg(['mean',np.sum]))
print(df.groupby('a')['b'].agg({'result1':np.mean,
'result2':np.sum}))
# 函数写法可以用str，或者np.方法
# 可以通过list，dict传入，当用dict时，key名为columns
输出：
a b c d
0.357911 0.318324 0.627797
0.964829 0.500017 0.570063
0.116608 0.194164 0.049509
0.933123 0.542615 0.718640
b c d
mean sum mean sum mean sum
a
0.661370 1.322739 0.409171 0.818341 0.598930 1.19786
0.524865 1.049730 0.368390 0.736780 0.384075 0.76815
result2 result1
a
1.322739 0.661370
1.049730 0.524865
'''
【课程2.】 分组转换及一般性“拆分-应用-合并” transform / apply '''
# 数据分组转换,transform
df = pd.DataFrame({'data1':np.random.rand(),
'data2':np.random.rand(),
'key1':list('aabba'),
'key2':['one','two','one','two','one']})
k_mean = df.groupby('key1').mean()
print(df)
print(k_mean)
print(pd.merge(df,k_mean,left_on='key1',right_index=True).add_prefix('mean_')) # .add_prefix('mean_')：添加前缀
print('-----')
# 通过分组、合并，得到一个包含均值的Dataframe
print(df.groupby('key2').mean()) # 按照key2分组求均值
print(df.groupby('key2').transform(np.mean))
# data1、data2每个位置元素取对应分组列的均值
# 字符串不能进行计算
输出：
data1 data2 key1 key2
0.003727 0.390301 a one
0.744777 0.130300 a two
0.887207 0.679309 b one
0.448585 0.169208 b two
0.448045 0.993775 a one
data1 data2
key1
a 0.398850 0.504792
b 0.667896 0.424258
mean_data1_x mean_data2_x mean_key1 mean_key2 mean_data1_y mean_data2_y
0.003727 0.390301 a one 0.398850 0.504792
0.744777 0.130300 a two 0.398850 0.504792
0.448045 0.993775 a one 0.398850 0.504792
0.887207 0.679309 b one 0.667896 0.424258
0.448585 0.169208 b two 0.667896 0.424258
-----
data1 data2
key2
one 0.446326 0.687795
two 0.596681 0.149754
data1 data2
0.446326 0.687795
0.596681 0.149754
0.446326 0.687795
0.596681 0.149754
0.446326 0.687795
# 一般化Groupby方法：apply
df = pd.DataFrame({'data1':np.random.rand(),
'data2':np.random.rand(),
'key1':list('aabba'),
'key2':['one','two','one','two','one']})
print(df.groupby('key1').apply(lambda x: x.describe()))
# apply直接运行其中的函数
# 这里为匿名函数，直接描述分组后的统计量
def f_df1(d,n):
return(d.sort_index()[:n])
def f_df2(d,k1):
return(d[k1])
print(df.groupby('key1').apply(f_df1,),'\n')
print(df.groupby('key1').apply(f_df2,'data2'))
print(type(df.groupby('key1').apply(f_df2,'data2')))
# f_df1函数：返回排序后的前n行数据
# f_df2函数：返回分组后表的k1列，结果为Series，层次化索引
# 直接运行f_df函数
# 参数直接写在后面，也可以为.apply(f_df,n = ))
输出：
data1 data2
key1
a count 3.000000 3.000000
mean 0.561754 0.233470
std 0.313439 0.337209
min 0.325604 0.026906
% 0.383953 0.038906
% 0.442303 0.050906
% 0.679829 0.336753
max 0.917355 0.622599
b count 2.000000 2.000000
mean 0.881906 0.547206
std 0.079357 0.254051
min 0.825791 0.367564
% 0.853849 0.457385
% 0.881906 0.547206
% 0.909963 0.637026
max 0.938020 0.726847
data1 data2 key1 key2
key1
a 0.325604 0.050906 a one
0.917355 0.622599 a two
b 0.825791 0.726847 b one
0.938020 0.367564 b two key1
a 0.050906
0.622599
0.026906
b 0.726847
0.367564
Name: data2, dtype: float64
<class 'pandas.core.series.Series'>
'''
【课程2.】 透视表及交叉表 类似excel数据透视 - pivot table / crosstab '''
# 透视表：pivot_table
# pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All') date = ['2017-5-1','2017-5-2','2017-5-3']*
rng = pd.to_datetime(date)
df = pd.DataFrame({'date':rng,
'key':list('abcdabcda'),
'values':np.random.rand()*})
print(df)
print('-----') print(pd.pivot_table(df, values = 'values', index = 'date', columns = 'key', aggfunc=np.sum)) # 也可以写 aggfunc='sum'
print('-----')
# data：DataFrame对象
# values：要聚合的列或列的列表
# index：数据透视表的index，从原数据的列中筛选
# columns：数据透视表的columns，从原数据的列中筛选
# aggfunc：用于聚合的函数，默认为numpy.mean，支持numpy计算方法 print(pd.pivot_table(df, values = 'values', index = ['date','key'], aggfunc=len))
print('-----')
# 这里就分别以date、key共同做数据透视，值为values：统计不同（date，key）情况下values的平均值
# aggfunc=len(或者count)：计数
输出：
date key values
-- a 5.886424
-- b 9.906472
-- c 8.617297
-- d 8.972318
-- a 7.990905
-- b 8.131856
-- c 2.823731
-- d 2.394605
-- a 0.667917
-----
key a b c d
date
-- 5.886424 NaN 2.823731 8.972318
-- 7.990905 9.906472 NaN 2.394605
-- 0.667917 8.131856 8.617297 NaN
-----
date key
-- a 1.0
c 1.0
d 1.0
-- a 1.0
b 1.0
d 1.0
-- a 1.0
b 1.0
c 1.0
Name: values, dtype: float64
-----
# 交叉表：crosstab
# 默认情况下，crosstab计算因子的频率表，比如用于str的数据透视分析
# pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, dropna=True, normalize=False) df = pd.DataFrame({'A': [, , , , ],
'B': [, , , , ],
'C': [, , np.nan, , ]})
print(df)
print('-----') print(pd.crosstab(df['A'],df['B']))
print('-----')
# 如果crosstab只接收两个Series，它将提供一个频率表。
# 用A的唯一值，统计B唯一值的出现次数 print(pd.crosstab(df['A'],df['B'],normalize=True))
print('-----')
# normalize：默认False，将所有值除以值的总和进行归一化 → 为True时候显示百分比 print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum))
print('-----')
# values：可选，根据因子聚合的值数组
# aggfunc：可选，如果未传递values数组，则计算频率表，如果传递数组，则按照指定计算
# 这里相当于以A和B界定分组，计算出每组中第三个系列C的值 print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum, margins=True))
print('-----')
# margins：布尔值，默认值False，添加行/列边距（小计）
输出：
A B C
1.0
1.0
NaN
1.0
1.0
-----
B
A -----
B
A
0.2 0.0
0.2 0.6
-----
B
A
1.0 NaN
1.0 2.0
-----
B All
A
1.0 NaN 1.0
1.0 2.0 3.0
All 2.0 2.0 4.0
-----
'''
【课程2.】 数据读取 核心：read_table, read_csv, read_excel '''
# 读取普通分隔数据：read_table
# 可以读取txt，csv import os
os.chdir('C:/Users/Hjx/Desktop/') data1 = pd.read_table('data1.txt', delimiter=',',header = , index_col=)
print(data1)
# delimiter：用于拆分的字符，也可以用sep：sep = ','
# header：用做列名的序号，默认为0（第一行）
# index_col：指定某列为行索引，否则自动索引0, , ..... # read_table主要用于读取简单的数据，txt/csv
输出：
va1 va3 va4
va2
# 读取csv数据：read_csv
# 先熟悉一下excel怎么导出csv data2 = pd.read_csv('data2.csv',engine = 'python')
print(data2.head())
# engine：使用的分析引擎。可以选择C或者是python。C引擎快但是Python引擎功能更加完备。
# encoding：指定字符集类型，即编码，通常指定为'utf-8' # 大多数情况先将excel导出csv，再读取
输出：
省级政区代码 省级政区名称 地市级政区代码 地市级政区名称 年份 党委书记姓名 出生年份 出生月份 籍贯省份代码 籍贯省份名称 \
河北省 石家庄市 陈来立 NaN NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN NaN ... 民族 教育 是否是党校教育（是=，否=） 专业：人文 专业：社科 专业：理工 专业：农科 专业：医科 入党年份 工作年份
... NaN 硕士 1.0 NaN NaN NaN NaN NaN NaN NaN
... NaN 本科 0.0 0.0 0.0 1.0 0.0 0.0 NaN NaN
... NaN 本科 0.0 0.0 0.0 1.0 0.0 0.0 NaN NaN
... NaN 本科 0.0 0.0 0.0 1.0 0.0 0.0 NaN NaN
... NaN 本科 0.0 0.0 0.0 1.0 0.0 0.0 NaN NaN [ rows x columns]
# 读取excel数据：read_excel
data3 = pd.read_excel('地市级党委书记数据库（2000-10）.xlsx',sheetname='中国人民共和国地市级党委书记数据库（2000-10）',header=)
print(data3)
# io ：文件路径。
# sheetname：返回多表使用sheetname=[,],若sheetname=None是返回全表 → ① int/string 返回的是dataframe ②而none和list返回的是dict
# header：指定列名行，默认0，即取第一行
# index_col：指定列为索引列，也可以使用u”strings”
输出：
省级政区代码 省级政区名称 地市级政区代码 地市级政区名称 年份 党委书记姓名 出生年份 出生月份 籍贯省份代码 \
河北省 石家庄市 陈来立 NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN
河北省 石家庄市 吴振华 NaN NaN NaN
河北省 石家庄市 吴显国 NaN NaN NaN
河北省 石家庄市 吴显国 NaN NaN NaN
河北省 石家庄市 车俊 NaN NaN NaN
河北省 石家庄市 孙瑞彬 NaN NaN NaN
河北省 唐山市 白润璋 NaN NaN NaN
Pandas之DataFrame——Part 3的更多相关文章
- python 数据处理学习pandas之DataFrame
请原谅没有一次写完,本文是自己学习过程中的记录,完善pandas的学习知识,对于现有网上资料的缺少和利用python进行数据分析这本书部分知识的过时,只好以记录的形势来写这篇文章.最如果后续工作定下来 ...
- Pandas之Dataframe叠加，排序，统计，重新设置索引
Pandas之Dataframe索引,排序,统计,重新设置索引 一:叠加 import pandas as pd a_list = [df1,df2,df3] add_data = pd.concat ...
- pandas中DataFrame对象to_csv()方法中的encoding参数
当使用pd.read_csv()方法读取csv格式文件的时候,常常会因为csv文件中带有中文字符而产生字符编码错误,造成读取文件错误,在这个时候,我们可以尝试将pd.read_csv()函数的enco ...
- pandas（DataFrame）
DataFrame是二维数据结构,即数据以行和列的表格方式排列!特点:潜在的列是不同的类型,大小可变,标记行和列,可以对列和行执行算数运算. 其中Name,Age即为对应的Columns,序号0,1, ...
- Python3 Pandas的DataFrame数据的增、删、改、查
Python3 Pandas的DataFrame数据的增.删.改.查 一.DataFrame数据准备 增.删.改.查的方法有很多很多种,这里只展示出常用的几种. 参数inplace默认为False,只 ...
- Python3 Pandas的DataFrame格式数据写入excle文件、json、html、剪贴板、数据库
Python3 Pandas的DataFrame格式数据写入excle文件.json.html.剪贴板.数据库 一.DataFrame格式数据 Pandas是Python下一个开源数据分析的库,它提供 ...
- python. pandas(series,dataframe,index) method test
python. pandas(series,dataframe,index,reindex,csv file read and write) method test import pandas as ...
- pandas取dataframe特定行/列
1. 按列取.按索引/行取.按特定行列取 import numpy as np from pandas import DataFrame import pandas as pd df=DataFram ...
- Pandas中DataFrame修改列名
Pandas中DataFrame修改列名:使用 rename df = pd.read_csv('I:/Papers/consumer/codeandpaper/TmallData/result01- ...
- Spark与Pandas中DataFrame对比
Pandas Spark 工作方式 单机single machine tool,没有并行机制parallelism不支持Hadoop,处理大量数据有瓶颈 分布式并行计算框架,内建并行机制paral ...
随机推荐
- (转)在图像处理中，散度 div 具体的作用是什么？
出处http://www.zhihu.com/question/24591127 按:今天看到这篇文章,有点感慨,散度这个概念我初次接触到至少应该是在1998年,时隔这么多年后看到这篇文章,真的 佩服 ...
- redis安装与简单使用
第一步 新建一个文件 第二步 利用winscrp软件从本机上传redis的压缩包到linux新建的rdtar目录 第三步 cd rdtar 第四步 解压 tar zxvf redis-2+t ...
- 4.1 基本类型和引用类型的值【JavaScript高级程序设计第三版】
ECMAScript 变量可能包含两种不同数据类型的值:基本类型值和引用类型值.基本类型值指的是简单的数据段,而引用类型值指那些可能由多个值构成的对象. 在将一个值赋给变量时,解析器必须确定这个值是基 ...
- 微信小程序CheckBox选中事件
1.微信小程CheckBox选中问题 <checkbox-group bindchange="checkboxChange" data-index="{{index ...
- 插入排序算法Java实现
一. 算法描述 插入即表示将一个新的数据插入到一个有序数组中,并继续保持有序.例如有一个长度为N的无序数组,进行N-1次的插入即能完成排序:第一次,数组第1个数认为是有序的数组,将数组第二个元素插入仅 ...
- C语言进阶——类型转换04
C语言内可以进行类型转换: 强制类型转换 隐式类型转换 强制类型转换的语法: (tpye)value (type)value_name 强制类型转换的结果: 目标类型可以容纳目标值:结果不变 目标值不 ...
- JAVA-数组或集合
哈哈,今天我们来讲解一下有关于一些数组 或者是集合的知识点 1.ArrayList,LinkedList,Vector的区别 ArrayList,LinkedList,Vector都是实现List接口 ...
- android gridview 停止滚动
http://blog.csdn.net/yaphetzhao/article/details/50544105 参考上面的博客,关键代码我就贴出来吧: public void stopGridVie ...
- mybatis 关联查询实现一对多
场景:最近接到一个项目是查询管理人集合 同时每一个管理人还存在多个出资人 要查询一个管理人列表 每个管理人又包含了出资人列表 采用mybatis关联查询实现返回数据. 实现方式: 1 .在实体 ...
- 【Pascal's Triangle】cpp
题目: Given numRows, generate the first numRows of Pascal's triangle. For example, given numRows = 5,R ...