数据分析工具：Pandas（3）

一，数值计算和统计基础

---

1.1，行列参数：axis，是否过滤空值：shipna

   df = pd.DataFrame({
       'key1': [4, 5, 3, np.nan, 2],
       'key2': [1, 2, np.nan, 4, 5],
       'key3': ['a', 'b', 'c', 'd', 'e']
   })
   print(df)
   print(df['key1'].dtype, df['key2'].dtype, df['key3'].dtype,)
   print('-------------------')
   # np.nan:（使用numpy创造NaN空值）
   # dtype:（判断元素本身的数据类型，忽略空值NaN）
   
   print(df.mean())       
   print(df.mean(axis=1)) 
   # mean()方法:（计算平均值）
   # axis参数:（0：计算列  1：计算行）
   # skipna参数:（True：过滤空值  False：加上NaN计算，结果返回Na）

1.2，主要数学计算方法

---

1）基本方法一

df = pd.DataFrame({'key1':np.arange(11),
                  'key2':np.random.rand(11)*10})
print(df)
print('-----')

print(df.count())			# 统计非NaN的元素个数
print(df.min(), df.max())	 # 统计最小值和最大值
print(df.quantile(q=0.5))	 # 分位数，返回1/2位的数，相当于最中间的数，q是分位
print(df.sum())				# 求和
print(df.mean())			# 求平均值
print(df.median())			# 求算数中位数，所有数排序以后最中间的数
print(df.std(), df.var())	 # std，var分别求标准差，方差
print(df.skew())			# skew样本的偏度
print(df.kurt())			# kurt样本的蜂度

2），累积求和/积

df['key1_s'] = df['key1'].cumsum()
df['key2_s'] = df['key2'].cumsum()
# cumsum：（样本的累积求和，后面的值等于前面的值相加）

df['key1_p'] = df['key1'].cumprod()
df['key2_p'] = df['key2'].cumprod()
# cumsum：（样本的累积求积，后面的值等于前面的值相乘）

print(df.cummax(),'\n',df.cummin(),'→ cummax,cummin分别求累计最大值，累计最小值\n')
# 会填充key1，和key2的值

3），唯一值

s = pd.Series(list('aaasdwfafafwa'))
sq = s.unique()

print(s.is_unique,s.index.is_unique)	
# 返回True或者False，判断s里面的值是否唯一

print(s)
print(sq, type(sq))
# 返回一个一维数组

4），值计数 .value_counts()

s = pd.Series(list('aaasdwfafafwa'))
sc = s.value_counts(sort=False)# 也可以这样写：pd.value_counts(sc, sort = False)
print(sc)
# 得到一个新的Series，计算出不同值出现的频率
# sort参数：排序，默认为True对结果进行排序

5），成员资格

s = pd.Series(np.arange(10,15))
df = pd.DataFrame({'key1':list('asdcbvasd'),
                  'key2':np.arange(4,13)})
print(s)
print(df)
print('-----')

print(s.isin([5,14]))
print(df.isin(['a','bc','10',8]))
# 用[]表示
# 得到一个布尔值的Series或者Dataframe

二，文本数据

---

2.1，Series对象通过.str调用字符串的方法

s = pd.Series(['A', 'b', 'C', 'dEf', 'aaahe', np.nan])
df = pd.DataFrame({
    'key1': list('abcdefg'),
    'key2': ['aa', 'bb', 'cc', '123d', 'w124', '4697s', 'wdwa2']
}, index=list('abcdefg'))

print(s)
print(df)
print('--------------')

print(s.str.upper())# 调用字符串的方法
print(df['key1'].str.upper())
print(df['key2'].str.upper())
# 直接通过.str调用字符串方法
# 可以对Series使用，DataFrame的数据可以提取成Series进行操作
# 自动过滤NaN值

df.columns = df.columns.str.upper()
df.index = df.index.str.upper()
# df.columns和df.index，也可使用.str

2.2，字符串常用方法（1）

s = pd.Series(['A','b','bbhello','123',np.nan])

print(s.str.lower())		# lower小写
print(s.str.upper())		# upper大写
print(s.str.len())			# len字符长度
print(s.str.startswith('b')) # 判断起始是否为b
print(s.str.endswith('3'))	 # 判断结束是否为3

2.2，字符串常用方法（2） — strip

s = pd.Series([' jack', 'jill ', ' jesse ', 'frank'])
df = pd.DataFrame(np.random.randn(3, 2), columns=[' Column A ', ' Column B '],
                  index=range(3))

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的前后空格，但没有去掉中间空格

2.3，字符串常用方法（3） — replace

df = pd.DataFrame(np.random.randn(3, 2), columns=[' Column A ', ' Column B '],
                  index=range(3))
df.columns = df.columns.str.replace(' ','-')
print(df)
# 替换

df.columns = df.columns.str.replace('-','hehe',n=1)
print(df)
# n：替换个数

2.4，字符串常用方法（4） — split、rsplit

s = pd.Series(['a,b,c','1,2,3',['a,,,c'],np.nan])

print(s.str.split(','))
# 类似字符串的split，并且只会对字符串进行切割

print(s.str.split(',')[1])
# 直接索引得到一个list

print(s.str.split(',').str[0])
print(s.str.split(',').str.get(1))
print('-----')
# 可以使用get或[]符号访问拆分列表中的元素

print(s.str.split(',', expand=True))
print(s.str.split(',', expand=True, n = 1))
print(s.str.rsplit(',', expand=True, n = 1))
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)
print(df['key2'].str.split('-'))
# Dataframe使用split

2.5，字符串索引

s = pd.Series(['A','b','C','bbhello','123',np.nan,'hj'])
df = pd.DataFrame({'key1':list('abcdef'),
                  'key2':['hee','fv','w','hija','123',np.nan]})

print(s)
print(df)
print('--------------------')
print(s.str[0])
print(s.str[:2])
print(df['key2'].str[0])

三，合并(merge)

---

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

3.1，merge合并

# 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']))
# 多个链接键

1），参数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

2），使用index进行合并 → 合并方式

df1 = pd.DataFrame({'lkey':list('bbacaab'),
                   'data1':range(7)})
df2 = pd.DataFrame({'rkey':list('abd'),
                   'date2':range(3)})
print(pd.merge(df1, df2, left_on='lkey', right_on='rkey'))
print('------')
# df1以‘lkey’为键，df2以‘rkey’为键

df1 = pd.DataFrame({'key':list('abcdfeg'),
                   'data1':range(7)})
df2 = pd.DataFrame({'date2':range(100,105)},
                  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

​ 3），参数 sort

# 参数 sort

df1 = pd.DataFrame({'key':list('bbacaab'),
                   'data1':[1,3,2,4,5,9,7]})
df2 = pd.DataFrame({'key':list('abd'),
                   'date2':[11,2,33]})
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

​ 3.2，另外的合并方法 —> pd.join()

# 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':[1,3,2,4,5,9,7]})
df2 = pd.DataFrame({'key':list('abd'),
                   'date2':[11,2,33]})
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

四，连接(堆叠)与修补

---

连接 - 沿轴执行连接操作

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,keys=None, levels=None, names=None, verify_integrity=False,copy=True)

4.1，连接函数：concat

s1 = pd.Series([1, 2, 3])
s2 = pd.Series([2, 3, 4])
s3 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s4 = pd.Series([2, 3, 4], index=['b', 'e', 'd'])
print(s1)
print(s2)
print(pd.concat([s1, s2]))
print(pd.concat([s3, s4]).sort_index())
# 默认axis=0，行与行进行纵向堆叠
print('---------------')
print(s3)
print(s4)
print(pd.concat([s3, s4], axis=1))
# axis=1，列与列进行横向合并，组成一个DataFrame

​ 1），连接方式(how): join, join_axes

s5 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s6 = pd.Series([2, 3, 4], index=['b', 'c', 'd'])
print(s5)
print(s6)
print(pd.concat([s5, s6], axis=1))
print(pd.concat([s5, s6], axis=1, join='inner'))
print(pd.concat([s5, s6], axis=1, join_axes=[['a', 'b', 'd']]))
# join：outer为取并集和inner为交集。
# join_axes：指定联合的index

​ 2），层次索引，覆盖列名

sre = pd.concat([s5, s6], keys=['one', 'two'])
print(sre)
print(sre.index)
# keys：序列，默认值无。使用传递的键作为最外层构建层次索引
sre1 = pd.concat([s5, s6], axis=1, keys=['one', 'two'])
print(sre1)
# 若将两个Series以列进行横向连接，key会成为columns

3）修补(值覆盖)：pd.combine_first()

df1 = pd.DataFrame([[np.nan, 3., 5.], [-4.6, np.nan, np.nan],[np.nan, 7., np.nan]])
df2 = pd.DataFrame([[-42.6, np.nan, -8.2], [-5., 1.6, 4]],index=[1, 2])
print(df1)
print(df2)
print(df1.combine_first(df2))
print(df2.combine_first(df1))
# 根据index，df1的空值被df2替代
# 如果df2的index多于df1，则更新到df1上，比如index=['a',1]

df1.update(df2)
print(df1)
# df2的值直接覆盖到df1上面

五，去重以及替换

---

5.1，去重 .duplicated

s = pd.Series([1,1,1,1,2,2,2,3,4,5,5,5,5])
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',3,4,5],
                  'key2':['a','a','b','b','c']})
print(df.duplicated())
print(df['key2'].duplicated())
# Dataframe中使用duplicated

5.2，替换 .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':123}))
# 可一次性替换一个值或多个值
# 可传入列表或字典

​ 六，数据分组

---

分组统计 - groupby功能

① 根据某些条件将数据拆分成组
② 对每个组独立应用函数
③ 将结果合并到一个数据结构中

Dataframe在行（axis=0）或列（axis=1）上进行分组，将一个函数应用到各个分组并产生一个新值，然后函数执行结果被合并到最终的结果对象中。

df.groupby(by=None, axis=0, 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(8),
                   'D' : np.random.randn(8)})
print(df)
print('------')
# print(df.groupby('A'), type(df.groupby('A')))
# 直接分组得到一个groupby对象，是一个中间数据，没有进行计算
# print(df.groupby('A').mean())
# 自动过滤字符串，对分组的数据进行且平均值

a = df.groupby('A').mean()
b = df.groupby(['A', 'B']).mean()    # 以两个字段的值进行分组，列：foo one是一组，看成整体
c = df.groupby(['A'])['D'].mean()    # 以A进行分组，在选取字段为‘D’的进行计算
print(a, type(a))    # 得到一个新的DateFrame
print(b)
print(c)
# 默认以axis=0,进行分组

​ 5.4，分组，可迭代对象

df = pd.DataFrame({'X' : ['A', 'B', 'A', 'B'], 'Y' : [1, 4, 3, 2]})
print(df)
print(df.groupby('X'), type(df.groupby('X')))
print('-----')

print(list(df.groupby('X')), '→ 可迭代对象，直接生成list\n')
print(list(df.groupby('X'))[0], '→ 以元祖形式显示\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(8),
                   'D' : np.random.randn(8)})
grouped = df.groupby(['A','B']).groups
print(df)
print(grouped)
print(grouped[('foo', 'three')])
# 按照两个列进行分组

​ 5.5，其他轴上的分组

df = pd.DataFrame({'data1':np.random.rand(2),
                  'data2':np.random.rand(2),
                  'key1':['a','b'],
                  'key2':['one','two']})
print(df)
print(df.dtypes)
print('-----')
for n,p in df.groupby(df.dtypes, axis=1):
    print(n)
    print(p)
    print('##')
# 按照值类型分列

5.6，DataFrame字典分组，Series分组

# 通过字典或者Series分组

df = pd.DataFrame(np.arange(16).reshape(4,4),
                  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 = 1)
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来分组

​ 5.7，通过函数分组

df = pd.DataFrame(np.arange(16).reshape(4,4),
                  columns = ['a','b','c','d'],
                 index = ['abc','bcd','aa','b'])
print(df)
print(list(df.groupby(len)))
for x,y in list(df.groupby(len)):
    print(x)
    print(y)
# 通过len函数计算长度进行分类

​ 5.8，分组计算函数方法

s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
print(s)
grouped = s.groupby(level=0)  # 唯一索引用.groupby(level=0)，将同一个index的分为一组
print(grouped)
print(list(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')

​ 5.9，多函数计算：agg()

df = pd.DataFrame({'a':[1,1,2,2],
                  'b':np.random.rand(4),
                  'c':np.random.rand(4),
                  'd':np.random.rand(4),})
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

七，分组转换及一般性 ’ 拆分-应用-合并 ’

7.1，数据分组转换,transform

df = pd.DataFrame({'data1':np.random.rand(5),
                  'data2':np.random.rand(5),
                  '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每个位置元素取对应分组列的均值
# 字符串不能进行计算

7.2，apply(定义函数处理分组)

df = pd.DataFrame({'data1':np.random.rand(5),
                  'data2':np.random.rand(5),
                  'key1':list('aabba'),
                  'key2':['one','two','one','two','one']})
print(df)
print(df.groupby('key1').apply(lambda x: x.sum()))

def f_df1(d):
    return(d.sort_values('data1'))
# 定义一个函数，能够返回按照data1字段排序的数据
def f_df2(d,k1):
    return(d[k1])

print(df.groupby('key1').apply(f_df1))
print(df.groupby('key1').apply(f_df2,'data2'))  # 第二个参数传参
# 把df按照key1排序，在通过apply运行函数，返回按照data1排序后的分组数

​ 7.3，tranfrom数据join合并原表

df = pd.DataFrame({
    'data1': np.random.rand(8),
    'data2': np.random.rand(8),
    'key': list('aabbabab')
})
print(df)
df1 = df.groupby('key').transform(np.mean)
print(df.join(df1, rsuffix='_mean')) 		# 方法一
df[['data1_mean', 'data2_mean']] = df1		# 方法二

八，透视表及交叉表

8.1，透视表：pivot_table

# pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')

# 透视表：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']*3
rng = pd.to_datetime(date)
df = pd.DataFrame({'date':rng,
                   'key':list('abcdabcda'),
                  'values':np.random.rand(9)*10})
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)：计数

​ 8.2，交叉表：crosstab

# 交叉表：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': [1, 2, 2, 2, 2],
                   'B': [3, 3, 4, 4, 4],
                   'C': [1, 1, np.nan, 1, 1]})
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，添加行/列边距（小计）

九，数据读取

9.1，读取普通分隔数据：read_table

# 可以读取txt，csv

import os
os.chdir('C:/Users/Hjx/Desktop/')

data1 = pd.read_table('data1.txt', delimiter=',',header = 0, index_col=1)
print(data1)
# delimiter：用于拆分的字符，也可以用sep：sep = ','
# header：把第几行作为数据的字段名(columns),否则自动索引0, 1, .....
# index_col：指定某列为行索引，否则自动索引0, 1, .....

# read_table主要用于读取简单的数据，txt/csv

9.2，读取csv数据：read_csv

## csv文件：由逗号分隔的文本文件

data2 = pd.read_csv('data2.csv', engine='python')
print(data2.head())
# engine：使用的分析引擎。可以选择C或者是python。C引擎快但是Python引擎功能更加完备。
# encoding：指定字符集类型，即编码，通常指定为'utf-8'

# 大多数情况先将excel导出csv，再读取

​ 9.3，读取excel数据：read_excel

data3 = pd.read_excel('地市级党委书记数据库（2000-10）.xlsx',sheetname='中国人民共和国地市级党委书记数据库（2000-10）',header=0)
print(data3)
# io ：文件路径。
# sheetname(哪张表)：int或者str：返回DataFrame，[0, 1]或者None返回字典
# header：指定列名行，默认0，即取第一行
# index_col：指定列为索引列，也可以使用u”strings”