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
规定索引顺序：index = [‘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)    # 一一匹配

六、排序

语法：sort_index(axis,ascending)

#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)

#  重复的轴的排序
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'))