Pandas

1、基本介绍

pandas类似于python的字典，一般和numpy搭配着使用。

1. 创建DataFrame，指定行和列的名称
2. 默认名称就是索引号
3. 传入字典构造DataFrame
4. 查看数据类型
5. 查看行和列的名称
6. 转置
7. 排序，按照索引名称排序。按照值排序

import pandas as pd
import numpy as np
# pd类似于字典
# 一般为pd和np搭配着使用
s = pd.Series([1,3,6,np.nan,44,1])
# 都是带索引的
print(s)

# 创建一个大的矩阵，在pd中叫DataFrame
# 这里创建一个DataFrame，行的索引为dates，列的索引为abcd，这样，每个数据都有一个名字
dates = pd.date_range('20220101',periods=6)
print(dates)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])
print(df)

# 默认名称就是对应的索引0,1,2等
df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
print(df1)

# 传入字典构造DataFrame
# A对应的只有一条数据，但是为了对齐，补成了4个
# 若都是四条数据（比如BCD），可以允许存在一条的数据（比如A），但不允许存在3条等其他数据
df2 = pd.DataFrame({
    'A':1.,
    'B':pd.Series(1,index=list(range(4)),dtype='float32'),
    'C':np.array([2,3,4,5]),
    'D':np.array(['test','train','test','train']),
    'E':pd.Timestamp('20210101')
})
print(df2)
print("*****************")
# 查看数据类型
print(df2.dtypes)
# 打印行索引和列索引，index和columns都是属性
print(df2.index)
print(df.columns)
print(df2.values)

print("\n********1**********")
# describe方法，计算数字型数据的一些属性比如方差平均值等
print(df2.describe())

# 转置
print(df2.T)

print("\n**********2*********")
# 排序
# 1.按照索引名称排序，指定排序的维度和方式
# 这里指定列排序，倒序
print(df2.sort_index(axis=1,ascending=False))
# 这里按照行
print(df2.sort_index(axis=0,ascending=False))

# 2.按照值排序
print(df2.sort_values(by='D'))

2、选择数据

1. 选择列，两种选择方式，[label] 和 .label
2. loc，通过标签选择
3. iloc，通过位置选择
4. Boolean indexing

import pandas as pd
import numpy as np

dates = pd.date_range('20220101',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates,columns = ['A','B','C','D'])
print(df)

# 选择一列，两种选择方式，[label] 和 .label
print(df['A'])
print(df.A)
print("\n********--1--*********")
# 切片选择行,只能选择行，不可加个逗号选择列
print(df[0:3])
# 注意，这种选择方式可以包括区间右端的值
print(df['20220101':'20220104'])

# -----几种选的方式--------
print("\n********--2--*********")
# 通过标签选择 loc
print(df.loc['20220101'])
# 选定指定行和列,值的切片包括右侧区间值
print(df.loc['20220102':'20220105',['A','B']])

# 通过位置选择 iloc ，就是和numpy类似了，可以切片
print("\n********--3--*********")

print(df.iloc[3])#选择第三行
print(df.iloc[3:5,1:3])#切片选择
print(df.iloc[[1,3,5],1:3])#选择指定行，切片选择列

# 混合筛选 mixed selection ix，在pandas0.20.0及其以后版本中，ix已经不被推荐使用
# 'DataFrame' object has no attribute 'ix' 
# print(df.ix[:3,['A','C']])

# Boolean indexing
print("\n********--4--*********")
print(df)
# df.A<8等价于df['A']<8
print(df[df.A<8]) 

3、设置值

1. iloc通过位置设置值
2. loc通过标签设置值
3. 更改符合条件的值
4. 添加一列

import pandas as pd
import numpy as np

dates = pd.date_range('20220101',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates,columns = ['A','B','C','D'])
print(df)
# 1.iloc设置值，通过位置
df.iloc[1,1]=111
# 2.loc设置值，通过标签
df.loc['20220101','C']=222
print(df)
print("\n********--1--*********")
# 3.更改符合条件的值
# 更改A列中大于4的值为0
df.A[df.A>4]=0
# 等价于df.iloc[:,0][df.iloc[:,0]>4]=0
print(df)
print("\n********--2--*********")
# 1.添加一列
df['F']=np.nan
# 2.添加一个有具体值的一列，这里添加pd的一个序列，并且索引值名称要相对应
df['E']=pd.Series([1,2,3,4,5,6],index=pd.date_range('20220101',periods=6))
print(df)

4、处理丢失数据

1. dropna
2. fillna
3. isnull

import pandas as pd
import numpy as np

dates = pd.date_range('20220101',periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates,columns = ['A','B','C','D'])
df.iloc[0,1]=np.nan
df.iloc[1,2]=np.nan
print(df)
# 1.使用dropna axis选择除去的维度，how any表示只要这一行有nan我就把这一行丢掉，
# all表示只有这一行都是nan才把这一行丢掉，默认为how=any
# 这里axis=0表示丢掉行
print(df.dropna(axis=0,how='any'))

# 2.fillna是把nan值填充为指定值
print(df.fillna(value=0))

# 3.isnull判断数据是否为nan，返回一个矩阵，对应的元素为nan时该位置的值为True否则为False
print(df.isnull())

# 4.查看是否包含指定值，这里查看是否包含True
print(np.any(df.isnull()==True))

5、导入和导出

1. 使用read_文件类型 读入文件
2. 使用to_文件类型 导出文件
3. 具体的参数使用可以查阅官方api

import pandas as pd

# 如果是vscode编译器，注意终端打开的是终端工作目录的文件夹，直接使用相对路径可能会出错
# 所以使用终端工作路径下的相对路径

# 读取csv文件，默认sep=','，这里csv使用excel工具生成的，间隔为\t,所以使用sep='\t'去掉
data = pd.read_csv('./3-pandas/student.csv',sep='\t')
print(data)

# 导出文件
data.to_pickle('./3-pandas/student.pickle')

6、合并concat

1. 使用concat合并
2. axis指定合并的维度
3. join指定合并的方式
4. append在末尾增加新行

import pandas as pd
import numpy as np

# concatenating
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2,columns=['a','b','c','d'])
print(df1)
print(df2)
print(df3)
print("*********--1--***********")
# 竖向合并，合并为多行
# axis指定合并的维度，ignore_index是忽略掉原有的索引，将索引合并
res = pd.concat([df1,df2,df3],axis=0,ignore_index=True)
print(res)

print("*********--2--***********")
# 使用join功能
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['a','b','c','d'],index=[1,2,3])
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['b','c','d','e'],index=[2,3,4])
# print(df1)
# print(df2)
# 如果直接合并，那么二者不同的部分就会自动填充为nan，等价于join默认为outer
res = pd.concat([df1,df2],join='outer')
print(res)
# 将join设置为inner，就会把不同的部分裁减掉，保留相同部分
res = pd.concat([df1,df2],join='inner',ignore_index=True)
print(res)

print("*********--3--***********")
# 左右合并，这里join_axes是按照df1的索引进行合并，df2没有得部分用nan代替
# 但是从 pandas=1.0.0 开始，就不支持 join_axes  参数了，所以这里不再演示，会在merge中学习
# res = pd.concat([df1,df2],axis=1,join_axes=[df1.index])
# print(res)

# append，在行的末尾加上新行
df1 = pd.DataFrame(np.ones((3,4))*0,columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2,columns=['a','b','c','d'])
res =  df1.append([df2,df3],ignore_index=True)
print(res)
# 添加一行，series
s1 = pd.Series([1,2,3,4],index=['a','b','c','d'])
res = df1.append(s1,ignore_index=True)
print(res)

7、合并merge

1. on指定依据哪一列进行合并
2. how指定合并的方式，left，right，outer，inner
3. indicator显示数据时如何合并的
4. 根据index合并
5. suffixes合并

from turtle import right
import pandas as pd
import numpy as np

left = pd.DataFrame({
    'key':['K0','K1','K2','K3'],
    'A':['A0','A1','A2','A3'],
    'B':['B0','B1','B2','B3']
})
right = pd.DataFrame({
    'key':['K0','K1','K2','K3'],
    'C':['C0','C1','C2','C3'],
    'D':['D0','D1','D2','C3']
})
print(left)
print(right)
# 使用merge进行合并，on指定合并依据哪一列
res = pd.merge(left,right,on = 'key')
print(res)

print("************--1--***************")
left = pd.DataFrame({
    'key1':['K0','K0','K1','K2'],
    'key2':['K0','K1','K0','K1'],
    'A':['A0','A1','A2','A3'],
    'B':['B0','B1','B2','B3']
})
right = pd.DataFrame({
    'key1':['K0','K1','K1','K2'],
    'key2':['K0','K0','K0','K0'],
    'C':['C0','C1','C2','C3'],
    'D':['D0','D1','D2','C3']
})
# print(left)
# print(right)
# 默认的合并方法，是inner.即只考虑相同的key，基于相同的key合并
res = pd.merge(left,right,on=['key1','key2'],how='inner')
print(res)
# outer,对于不同的key，进行填充
res = pd.merge(left,right,on=['key1','key2'],how='outer')
print("**********--outer--**********")
print(res)
# how = ['left','right','outer','inner']
# left,right就是数据库的左外连接和右外连接，即基于左侧的key合并还是基于右侧的key合并
res = pd.merge(left,right,on=['key1','key2'],how='left')
print("*********--left--**********")
print(res)

# indicator,显示数据是如何合并的
df1 = pd.DataFrame({
    'col1':[0,1],
    'col_left':['a','b']
})
df2 = pd.DataFrame({
    'col1':[1,2,2],
    'col_right':[2,2,2]
})
# 这里默认显示如何合并的列名为 _merge，用户可以自定义列名：indicator='name'即可
res = pd.merge(df1,df2,on='col1',how='outer',indicator=True)
print(res)

# 通过index合并，需要使left_index和right_left都为真即可根据index合并
left = pd.DataFrame({
    'A':['A0','A1','A2'],
    'B':['B0','B1','B2']
},index = ['K0','K1','K2'])
right = pd.DataFrame({
    'C':['C0','C1','C2'],
    'D':['D0','D1','D2']
},index = ['K0','K2','K3'])
res = pd.merge(left,right,left_index=True,right_index=True,how='outer')
print("*********--index--**********")
print(res)

# suffixes对原列相同，但是表示的意义不同的列，进行重命名
# 比如这个，都是年龄，但是分为男孩年龄和女孩年龄，
# 如果直接根据关键字合并，那么只剩下age这一列，无法区分性别，所以使用suffixes
boys = pd.DataFrame({
    'k':['K0','K1','K2'],
    'age':[1,2,3]
})
girls = pd.DataFrame({
    'k':['K0','K0','K3'],
    'age':[4,5,6]
})
print(boys)
print(girls)
# 这里对于K0，男孩年龄将会用age_boy表示，女孩年龄会用age_girl表示
res = pd.merge(boys,girls,on = 'k',how = 'outer',suffixes=['_boy','_girl'])
print(res)

8、plot画图

主要是用到matplotlib模块，这里不再详细介绍

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# plot data

# Series
data = pd.Series(np.random.randn(1000),index=np.arange(1000))
# 累加
data = data.cumsum()
# 在pandas中直接将数据plot就可
data.plot()
plt.show()

# DataFrame
data = pd.DataFrame(np.random.randn(1000,4),#生成一千组数据，一组四个数据
                    index = np.arange(1000),
                    columns=list('ABCD'))
data = data.cumsum()
# 先查看一下前5个数据，默认为5，可以在括号中传入参数改变数据
print(data.head())
data.plot()
plt.show()