pandas用法和笔记

import pandas as pd
import numpy as np

 

目录

Series简单了解

1.下标索引

2.布尔型索引

3.按条件筛选

4.判断有么有空值

5.标签自动对其运算

6.删除

7.添加

8.修改

DataFrame了解一下

一个表格类型的数据格式支持多种数据类型，但是数据类型要保持一致，#index是表格的列索引，columns是表格的行索引

---

Series简单了解

1.下标索引

series能为数据自定义标签，如果没有设置，默认下标从0开始自增
print('默认下标从0开始自增',np.random.randn(5))
print('直接给下标索引',pd.Series(np.random.randn(5),index=['a','b','c','d','e']))
print('直接给下标索引',pd.Series(np.random.randn(5),index=['a','b','c','d','e']))

2.布尔型索引

s1=pd.Series(np.random.randn(3)*100)
print('布尔型索引',s1>10)

3.按条件筛选

print('按条件筛选',s1[s1>10])

4.判断有么有空值

print('判断有么有空值',s1.isnull())

5.标签自动对其运算

s1=pd.Series(np.random.randn(3)*100,index=['a','b','c'])
s2=pd.Series(np.random.randn(3)*100,index=['a','d','e'])
print('标签自动对其运算',s1+s2)

6.删除

s2.drop('e')

7.添加

s2['瓜皮']=22

8.修改

s2['瓜皮']=18

DataFrame了解一下

一个表格类型的数据格式支持多种数据类型，但是数据类型要保持一致，#index是表格的列索引，columns是表格的行索引

1.使用二维数组进行创建

df1=pd.DataFrame(np.random.randint(0,20,(4,5)),index=[1,2,3,4],columns=['a','b','c','d','e'])
print(df1)

2.使用字典创建

dict1={ 'a':[1,2,3],
        'b':[1,2,3],
        'c':[1,2,3],
       }
df2=pd.DataFrame(dict1,index=[1,2,3])

3.由字典生成的字典创建'

dict2={'jack':{'math':90,'english':89,'art':78},
        'marry':{'math':90,'english':89,'art':78},
        'tom':{'math':90,'english':89,'art':78},
       }
df3=pd.DataFrame(dict2)
print('index修改行索引',df3.rename(index={'art':'ch'},columns={'tom':'sb'}))

基本属性

dict1={ 'a':[1,2,3],
        'b':[1,2,3],
        'c':[1,2,3],
       }
df2=pd.DataFrame(dict1,index=[1,2,3])
print('获取索引的行列数',df2.shape)
print('获取列索引内容',df2.columns.tolist())
print('获取行索引内容',df2.index.tolist())
print('查看是几维的数据',df2.ndim)
print('查看数据类型',type(df2))
print('查看元素的数据类型',df2.dtypes)
print('查看元素',df2.values)
print('查看前两行元素',df2.head(2))
print('查看后两行元素',df2.tail(2))
print('取一列',df2['a'])
print('取两列',df2[['a','b']])
print('取一行',df2[0:1])
print('取两行',df2[0:2])
print('取两行中的莫一列',df2[0:2]['a'])

通过标签索引取值  loc
通过位置索引取值  iloc

print(df2.loc[:,['a','b']])
print(df2.iloc[:,[0,1]])
#直接取单个值
print(df2.loc[1,'a'])
print(df2.iloc[0,0])

索引排序

df1=pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                 index=[1,5,7,4],
                 columns=['a','b','c','d']
                 )
print(df1)
print('按行的索引进行排序',df1.sort_index())
print('按值进行排序',df1.sort_values(by='b',))

排名（出现了相同数值的排序方式）

s2=pd.Series([1,3,321,3,41,31,22,2])
print(s2.rank(method='min'))

设置一列的index

df1=pd.DataFrame(np.arange(9).reshape(3,3),index=['a1','a2','a3'],columns=['a','b','c'])
df1.index=['b1','b2','b3']
函数改全部名字
def test1(x):
    '''
    函数改名字
    :param x:
    :return:
    '''
    return x+'_111'
df1.rename(index=test1,columns=test1,inplace=True)
直接改一个
df1.rename({'b3_111':'b2_333'})


df3=pd.DataFrame({'A':range(4),'B':[2,3,4,5],'C':list('abcd'),'D':[3,4,10,5]})
把那一列设置为索引列设置之后那一列会消失 drop保留原数据
df3.set_index('D',drop=False)
将行转换为列索引将（第一行转换为列索引）
df3.set_axis(df3.iloc[0],axis=1,inplace=True)

DataFrame常见操作

1.添加数据

df=pd.DataFrame(np.random.rand(16).reshape(4,4)*100,columns=['a','b','c','d'])
新增一列
df['e']=88
print('#新增一列',df)
df[['f','g']]=99
print('#新增加2列',df)

2.增加数据列

df1=pd.DataFrame([['a1','f',20],['a1','f',20],['a1','f',20]],columns=['w','e','r'])
df1['t']=[22,33,444]
print('增加数据列',df1)
在那个位置增加一列（下标，新曾列名，数据）
df1.insert(3,'married',[1,2,3])
不能增加一列只能覆盖掉
df1.iloc[2]=[1,2,3,4,5]
多了的下标位置就增加
df1.loc[2]=[10,2,3,4,5]

3.数据合并

df1=pd.DataFrame(np.arange(6).reshape(3,2),columns=['a','b'])
df2=pd.DataFrame(np.arange(6).reshape(2,3),columns=['c','d','e'])
在1轴上堆上数据，列会多，行数不怎么变
res=pd.concat([df1,df2],axis=1)
在0轴上补全数据行数和列数都会增加,keys是个前面加上个表头
res1=pd.concat([df1,df2],axis=0,keys=['1月','2月'])

df1=pd.DataFrame({'kes':['k1','k2','k3','k4'],
'a':['a1','a2','a3','a4'],
'b':['b1','b2','b3','b4']}
                 )

df2=pd.DataFrame({'kes':['k1','k2','k6','k4'],
'a':['a1','a2','a3','a4'],
'b':['b1','b2','b3','b4']}
                 )
关注列的合并，（比如按kes去合并）
print(pd.merge(df1,df2,on='kes'))

df3=pd.DataFrame({'kes':['k0','k0','k1','k2'],
'kes1':['k0','k1','k0','k1'],
'a':['a1','a2','a3','a4'],
'b':['b1','b2','b3','b4']})
df4=pd.DataFrame({'kes':['k0','k1','k1','k2'],
'kes1':['k0','k0','k0','k0'],
'c':['c1','c2','c3','c4'],
'd':['d1','d2','d3','d4']})

合并后默认是交集kes和kes1两个为参考
print(pd.merge(df3, df4, on=['kes', 'kes1']))
合并后是并集kes和kes1两个为参考 how='outer'
print(pd.merge(df3, df4, on=['kes', 'kes1'],how='outer'))
合并后是kes和kes1两个为参考 how='left'，以左表去匹配，没有就为空
print(pd.merge(df3, df4, on=['kes', 'kes1'],how='left'))

4.join 基于index行索引去合并

de1=pd.DataFrame({'a':['a0','a1','a2'],
                  'b':['b0','b1','b2']},
                 index=['k0','k1','k2']
                 )
de2=pd.DataFrame({'c':['c0','c1','c2'],
                  'd':['db0','db1','db2']},
                 index=['k0','k2','k3']
                 )
print(de1.join(de2, how='left'))

5.删除

df=pd.DataFrame(np.random.rand(16).reshape(4,4)*100,columns=['a','b','c','d'])
del df['b']
默认按照0轴方向删除，要删除列就是声明了
df.drop(1)
df.drop('a',axis=1)

6.创建多级索引

df1=pd.DataFrame(np.random.randint(70,100,size=(2,4)),index=['a','b'],
                 columns=[['q','q','e','e'],['1','2','3','4']])
隐式索引
df2=pd.DataFrame(np.random.randint(70,100,size=(4,2)),
                  columns=['a','b'],
                 index=pd.MultiIndex.from_product([['q','e'],['1','2']]))

7.检索多层索引

s=pd.Series(np.random.randint(0,100,size=6),index=[['a','a','b','b','c','c'],['1','2','3','4','5','6']])
print(s)
print('取外层索引的值',s['a'])
print('取里层索引的值',s['a','1'])
print('取里层索引的值',s.iloc[0])
print('取里层索引的值',s.loc[:,'1'])
s=s.reset_index()  #重置索引的值

8.更改索引的层集

df=pd.DataFrame(np.random.randint(70,100,size=(6,4)),
                index=pd.MultiIndex.from_product([[1,2,3],['a','b']]),
                columns=pd.MultiIndex.from_product([['sb','sc'],['y','n']])
                )

给索引起名儿
df.columns.names=['ming','zhi']
df.index.names=['s1','s2']
print(df)
默认行索引交换列索引就要指定axis=1
df.swaplevel('s2','s1')
df.swaplevel(0,1,axis=1)
print(df)

9.算术运算和数据对其和值的填充

df1+df2 会自己对其索引项做运算要行索引和列索引都一样才行
df1.add(df2,fill_value=0)   add是加法  把空值填充为0，如果两个都是空就无效了

10.函数的应用和映射

df= pd.DataFrame(np.random.randn(4,3),columns=list('qwe'),
                 index=['a1','a2','a3','a4'])
print(df)
函数制定规则求最小值，默认是0轴方向的
f=lambda x:x.min()
print(df.apply(f))
print(df.apply(f,axis=1))
可以做运算的
d=lambda x:x.max()-x.min()
print(df.apply(d))
也可以直接写函数
def func(x):
    return pd.Series([x.min(),x.max()],index=['min','max'])
print(df.apply(func))

给数据调整名字比如保留2位小数，还带%号
f2=lambda x:'{:.2%}'.format(x)
print(df.applymap(f2))

11.带有重复标签的轴索引

df=pd.Series(range(5),index=['a','b','a','d','e'])
print('查看相同索引的值',df['a'])
print('查看轴的索引名称',df.index.unique())

12.汇总和计算描述统计

df=pd.DataFrame({'k1':[1,2,3,4,np.nan],
                'k2':[2,3,np.nan,5,9],
                'k3':[2,3,4,'s','t']},
                index=['a','b','c','d','e'])
print(df['k1'].dtype)
mean()平均数  median() #中位数  descirbe() #给出此对象的基本统计项目
print(df['k1'].mean())

13.常用的统计方法

df.sum()  #默认0轴方向上求和
df.sum(axis=1)  #1轴方向上求和
df.argmax()  #返回位置索引
df.idxmax()  #最大值对应的标签索引
df.descirbe()  #给出此对象的基本统计项目
df.mean()      #平均数
df.median()      #中位数
df.std()      #标准差  与均值的偏离程度

14.累计函数

df['k1'].cumsum()   #累计求和
df['k1'].cumprod()   #累计求积

15.数据处理（处理空值）

from numpy import nan as NaN

(1)DataFrame处理空值

df=pd.DataFrame([[1,2,3],[NaN,3,NaN],[NaN,4,5],[NaN,NaN,NaN]])
删除空值所有都删
print(df.dropna())
删除全是空值的行
print(df.dropna(how='all'))
删除全是空值的列
print(df.dropna(axis=1,how='all'))
print(df.dropna(thresh=1))

(2)填空空值

填入平均数
print(df.fillna(df.mean()))
指定行进行填充指定值
print(df.iloc[:,0].fillna(100,inplace=False))
插值填充
print(df.fillna(method='ffill'))  #填自己的上个数据
print(df.fillna(method='bfill'))   #填自己的下个数据

(3)判断是不是重复

df1=pd.DataFrame({"a":[1,2,1,2,5,1],'b':list('aaabbe')})
print(df1)
对整行进行去重
print(df1.drop_duplicates())
对那一列进行去重 keep='last'保留重复数的最后一个
print(df1.drop_duplicates(['a'],keep='last'))
替换把b这一列的a全部替换成什么玩意
print(df1['b'].replace({'a':'hello'}))

16.atr属性

str访问，而且自动排除丢失/nan值 upper(),lower(),len(),split(),replace()
把k1这一列全部变成大写
print(df['k1'].str.upper())

17.分组聚合

对name这一列进行求和,会把这一列的所有相同的name对应的数据求和
print(df.groipby('name').sum())
对name这一列和 年份 一起进行求和,会把这一列的所有相同的name对应的数据求和（结果是多重索引）
print(df.groipby(['name','年份']).sum())
对k1这一列进行求和求标准差和很多,会把这一列的所有相同的k1对应的数据求和
print(df.groipby('k1').agg(['sum','std','mean']))

18.透视表

生成一个透视表 对df1 里的a列 和b列 进行求和
print(pd.pivot_table(df1,values=['a','b'],aggfunc='sum'))
生成一个透视表 对df1 里的a列 和b列 进行求和和求标准差和很多
print(pd.pivot_table(df1,values=['a','b'],aggfunc=['sum','std','mean']))

数据的加载

#检查pandas的版本号
print(pd.__version__)

1.read_csv函数用法文件，文件对象

data2=pd.read_csv(r'路径地址',
            encoding='ANSI,utf-8,gbk',
            sep='\t,"空格逗号什么的"',
            header='0索引的行为表头或者是不设置表头 None',
            index_col='设置索引列False或者 0 列 或者["a1","a2"]',
            usecols='当数据量比较大的时候筛选几列出来分析[0,2,3]',
            na_values='把那个值填充为NaN主要处理异常数据 0.5 也可以用字典{"列名1":0.8}',
            dtype='{"列名1":np.float64} 直接设置的数据类型',
            chunksize='数据量大的时候使用 假如设置为 1000 就会把这个变成迭代器 用for循环去取',
            )

大文件读取成块后去拼接回来

list1=[]
for i in data2:
    print(i)
    list1.append(i)
pd.concat(list1,ignore_index=True)

2.read_table函数用法 文件，文件对象

data=pd.read_table(r'路径地址.txt',
              sep='\t,"空格逗号什么的",也可以用正则表达式的方法 \s+ 至少有一个空格',
              )

3.read_excel函数用法 excel xls xlsx

pd.read_excel(r'路径地址',)

4.数据的存储(追加模式自己写)

data.to_csv('./text.csv')
data.to_excel('./text1.xlsx')

判断是不是空值/查看数据类型

data.isnull()
data.info()

5.离散化给数据分开

data.isnull.sum()  #查看空值的个数
ages=[20,21,23,25,28,30,37,62,69,55,35,45]
bins=[18,25,35,60,100]
labels=['少年','青年','中年','老年']
s10=pd.cut(ages,bins=bins,labels=labels)
print(s10)
print(s10.value_counts()) #获得数据的个数，在排序
print(pd.cut(ages, 5))    #等频切片不看个数


data1=np.random.randn(1000)
print(pd.qcut(data1,4))        #等频切片不看个数
print(pd.value_counts(data1))  #数量的计算结果

6.多表合并

import os
df_list=[]
path1='c:/aa'  #路径
list212=os.listdir('获取文件夹的所有文件信息进行拼接，，，写路径')
for i in list212:
    #拼接路径
    file_path=os.path.join(path1,i)
    #判读是不是文件
    if os.path.isfile(file_path):
        #循环读取
        df=pd.read_excel(file_path)
        #添加成集合
        df_list.append(df)
#合并到一起
data=pd.concat(df_list)
#提取月份
data['月份']=pd.to_datetime(data['时间']).dt.month
data['季度']=pd.to_datetime(data['时间']).dt.quarter