pandas笔记和代码

1.Series

import numpy as np
import pandas as pd
s = pd.Series([False,21,True,2018,'yokan'],index=['gender','age','ishandsome','nowDate','name'])    #创建一个Series,和字典类似
print(s)            #可以不给index,不给的话会按照0,1,2,3,4,5这样的顺序来生成index

s = pd.Series({'name':'yokan','age':21,'gender':False,'ishandsome':True})            #既然是类似于字典,自然也可以用字典创建
print(s)                        
print(s[['name','age','gender']])                #取值和字典也是一样的单独取值，也可以传入一个数组的key进行取值

home_price = pd.Series({'ShenZhen':53700,'Shanghai':61000,'Beijing':68000,'Wuhan':20000,'Chendu':30000,'Chongqin':36000})
print(home_price[home_price < 60000])            #同时也可以根据范围取值

print(home_price < 60000)             #这个是返回True和False,而这个可以用作home_price进行True的取值

home_price = pd.Series({'ShenZhen':53700,'Shanghai':61000,'Beijing':68000,'Wuhan':20000,'Chendu':30000,'Chongqin':36000})
home_price['ShenZhen'] = 55000            #和字典一样可以对Series的值进行修改
print(home_price)            

home_price = pd.Series({'ShenZhen':53700,'Shanghai':61000,'Beijing':68000,'Wuhan':20000,'Chendu':30000,'Chongqin':36000})
home_price[home_price < 50000]  = 40000
print(home_price)                    #也可以根据范围重新赋值

home_price = pd.Series({'ShenZhen':53700,'Shanghai':61000,'Beijing':68000,'Wuhan':20000,'Chendu':30000,'Chongqin':36000})
print(home_price + 10000) #加
print(home_price - 10000) #减
print(home_price * 2)    #乘
print(home_price / 2)   #除

home_price = pd.Series({'ShenZhen':53700,'Shanghai':61000,'Beijing':68000,'Wuhan':20000,'Chendu':30000,'Chongqin':36000})
car_price = pd.Series({'ShenZhen':200000,'Shanghai':110000,'Beijing':680000,'Wuhan':90000,'Chendu':80000,'Xian':36000})
n_price = (car_price + home_price * 100) #两者相加,因为两者的key并不是完全一毛一样,所以会产生NAN值
print(n_price.notnull()) #找出NAN值,返回bool值

2.DataFrame

data_f = pd.DataFrame({'city':['ShenZhen','Chendu','Guangzhou','chonqin','Beijing','Xian'],
                       'GDP':[100000,80000,90000,75000,200000,60000],
                       'year':[2016,2017,2018,2015,2016,2017]},index=['one','two','three','four','five','six'],columns=['city','GDP','year'])
print(data_f)        #创建一个dataFrame对象,index,为左边的index值,不填就默认从0开始,columns不填的话就全部展示,填什么展示什么

data_f = pd.DataFrame({'city':['ShenZhen','Chendu','Guangzhou','chonqin','Beijing','Xian'],
                       'GDP':[100000,80000,90000,75000,200000,60000],
                       'year':[2016,2017,2018,2015,2016,2017]},index=['one','two','three','four','five','six'],columns=['city','GDP','year'])
print(data_f['city'])            #获取dataFrame的一列
print(type(data_f))              #整体元素就是个DataFrame
print(type(data_f['city']))      #单列的元素就是个Series
print(data_f.city)               #同样是获取单列元素
print(data_f.ix['two'])          #获取一行元素
print(type(data_f.ix['two']))    #单行元素也是个Series
print(data_f.ix[1])              #这个方式也可以获取一个单行元素

data_f = pd.DataFrame({'city':['ShenZhen','Chendu','Guangzhou','chonqin','Beijing','Xian'],
                       'GDP':[100000,80000,90000,75000,200000,60000],
                       'year':[2016,2017,2018,2015,2016,2017]},index=['one','two','three','four','five','six'],columns=['city','GDP','year','population','isCapital'])
data_f['isCapital'] = (data_f.city == "Beijing")    #判断city信息是不是Beijing,如果是把isCapital改成True
print(data_f)
print(data_f.columns)             #获取该DataFrame的columns,相当于矩阵的列
print(data_f.index)               #获取该DataFrame的index,相当于矩阵的行
print(data_f.T)                   #讲DataFrame转置

data_f = pd.DataFrame({'Shanghai':[2100,2200,2300,2400,2500,2600,2700],'beijing':[3000,3100,3200,3300,3400,3500,3600]},index=[2011,2012,2013,2014,2015,2016,2017])
print(data_f)
print(data_f['beijing'][:2])  #把北京2011年和2012年的数据切片出来
print(data_f['Shanghai'][1:]) #从第二行开始切片到最后一行,注意后面填-1是切到倒数第二行

data_f = pd.DataFrame({'Shanghai':[2100,2200,2300,2400,2500,2600,2700],'beijing':[3000,3100,3200,3300,3400,3500,3600]},index=[2011,2012,2013,2014,2015,2016,2017])
data_f.columns.name = 'city'     #给dataFrame的colument设置个名称,跑起来就看出效果了
data_f.index.name = 'years'      #给dataFrame的index设置个名称
print(data_f)                    
print(data_f.values)             #获取纯value就是不含columns和index.得到的是一个numpy的数组

indexObject

obj = pd.Series(range(3),index=['a','b','c'])            #创建一个普通的Series
print(obj.index)                    #取出index对象,这就是index
m_index = pd.Index(range(3))    #创建index对象
print(m_index)
s = pd.Series(range(3),index=m_index) #为Series赋值,并把前面的index对象当参数传入进去
print(s.index is m_index)     #返回true,可见还是同一个index

obj = pd.Series(range(5),index=['a','b','c','d','e'])print(obj[1:3])  #创建一个[0:4]index为a,b,c,d,e的Series
print(obj['b':'d'])          #obj[1:3]是截取第二行和第三行,也就是'b','c'这两行,不包括第四行,奇怪的是'b':'d'居然包括'd'
obj['b':'d'] = 5             #给b,c,d三行赋值
print(obj)                    #打印赋值后的Series

m_index = pd.Index(['a','b','c','d'])    #创建一个index,准备赋值给DataFrame
data_f = pd.DataFrame(np.arange(16).reshape((4,4)),index=m_index,columns=['Hubei','Guangdong','Beijing','Wuhan'])   #初始化一个DataFrame
print(data_f[:2])                   #这里切片是对index切片,所以是行方向切出第一行和第二行,就是a,b两行
print(data_f['Hubei':'Beijing'])    #这里是对列切片,不过只能切出列的字符,并不能得到其它信息
print(data_f.ix[:,'Guangdong':'Beijing'])   #这个对列切片就能得到很完整的信息了,这样切片是得到Guangdong和Beijing两列
print(data_f.ix[:'c','Guangdong':'Beijing']) #这个是对行和列都切片对行是切到'c',所有得到的是abc三行和Guangdong，Beijing两列的交集
print(data_f[data_f.Guangdong > 7]) #找出所有符合条件的行
data_f[data_f < 10] = 5 #对找出符合条件的元素全部赋值,与上者不同的是,上者是行操作(虽然Guangdong是列,但实际筛掉的是行),这个是所有元素的操作
print(data_f)

reindex

s = pd.Series(np.arange(4),index=['a','b','c','d']) #创建一个以m_index为index的Series
s = s.reindex(['a','b','c','d','e'],fill_value=0) #改变index值,如果添加index的话,默认是NAN,如果要给个默认值,加个fill_value字段,然后要默认什么自己填
print(s) #注意要接受返回值,这个不是在原Series上做修改

s = pd.Series(["tree",'bell tree','double tree'],index=[0,2,4])
print(s.reindex(np.arange(6),method='ffill'))   #因为重新生成的index 1,3,5是没值的,method就代表填充方式,ffill就是根据这个值前面的值来
print(s.reindex(np.arange(6),method='bfill'))   #而bfill就是根据后面的值来填充,如果前面或者后面没值就填充NaN

m_index = pd.Index(['a','b','c','d'])    #创建一个index,准备赋值给DataFrame
data_f = pd.DataFrame(np.arange(16).reshape((4,4)),index=m_index,columns=['Hubei','Guangdong','Beijing','Wuhan'])   #初始化一个DataFrame
print(data_f.reindex(['a','b','c','d','e']))     #给dataframe重新定义index,多余的值没填充则表示为NaN
print(data_f.reindex(columns = ['Hubei','Guangdong','Beijing','Wuhan','Shanghai','Tianjin']))  #给dataframe重新定义columns,多余的值，则是NaN
#同时重新定义index和columns,这个应该写成下面这样,但实际写成下面这样会报错,我在stackoverflow上找到了答案,如果感兴趣可以看看原因
# print(data_f.reindex(index = ['a','b','c','d','e'],method='ffill',columns = ['Hubei','Guangdong','Beijing','Wuhan','Shanghai']))
#https://stackoverflow.com/questions/47388717/python-reindexing-with-method-ffill
print(data_f.sort_index(axis=1).reindex(index = ['a','b','c','d','e'],method='ffill',columns = sorted(['Hubei','Guangdong','Beijing','Wuhan','Shanghai'])))

drop删除

m_index = pd.Index(['a','b','c','d'])
s = pd.Series(np.arange(4),m_index)
# print(s.drop('a')) #删除一行
print(s.drop(['a','c'])) #删除多行

m_index = pd.Index(['a','b','c','d'])    #创建一个index,准备赋值给DataFrame
data_f = pd.DataFrame(np.arange(16).reshape((4,4)),index=m_index,columns=['Hubei','Guangdong','Beijing','Wuhan'])   #初始化一个DataFrame
print(data_f.drop('a'))   #删除一行
print(data_f.drop(['a','c']))   #删除多行
print(data_f.drop('Guangdong',axis=1)) #删除一列,axis必须要改成1,1是列操作
print(data_f.drop(['Guangdong','Beijing'],axis=1)) #删除多列

hierarchical index

#hierarchical index可以理解为索引的索引
s = pd.Series(np.arange(12),index=[['a','a','a','b','b','c','c','c','d','d','d','d'],[1,2,3,1,2,1,2,3,1,2,3,4]]) #建立一个hierarchical index的Series
print(s.index)  #查看索引
print(s['b'])   #hierarchical index切出值，比如是b返回的就是第4列和第五列的值
print(s['b':'d']) #hierarchical index的范围取值,比如b:d就是返回所有bcd的值,
print(s[1:3])     #这个还是原本的切片
print(s.unstack())    #变成一个以abcd和1234组成的dataframe
print(s.unstack().stack())   #转换成原来的Series

#data_f为啥要hierarchical index，我想把这个data_f打印出来,多少能明白点吧,就是数据瞎弄的,凑合看看吧
data_f = pd.DataFrame(np.random.random((3,4)) * 1000,columns=[['Changsha','Changsha','Nanchang','Nanchang'],['home','car','home','car']],index=[['2016','2016','2017'],[1,2,1]])
data_f.columns.names = ['city','priceOfType']   #定义columns中 hierarchical index,index的名称
data_f.index.names = ['year','month']     #定义index中hierarchical index,index的名称
print(data_f)
print(data_f.ix['2016',2])                #查看2016年2月各城市的房价,车价
print(data_f.ix['2016',2]['Changsha']['home'])  #查看2016年2月,长沙的房价

Concatenate

data_f1 = pd.DataFrame({'gdp':[2000,2400,2600,2800],'home_price':[51000,52000,48000,30000]},index=['Beijing','Chendu','Dalian','Shenzhen'])
data_f2 = pd.DataFrame({'gdp':[2000,2400,2600,2800],'home_price':[51000,52000,48000,20000]},index=['Shanghai','Sichuan','Jingzhou','Wuhan'])
data_f3 = pd.DataFrame({'gdp':[2000,2400,2600,2800],'home_price':[51000,52000,48000,20000]},index=['Nanning','Nanjing','Jinzhou','Datonng'])
dfs = [data_f1,data_f2,data_f3] #创建三个columns和index相同的df,然后加入一个数组
print(pd.concat(dfs))       #合并
print(pd.concat(dfs,keys = ['df1','df2','df3']))   #给每个df单独加上一个hierarchical index
df = pd.concat(dfs)
print(df.ix[3:6])       #继续切片,切3-6行
data_f4 = pd.DataFrame({'Salary':[6000,5000,7000,9000,4000]},index=['Beijing','Chendu','Dalian','Shenzhen','Nanning']) #创建一个index相似,columns完全不同的
n_df = pd.concat([df,data_f4],axis = 1) #因为index相似要插入只能是对列的拼接,所以axis=1 ,0行1列
print(n_df.stack())  #回归成Series形式,
#合并还可以用append
print(data_f1.append(data_f2))     #列和行有一项一样,就在另一项上面扩展
print(data_f1.append(data_f4))     #如果都不一样,则取交集,没有数据的地方填充NaN
#dataframe和Series合并
s = pd.Series([2,3],index=['Beijing','Chendu'],name='newcolunms')    #创建个Serise合并的试试
s_d = pd.concat([data_f1,s],axis=1)                  #为毛要列合并？因为index类似,会根据Series的名称多生成一个column
print(s_d)
#用append则要改变下数据
s1 = pd.Series([4000,16000],index=['gdp','home_price'],name='Xian')
print(data_f1.append(s1))

Merge(还是合并)

data_f1 = pd.DataFrame({'home_price':[40000,50000,60000,20000,1],
                        'car_price':[80000,100000,120000,40000,20000],
                        'citis':['Guangzhou','Shenzhen','Beijing','Wuhan','Jingzhou']})
data_f2 = pd.DataFrame({'salary':[6000,8000,9000,12000],'citis':['Nanchang','Wuhan','Shenzhen','Beijing']})
print(pd.merge(data_f1,data_f2,on='citis'))    #根据cities合并两个dataframe,不过是取交集,就是两个citis数组的交集
print(pd.merge(data_f1,data_f2,on="citis",how= 'outer'))  #根据cities合并两个dataframe，取并集,缺失的数据用NaN填充

Join(依然是合并)

data_f1 = pd.DataFrame({'home_price':[40000,50000,60000,20000,1],
                        'car_price':[80000,100000,120000,40000,20000],
                        },index = ['Guangzhou','Shenzhen','Beijing','Wuhan','Jingzhou'])
data_f2 = pd.DataFrame({'salary':[6000,8000,9000,12000]},index = ['Nanchang','Wuhan','Shenzhen','Beijing'])
print(data_f1.join(data_f2))   #join和merge类似,不过用data_f2join到data_f1,他的独特城市,比如Nanchang就不会带进去
print(data_f2.join(data_f1))   #这两个得到的完全不同的数据,就是添加的dataframe里面的index并不会带进去,只会进行匹配填充
print(data_f1.join(data_f2, how='outer')) #这样就会取到并集了,同时,column也是有顺序的,比如data_f1.join(data_f2),salary就会在home_price和car_price的后面
#用merge也可以实现类似的功能
print(pd.merge(data_f2,data_f1,left_index=True,right_index=True, how='outer'))  #想让哪个在左,就把谁放左边就行了

Group by(合并好了该分了)

salary_table = pd.DataFrame({'employee':['dabai','dabai','dabai','xiaobai','xiaobai','xiaobai','yokan','yokan'],
                             'year':['2016','2017','2018','2016','2017','2018','2017','2018'],
                             'salary':[50000,60000,70000,60000,70000,80000,150000,250000]
                             })
st_groupby = salary_table.groupby('employee') #进行分组,但直接分没什么实际意义,聚合就是为了统计
print(st_groupby.aggregate(sum))  #聚合函数和groupby会更配,不管是在什么语言里面,包括mysql,这个语句就是根据名称统计他这几年的总收入
print(st_groupby.sum())           #效果和aggregate(sum)是一样的
st_groupby_ny = salary_table.groupby(['employee','year'])  #用两个字段进行分组
print((st_groupby_ny.aggregate(sum)))     #会返回每个人具体一年的收入
print((st_groupby_ny.size()))   #具体的元素,不过我没有其它的未划分字段,所以都是1
print(st_groupby_ny.size().describe())#元素的统计值描述

CSV和pandas的交互

#首先必须要有csv文件,刚好我有七月的csv
bike_rec = pd.read_csv('bikes.csv',encoding='latin1') #读取一个csv文件,encoding为csv的常用coding latin1
# print(bike_rec)  #先看看都有啥玩意儿
bike_rec1 = pd.read_csv('bikes.csv',encoding='latin1',sep=';',parse_dates=['Date'],dayfirst=True,index_col='Date')
# print(bike_rec1)   #高级点的读取方式,sep是分隔符,这个csv读出来就会发现是被;分割的,
# print(bike_rec1.dropna(how='all').head())  #删掉所有的NaN项,结果就删完了,哈哈没那么十全十美的数据
print(bike_rec1.dropna(how='all',axis=1).head())
#就先总结到这吧,要吐了

1.读取csv

# print(pd.read_csv('./data/data4.csv'))  #先查看原始数据,否则怎么知道是否跳过了某些字段
data = pd.read_csv('./data/data4.csv',skiprows=[0,2,3])   #之前的读取文档可以看出第1行和第3,4行是注释,没意义,直接去掉
data1 = pd.read_csv('./data/data6.csv',nrows=5)    #数据比较大的时候可以分段读取
# print(data1)
chunk = pd.read_csv('./data/data6.csv',chunksize=50)    #定义读取块,有点类似python原生的迭代器,chunksize自定义一次的行数
#先统计下关键字的个数吧
s = pd.Series({})
for item in chunk:              #遍历chunk可以把数据全部读出来
    s = s.add(item['key'].value_counts(),fill_value = 0)    #把每个出现过的关键字数目循环加起来,这样会得到各个关键字的数目
print(s)

2.写入csv

#读粗来了就要修改,修改就用pandas,然后就该写回去了
data = pd.read_csv("./data/data5.csv")   #直接读
# data.to_csv('new.csv')    #直接取就会发现na已经变成了空白字段
data.to_csv('new.csv',sep='-') #想用啥分隔就打什么标点符号,貌似写两次是覆盖
data.to_csv(sys.stdout,na_rep='NULL')  #sys.stdout就是并不生成文件,而是在debug栏把文本显示出来,na_rep就是代替NA的字符,必须导入sys才能用sys.stdout
data.to_csv(sys.stdout,index=False,header=False) #index = False 就是不写入index值,header就是不写入columns,详见pandas的DataFrame
data.to_csv(sys.stdout,index=False,columns = ['a','b','c'])  #emmm取消掉原来的columns新赋值一个columns
date_m = pd.date_range('2018/05/20',periods=20)    #可以传入开始和截止时间,默认第一个是起始时间,period表示周期,取7就是7天，它将得到一个count为7的时间数组
s = pd.Series(np.arange(20),index=date_m)   #然后用时间数组当index创建一个Series
s.to_csv('date.csv')    #写入csv
s = pd.Series.from_csv('date.csv',parse_dates  = True)   #然后根据时间读出来
print(s)

3.更多读写相关

f = open('./data/data7.csv')   #用python原生的方式读取数据
data = csv.reader(f)    #得到的是多个csv对象
for item in data:       #遍历这些csv并输出里面的内容
    print(item)

c_list = list(csv.reader(open('./data/data7.csv')))   #将上面三四个步骤打包起来就是这段语句了
columns , values = c_list[0],c_list[1:]
n_dic = {k : v for k,v in zip(columns,values)} #这是字典生成式,zip出来的是一个组合数组,因为循环一次columns需要循环多次values,就会行为columns为key,values对应位置组成数组成为值
print(n_dic)

4.JSON,目前的程序员见到最多的数据格式怕就是JSON了

j_str = """{"name":"yokan","age":21,"adr":["china","日本","america"],"fav":["coding","game"]}""" #注意json串区分单引号和双引号
json_obj = json.loads(j_str)                    #得到一个json元素,这是一个字典类型
print(json_obj)                                 #打印出来
j_dp = json.dumps(json_obj,ensure_ascii=False)  #这句话的意思是把json元素转成一个json字符串,或者说把一个字典转成字符串,一般用来做协议传输
print(j_dp)
print(json_obj['adr'][1])   #既然是字典肯定也能这样取值了