python pandas

一、Pandas 基本数据结构

1.series

类似一维数组的对象，由一组数据（各种numpy数据类型）和与之相关的索引列组成。

创建：

(1)obj = Series([1,2,3,4],index=[‘a’,‘b’,‘c’,‘d’])
此索引是自定义的，默认的索引是0123，读取的时候既可以用自定义的索引值，也可以用默认的索引来读取。
读取：obj[0] 或者 obj[‘a’] 2个读取：obj[[‘a’,‘c’]] 区间读：obj[‘a’:‘c’]
修改：obj[‘a’]=50

(2)city = {‘beijing’:35000,‘shanghai’:45000,‘guangzhou’:50000,‘shenzhen’:55000}
s2 = Series(city)
通过字典来创建series.字典的key会自动变成index
规定索引顺序：index2 = [‘beijing’, ‘shanghai’, ‘guangzhou’, ‘shenzhen’]
s3 = Series(city,index=index2)
规定顺序后依然可以更改索引：s3.index = list(‘abcd’)

2.DataFrame

表格型数据结构，有行索引和列索引,行索引：index ;列索引：columns
创建：

（1）由等长列表或Numpy数组构成的字典：

import pandas as pd
from pandas import Series,DataFrame
data = {
    'city':['beijing','shanghai','guangzhou','shenzhen','wanwan'],
    'year':[2014,2015,2016,2017,2018],
    'pop':[1.5,1.7,1.0,2.1,2.3]
}
df1 = pd.DataFrame(data)
# 自定义列的显示顺序
df2 = DataFrame(data,columns=['year','city','pop'])
# 读取数据
df2.city #方法1
df2['year']#方法二
df2['city'][3] #读取城市中下标为3的。'shenzhen'
#重新赋值
df2['pop'][2]=1.9
# 赋值的列名不存在,会新建一列,如果长度比索引的长度长，则会报错，如果给一个值，那么一列就会被填充满这个值
df2['debt'] = np.arange(5.0) #长度刚好，正确
 # 改索引值，按照‘，’分割，改的是行索引的值，默认的是01234
df2.index = 'one,two,three,four,five'.split(',')  
# 再加一列，赋值的类型为Series.会在索引值对应的地方填上数字，无值的地方用nan填充
df2['debt2'] = Series([-10,-30,-50],index=['one','two','five'])
#再加一列，即使长度一致也要保证index的匹配，否则没有值，会显示NAN
df2['debt3'] = Series([9,8,'k','a','k'],index = 'one,two,three,four,five'.split(',') )    
#再加一列，我们从已有的列中而来的数据不规定索引也能添加数据，返回的是df2.city=='上海'的值，是一些布尔类型的值
df2['pcity'] = (df2.city=='shanghai')   
#删除列：
del df2['debt3']

（2）嵌套字典（即字典中的字典）

#第一个key是列索引，第二个Key是行索引
data2 = {
    'shanghai':{2000:2.4,2001:3.5},
    'beijing':{2001:3.4,2002:4.4}
}
df3 = DataFrame(data2)
# 转置
df3.T
 #给行和列索引取名 
df3.index.name='年份'
df3.columns.name='城市'

** 额外的小知识 **

时间处理：用日期做索引

#随便定义的8天的日期
dates = pd.date_range('20181001',periods=8) #期间为8
#将时间作为索引
df4 = DataFrame(np.random.randn(8,5),index=dates,columns=list('ABCDE')) #8行5列的随机数

二、Series与DataFrame中的索引

1.读取 赋值和删除

1）.series

import numpy as np 
import pandas as pd 
from pandas import Series,DataFrame
#准备一个Series
s = Series(np.arange(4),index=list('ABCD'))
#读取所有的index
s.index
#读取index中下标为2的
s.index[2] 
#index是不能更改和赋值的
s.index[2]= 'H' #不能修改赋值
# series的删除
del s['D']

2）.DataFrame

object.drop(‘XXX’,axis=0) 默认删除横向数据
object.drop(‘YYY’,axis=1)纵向删除

#准备一个DataFrame
df = DataFrame(
    np.arange(16).reshape(4,4),
    index = list('abcd'),
    columns= 'one|two|three|four'.split('|')
)
# 返回删除后的返回值,原数据不变
drop1 = df.drop(['a','b'])
# 纵向删除 一定要加上轴
drop1.drop(['four'],axis=1)
#读取 DataFrame 行索引，一列
df.loc['b'] #根据索引读取 location
df.iloc[1] #根据下标读取 index location

2.索引的选区和过滤

#准备一个series
s1 = Series(
    np.arange(2,9),
    index=list('abcdefg')
)
#读取
s1['b']
s1[1]
s1[1:4]
s1<5#返回布尔值
s1[s1<5] #有条件的读取 返回值
df.loc['a':'c']#索引行，读取列

三、pandas中的数据运算与算术对齐

pandas最重要的一个功能是,它可以对不同索引的对象进行算术运算。在将对象相加时,如果存在不同的索引|对,则结果的索引就是该索引对的并集。

1.算术相加

1）.Series

#准备2Series
s1 = Series([1,2,3,4],index=list('abcd'))
s2 = Series([8,7,6,5],index=list('abef'))
#直接相加
s1+s2 #法一
s1.add(s2) #法二

a    9.0
b    9.0
c    NaN
d    NaN
e    NaN
f    NaN
dtype: float64

2).DataFrame相加

#准备2个DataFrame
df1 = DataFrame(
    np.arange(9.0).reshape(3,3),
    index=list('ABC'),
    columns=list('abc')
)
df2 =DataFrame(
    np.arange(20.0).reshape(4,5),
    index=list('BCDE'),
    columns=list('acdef')
)

（1）直接相加

#直接相加
df1+df2

只有df1和df2 行列相同有值的才有结果

（2）相加并对空缺部分进行填充

两个中有一个有值，另一个df则填充，如果两个df都没有数据，则不填充
语法：df1.add(df2,fill_value = ‘’)
①：

df1.add(df2,fill_value=0)    #先替换为0再相加

填充nan的值：
语法：xxx.fillna()

df1.add(df2).fillna(0)  #先相加再把nan替换为nan 

df1.add(df2,fill_value=0).fillna(0)   # 相加之后将余下的nan再替换为0

2.算术的减、乘、除

df1.sub(df2) #减法
df1.div(df2) #除法   0 作除数， 趋紧inf 无穷
df1.mul(df2) #乘法

四、DataFrame 和Series的运算

# 在df1中添加新的一列
df1['d']= Series([11,12,13],index=list('ABC'))

df1_A = df1.loc['A'] #提取A行，提取出来的值是Series值
 #对应位相减
df1-df1_A  

A:0.0-0.0,1.0-1.0,2.0-2.0,11-11
B:3.0-0.0,4.0-1.0,5.0-2.0,12-11
C:6.0-0.0,7.0-1.0,8.0-2.0,13-11

五 、函数的应用和映射

#准备一个df
df4 = DataFrame(
    np.random.randn(4,3),
    index=list('ABCD'),
    columns=list('abc')
)
df4['a'] #默认的取的是列
df4.loc['A'] #取的是行
# 使用Numpy的函数都没有问题 
np.abs(df4) #取绝对值

# 最大值减去最小值，写个通用函数
np.max(df4) #得到了每一列的最大值
np.min(df4) # 每一列的最小值
np.max(df4)-np.min(df4)

 # 使用函数,axis=0是默认的    
ufunc = lambda x:x.max()-x.min()
df4.apply(ufunc,axis=1)#将某个函数应用到xx里 

# 保留几位小数
myformat = lambda x:'%.2f'%x
df4.applymap(myformat)    # appplymap应用一一匹配

六、排序

语法：sort_index(axis,ascending)

知识链接：python基础中的sort：key参数是按照某列或某行来排列
sort(…)
L.sort(key=None, reverse=False)

#python中的排序
list5 = [1,3,5,2,4,6]
list5.sort()  #默认是升序排序的
list5.sort(reverse=1) #降序

# 按照某一项进行排序
#准备一个列表
list2 = [
    [10,'a',4],
    [50,'c',12],
    [60,'d',6],
    [30,'b',9]
]
#按照第一列数据来进行排序，降序 reverse=True或 reverse=1 都表示降序
list2.sort(key=lambda x:x[0],reverse=True) 

#pandas中的排序
#准备一个Series
s5 = Series([1,3,5,2,4,6],index=list('adbecf'))
# 先按照索引排序,原结果是不变的
s5.sort_index()
# 按照值进行排序
s5.sort_values()

#准备一个DataFrame
df5 = DataFrame(
    np.random.choice(np.arange(100),replace=False,size=16).reshape(8,2),
    index=list('asdfghjk'),
    columns= list('AB')
)
#按列排序
df5.sort_index(axis=1)
df5.sort_values(by='a',axis=1,ascending=False)   #要选择轴
df5.sort_values(by='B',axis=0,ascending=False) #降序,默认是升序排

#按照多行或多列对DataFrame进行排序，将name传给by
df50.sort_values(by='A')
df50.sort_values(by=['A','B'],ascending=False)     # 先按照A的值进行排序，如果A存在相同的值，那么在A的基础上再对B进行排序

按照A的值进行排序，默认是升序

#  重复的轴的排序
s7 = Series(range(8),index=list('aaabbccc'))
# 读取的是所有
s7['a']
# 判断是否是唯一的index
s7.index.is_unique # 返回的是布尔值
df7.columns.is_unique #返回的是布尔值
df7 = DataFrame(np.arange(9).reshape(3,3),index=list('aaa'),columns=list('bbc'))

六、汇总计算描述统计

#准备一个dataframe ,注意四个值放在一个列表里
df8 = DataFrame(
    [[2,np.nan],
    [-7,5],
    [np.nan,np.nan],
    [1,-2]],
    index=list('abcd'),
    columns = ['one','two']
)
df8

1.SUM 求和

# 求和
df8.sum()   # 一
df8.sum(axis=0) # 二 
df8.sum(axis='index') # 三
df8.sum(axis='columns') #列索引，按行进行求和

nan没有参与运算

2.mean 求平均数

# 求平均数,默认nan不参与运算,skipna = True 或者False :是否跳过nan。
df8.mean()  #默认axis=0 ，竖着求平均值
df8.mean(axis=1) #横着求平均值
#不要跳过nan, 只要nan参与计算得到的结果就是nan
df8.mean(skipna=False)

3.cumsum 累计求和

# 累计求和
#准备一个dataframe
df81 = DataFrame(
    np.arange(1,13).reshape(4,3),
    index=list('abcd'),
    columns=list('ABC')
)

df81.cumsum() #竖着加

df81.cumsum(axis=1) #横着加

df81.cumsum().cumsum(axis=1) #先竖着加，再横着加

4.describe 一次性展示多种数值

用df81这个数据

#描述DataFrame
df81.describe()

#描述Series
s8 = Series(list('aaabbcdd')*5)
s8.describe() 

count     40
unique     4
top        a
freq      15
dtype: object

count:总数；unique:非重复数 top：众数； freq:众数的频率 如果有两个值是众数，也只显示一个数

七、唯一值、值计数与成员资格

1 .唯一值

Series.unique( )提取唯一值
返回的值是无序的，如果需要排序，可以用uniques.sort()

#准备一个series
s9 = Series([4,1,2,3,3,4],index= list('ccdadd'))
#只提取唯一值，不管索引是否重复
s9.unique()

#准备一个dataframe
df9= DataFrame(np.random.randint(1,6,48).reshape(6,8))
df9[2].unique() # 默认按列读取
df9.iloc[5].unique() #读取第5行

2.值计数

value_counts() 值计数 用于计算每个值的数量 默认按照数量的降序排序

value_counts(self, normalize=False, sort=True, ascending=False, bins=None, dropna=True)
normalize:bool 默认为False,如果为True,返回的对象包含唯一值的相对频率
sort:bool 默认为True ,按照统计值排序
ascending:bool 默认是False,降序排序。
bins:int,可选，分组数据，为pd.cut()提供便利，仅适用于数字
dropna:bool ,默认为true,丢弃nan的值.

series 还是用的s9这个数据 ，
s9:

1.直接进行值计数

#对s9进行值计数
s9.value_counts()

4出现了2次，3出现了2次，2出现了一次，1出现了1次

2.normalize

s9.value_counts(normalize=True) # 返回唯一值的相对频率

3.sort and ascending

#重新写了个s9
s9 = Series([10.0,20.0,40.0,40.0,40.0,30.0,30.0,20.0,20.0,20.0],index=list('abcacacbaa'))
print(s9)
s9.value_counts(sort=True,ascending=False)

4.bins

#bins 分区间统计 
# 先将s9分成10份等比例的，再进行升序排序
s9.value_counts(normalize=False,sort=True,ascending=True,bins=10) 

5.drop

# drop 默认丢弃nan的值
s9[5]=np.nan #将下标是5的数字改成nan，注意：修改nan 数字类型必须要是浮点数
s9.value_counts(dropna= False) # 不丢弃nan
s9.value_counts() #默认被丢掉了

6.pandas.value_counts()

value_counts(传入的数据, sort=True, ascending=False, normalize=False, bins=None, dropna=True)
Compute a histogram of the counts of non-null values.

pd.value_counts(s9,dropna=False)

3.成员资格 isin

isin() 判断值在某数据， 参数是set ,list-like
s9:

# 判断20 或 30 是否在s9中
s9.isin({20,30})
s9.isin([20,30]) 
s9.isin((20,30))

4.将value_counts与apply结合起来应用

可以对DataFrame来apply我们的pd.value_counts.这样会统计每一行或每一列的统计结果
df9:

df9.apply(pd.value_counts,axis=0)   #按列统计的
# !!得到的展示结果最前面的不是index 而是原来的统计的数值

df9.apply(pd.value_counts,axis=1) # 按行来统计的

八、缺失值处理

1.删除缺失值

#创建一个series
s10 = Series([1,np.nan,None,4,np.nan,5])
s10.dropna() #丢弃nan
s10.fillna(666) #将nan填充为666

 # dataframe是一样的使用， 但是在dropna的时候有不同
# 创建一个dataframe
df10 =df9.apply(pd.value_counts,axis=0) 

df10.dropna() # 丢掉所有含有nan的行

df10.dropna(axis=1) #丢掉所有含有nan的列

df10.dropna(how='all') #删除一行全是nan的数据

因为该数据没有全是nan的一行，所以没有变化

#添加全是Nan的行试一试
df10.loc[6]=Series([np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan],index=list('ABCDEFGH'))
df10.loc[7]=Series()

2.填充缺失值

df10:

df10.fillna(0) #将nan 填充为0    但是df10并没有被修改
df10.fillna({'A':100,'B':1000}).fillna(666) #目前只能按列填充

# 参数 inplace=True就是在原值上进行更改
df10.fillna(-2,inplace=True) # 把所有的nan变成-2

额外：
将np.nan 简写为NA导入的模块

from numpy import nan as NA   # 将np.nan 变成NA

九、pandas中的字符串操作

# 准备一个很多空格的字符串
str12 = 'a ,b,          c          
#将字符串单独提取出来
list12 = [each.strip() for each in str12.split(',')]   

a1,b1,c1 = list12
#法一：
a1+'::'+b1+'::'+c1
#法二：
'::'.join(list12)  # xxx.join(list) 返回一个字符串

'a::b::c'

# x in yyy
str1 = 'hello world'
'w' in str1

True

# find()  寻找不存在的值返回-1
str1.find('z')  
# index() 寻找不存在的值报错
str1.index('z')
# count() 计数
str12.count(',')
 # replace (x,y ) 把x替换为y
str1.replace('world','moto')

# 假设字符串 
name='张三/李四/王二/赵六'
#分段存成CSV
name.replace('/',',')

'张三,李四,王二,赵六'

# 然后又 一个字符串，里面的字母个数不一样，只能用正则来提取
str2= 'a,bb.cdd~dfd!ef%f&g'
import re #导入正则包
#使用正则来提取
reg= re.compile('[a-z]+')
re.findall(reg,str2)

十、pandas中的日期时间处理

from datetime import datetime #导入模块
#设定一个时间
time1 = datetime(2018,7,23)
#获取当前时间
now = datetime.today()#法一
now2=datetime.now()#法二
#将日期对象转成字符串
now.strftime('%Y-%m-%d %H:%M:%S.%f')  
#把字符串转成datetime 对象
datetime.strptime('2018-09-29 14:28:16.694226','%Y-%m-%d %H:%M:%S.%f') #parse:解析
# 求时间中 的差
now-time1
# dateutil.parser.parse 处理日期
from dateutil.parser import parse # 导入模块
#下面将各种形式的字符串转换成 datetime对象
parse('2018-7-23 9:00:00')
parse('2018-7-23 9 PM')
parse('Oct 1,2018 6:0:0 pm')
parse('18-7-23') #  会读成 日-月-年
parse('07-08-09') #默认是月 日 年，当第一个数字超过月份的时候才会成为日
parse('07-08-09',dayfirst='True')   #让第一个是day
parse('7/23/2018') # 月 日 年
parse('23/3/2018') # 日 月 年

pandas 处理时间日期：

# 准备一个列表
datelist =['7/23/2018','9/29/2018']
# 转化为时间的格式
date13 = pd.to_datetime(datelist)
# datalist从datalist中添加NA，None,2018-10-01三条数据
datelist1 = datelist+[NA,None,'2018-10-01']
# 转化为时间的格式
date14 =pd.to_datetime(datelist1)
# 读物date14中的第一条
date14[1]
# 判断是否为nul,返回布尔值l
date14.isnull()

Series 或 dataframe 使用日期作为index

# 准备一个时间数据
dates= [
    datetime(2018,10,1),
    datetime(2018,10,2),
    datetime(2018,10,3),
    datetime(2018,10,4),
    datetime(2018,10,5),
    datetime(2018,10,6),
    datetime(2018,10,7)
]
# 随机创建一个series，使用date作为index。
s13 = Series(np.random.randn(7),index=dates)

!!! 读取某个index对应的值的n多方法

# 读取第七个值
s13.iloc[6]
s13['2018-10-7']
s13['2018/10/7']
s13['20181007']
s13['10/7/2018']

索引选区：

# 使用pandas.date_range( '时间字符串',periods = int) 构建时间区间
pd.date_range('2018/10/1',periods=7)
# 创建一个series，索引是 从2017年9月29日 起一年内的数据
s_long = Series(np.random.randn(365),index= pd.date_range('2017/9/29',periods=365))
# 读取2017年的所有数据
s_long['2017']
# 读取2018年的数据
s_long['2018']
# 读取某个月份，如 2017-10
s_long['2017-10']
# 指定日期区间 
index = pd.date_range('2017/11/11','2018/05/20')
s_long[index]  # 读取指定日期区间
s_long['2017/12/11':'2018/4/20']  # 读取区间
#生成以某个日期开始隔了多少天的日期
pd.date_range(start='2018/2/14',periods=49)
#生成以某个日期结束 向前推了多少天的日期
pd.date_range(end='2018/9/9',periods=81)
s_long[0:-1] # 读取全部
# s_long[index[0]:index[-1]] = s_long['2017-11-11 ','2018-05-20']