Python数据分析库Pandas

引入

import pandas as pd

《《------------------------------------------------------------------------------------------------------》》

使用

Pandas 数据结构：一维数据结构

创建字典格式： pd.Series（{“今日销售量” ： 10086，“今日成交金额”：“1000084”}，time=‘2018.8.21’）

创建数组格式： pd.Series([10086,1000084],index=['今日销售量','今日成交金额'],time='2018.8.21')

《《------------------------------------------------------------------------------------------------------》》

Dataframe ：二维数据结构是一个表格形的数据结构，“带标签的二维数组” ，带有（index） and （列标签）

使用

data = {'name':['Jake','Jeek','Anmi'],'age':[22,15,32],'time':['2019.2.1','2019.3.1','2019.4.2']}

pd.DataFrame(data) 形成一个表格数据

创建的三种方法：其他方法都不通用

1.data = {'name':['a','b','c'],'age':[22,15,32],'time':['2019.2.1','2019.3.1','2019.4.2']}

2. 第二种设置两个一维数组 Series的方式

data={'one':pd.Series(np.random.rand(2)),'two':pd.Series（np.random.rand(3)）} 不设置index的

data={'one':pd.Series(np.random.rand(2)),'two':pd.Series（np.random.rand(3)）,index=['a','b','c']} 设置 index的

3. 第三种通过二维数组，指定index 和 colums

arr=np.arange(9).reshape(3,3)

data = pd.DataFrame(arr)

data = pd.DataFrame(data,index=['a','b','c'],colums=['昨天'，‘今天’，‘明天’])

print(data)

重新指定cloums列名： pd.DataFrame(data,colums=['H5','Json','Dic'])

出现问题：

？如果指定后，列名比数据多，那么该列下面的数据显示 NaN

？如果指定后，列名少于数据，只会显示对应的列数据

《《------------------------------------------------------------------------------------------------------》》

Pandas 索引+切片中筛选数据

Series和Datafram索引的原理一样，我们以Dataframe的索引为主来学习

列索引：df['列名'] （Series不存在列索引）
行索引：df.loc[]、df.iloc[]

选择列 / 选择行 / 切片 / 布尔判断

data['one','abc'] 通过columns 选

data.loc['a','b','c','d','e'] 通过行选这个里面切片是包含最后一个的

data.iloc[:3] 通过切片用数字表示，3之前的行不包含3

data[data>50] 数据大于50的值

data[data['a'] > 50] a列》 50 行数据

？选择出来后按照顺序放入序列

data[data > 5].index().tolist() 转为数组按照顺序

《《------------------------------------------------------------------------------------------------------》》

Pandas 基本技巧

df.head() 默认前5条数据，也可以在括号内指定数字

df.tail() 默认后5条数据

df.T() 转置 index 互换 columns | 列变行，行变列

添加和修改删除数据行

（添加操作）

这个二维数据表格 index 只有 5，那么就把 index[6] 赋值

（修改操作）

df['a'] = 200 df['a'][0] = 333

（删除操作）

del df['a'] 删除 columns 【a】

df.drop(0) 删除行删除index 行

两个数据对齐合并相加

就会默认对应行和列对齐相加填充，如果没有的行和列，填充NaN

DataFrame 数据排序

      random4 = np.random.rand(3,3)*100
      print(random4)
           data4 = pd.DataFrame(random4,columns=['a','b','c'])
           data5 = data4.sort_values(['b'],ascending = True) #升序 False #降序
           data5

DataFrame 索引排序

data7.sort_index() #升序

data7.sort_index(inplace=True) #数据更新改变

《《------------------------------------------------------------------------------------------------------》》

DataFrame 数据计算和统计基础

# np.nan ：空值
# .mean()计算均值

m2 = df.mean(axis=1) 1=行数值计算结果 0 = 列结果

# axis参数：默认为0，以列来计算，axis=1，以行来计算，这里就按照行来汇总了
# 只统计数字列

m3 = df.mean(skipna=False)

# skipna参数：是否忽略NaN，默认True，如False，有NaN的列统计结果仍未NaN
# 可以通过索引单独统计一列

# 主要数学计算方法，可用于Series和DataFrame（1）

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

print(df.count(),'→ count统计非Na值的数量 ')
print(df.min(),'→ min统计最小值 ',df['key2'].max(),'→ max统计最大值 ')
print(df.quantile(q=0.75),'→ quantile统计分位数，参数q确定位置 ')
print(df.sum(),'→ sum求和 ')
print(df.mean(),'→ mean求平均值 ')
print(df.median(),'→ median求算数中位数，50%分位数 ')
print(df.std(),' ',df.var(),'→ std,var分别求标准差，方差 ')
print(df.skew(),'→ skew样本的偏度 ')
print(df.kurt(),'→ kurt样本的峰度 ')

# 主要数学计算方法，可用于Series和DataFrame（2）

df['key1'].cumsum() 单列的累计和

df['key1'].cumprod() 单列累计积

print(df.cummax(),' ',df.cummin(),'→ cummax,cummin分别求累计最大值，累计最小值 ')

# 唯一值：.unique()

解决问题：colums 中有重复的值，两个一样的列，那么取到唯一个重新整理成为一个DataFrame表格

## 值计数：.value_counts()

解决问题: 得到该数据出现的频率次数 a:2 b 3 生成一个新的 Series 括号内可写排序：sort = False or True

# 成员资格：.isin()

解决问题：一个DataFrame 显示数据，我就想知道里面有没有我指定的一个 50 有就是对应位置显示 True，没有就是False

《《------------------------------------------------------------------------------------------------------》》

pandas 文本数据处理

一般处理：

1.自动排除为np的值 NaN

2.查看指定文本数据字符的个数 .str.count()

3.修改大小写 .str.upper() .str.lower()

4.字符长度 .str.leng()

5.开始字符是哪一个 .str.startwith('')

6.结束字符是哪一个 .str.endwith('')

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

df.columns.str.upper() 修改数据列

去空格
print(s.str.strip()) # 去除字符串中的空格
print(s.str.lstrip()) # 去除字符串中的左空格
print(s.str.rstrip()) # 去除字符串中的右空格

替换字符中的空格

str.replace(' ',''，n=1) 把空格替换为空字符

不写第三个参数，那么就是全部替换，写了就是指定替换几个

# 字符串常用方法（4） - split、rsplit

print(s.str.split(',').str[0])
print(s.str.split(',').str.get(1))

# 可以使用get或[]符号访问拆分列表中的元素

# 可以使用expand可以轻松扩展此操作以返回DataFrame
# n参数限制分割数
# rsplit类似于split，反向工作，即从字符串的末尾到字符串的开头
print(s.str.split(',', expand=True))
print(s.str.split(',', expand=True, n = 1))
print(s.str.rsplit(',', expand=True, n = 1))

# 字符串索引

print(s.str[0]) # 取第一个字符串
print(s.str[:2]) # 取前两个字符串
print(df['key2'].str[0])
# str之后和字符串本身索引方式相同

DataFrame 合并

.merge（data1,data2,on='key'）根据key列为索引合并，看下两个是否共有一样的key ，有就保留

@合并有有一个分类：交集和并集 how='' /inner、outer 、left、right

交集：解释就是原有的数据合并没有对应上，那么就会不要，只保留共有的

并集：解释就是合并后不管你有没有，都会保留，只不过有的就是保留原有数据，没有的 NaN

然后就是设置参考键： on=‘’ 设置根据on里面的值，两两对比，如果一样就合并

on是一个键，how='left' 根据两个表，用第一个表 how='right' 根据两个表，用第二个表

指定参考键：我想用左边的lkey列作为左边的参考键，我想用右边表的index 作为参考键（两个数据表合并比较）

（left_index right_index 左边（设置True就行） left_on right_on 这俩on（还是制定 index只不过分开指定，左表，右表说法））

代码展示

dataG = pd.DataFrame({'key':list('abcdedf'),'list':range(7)});
dataW = pd.DataFrame({'key':list('abcdedf'),'list':range(3,10)});
print(pd.merge(dataG,dataW,on=['list'],how='outer'))

how ='outer' 根据list为合并的条件，用了outer 没有达到要求的NaN补全

print(pd.merge(df1, df2, left_on='key', right_index=True))

左边的指定键为key，右边的表用角标index 为键合并比较

数据连接

两个DataFrame 连接，通过pd.concat([数组表1，数组表2]).sort_index() 角标顺序排列连接

两个DataFrame 连接，通过 pd.concat([数组表1，数组表2])，axis=1 列+列成为一个DataFrame ，空的位置用 NaN补全

inplace

两个Series pd.reset_index(inplace=True).drop = True

一个Series一维，重置了他的index值，0 1 2 3 4 5 6 然后吧替换之前的index 设置为一个列，drop 设置True 就是问你是否删除这个之前的；列

去重

按照 s.duplicate() 就会出现一个 True False 的列表，打印出 s[s.s.duplicate() == False] False 就代表不重复的值

replace

replace('a','w') replace(['a','b'],50) 都可以进行一个替换

DataFrame 数据分组（简称列分组）

根据数据列columns名字，分组，并计算处理，得出数据求和、平均值、长度、常用的一些列计算

简单解释语句：

df.groupby('A') 通过A列，里面的数据只要不一样就会成组，分成一个组然后计算

df.groupby(['A','B']).mean() 通过A/B两列，里面的数据，只要A 和 B两个组成不同的配对，就可以成组，计算

df.groupby(['A'])['D'].mean() # 以A分组，算D的平均值

分组后类型格式为 groupby类型，经过处理后得出可迭代对象，可以是数组、元祖、字典一一对应操作方法

              print(list(df.groupby('X')), '→ 可迭代对象，直接生成list ')
              print(list(df.groupby('X'))[0], '→ 以元祖形式显示 ')
             for n,g in df.groupby('X'):
   print(n)
   print(g)
   print('###')     # n是组名，g是分组后的Dataframe

# .get_group()提取分组后的组

print(df.groupby(['X']).get_group('A'),' ')

# .groups：将分组后的groups转为dict
# 可以字典索引方法来查看groups里的元素

              grouped = df.groupby(['X'])
              print(grouped.groups)
              print(grouped.groups['A']) # 也可写：df.groupby('X').groups['A']

# .size()：查看分组后的长度

grouped.size()

# 按照两个列进行分组

     grouped = df.groupby(['A','B']).groups
           print(df)
           print(grouped)
           print(grouped[('foo', 'three')])

# 分组计算函数方法

s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
grouped = s.groupby(level=0) # 唯一索引用.groupby(level=0)，将同一个index的分为一组
print(grouped)
print(grouped.first(),'→ first：非NaN的第一个值 ')
print(grouped.last(),'→ last：非NaN的最后一个值 ')
print(grouped.sum(),'→ sum：非NaN的和 ')
print(grouped.mean(),'→ mean：非NaN的平均值 ')
print(grouped.median(),'→ median：非NaN的算术中位数 ')
print(grouped.count(),'→ count：非NaN的值 ')
print(grouped.min(),'→ min、max：非NaN的最小值、最大值 ')
print(grouped.std(),'→ std，var：非NaN的标准差和方差 ')
print(grouped.prod(),'→ prod：非NaN的积 ')

DataFrame 读取分组

import os 引入修改默认引入路径
os.chdir('c:/zzz/www')

导入普通文本文件类型

pd.read_table('data1.txt',delimiter=',',sep=False)

导入Excel数据表格少量数据

dataexcel = pd.read_excel('地市级党委书记数据库（2000-10）.xlsx',sheet_name='中国人民共和国地市级党委书记数据库（2000-10）',header=0)
print(dataexcel.head())

导入CSV大型数据表格

datacsv = pd.read_csv('地市级党委书记数据库（2000-10）.csv',encoding = 'utf-8')
print(datacsv.head())