Pandas常用方法一

文章目录

1、Series 有序(index)序列
- 1）创建Series
- 2）序列索引查找
2、Dataframe
- 1）创建dataftame （ndarray、dict、series）
- 2）创建符合索引的dataframe
- 3）数据信息概览
3、数据的读取与保存
- 1）读写excel文件
- 2）读写csv文件
- 3）读写HDF5文件
- 4）读写SQL文件
4、DataFrame的部分数据获取
- a）按顺序匹配df.iloc[row_index, col_index]
- 2）按名字索引匹配 df.loc[row_index, col_index]
- 3）按布尔值匹配df[condition]
5、数据集成之concat、merge、insert
- 1）给dataframe增加一行
- 2）merge
6、数据清洗
- 1）处理重复值
- 2）处理缺失值
- 3）filter过滤筛选某个列变量
- 4）根据某种条件过滤数据
7、数据转换
- 1）map的用法
- 2）apply的用法
- 3 transform
- 4）applymap针对每一个元素进行映射
- 4）打乱数据 np.random.permutation(length)，也可以用random.shuffle()
8、数据形状转变

1、Series 有序(index)序列

pandas库的很多功能或者方法是根据numpy来实现的，所以他们之间是由共通之处的，比如运算规则、数据结构。
pandas使用最多的两的数据类型：

Series 序列，包含索引（index）和数据值（values）
DataFrame，数据框，结构类似于excel的表格，有列名（变量名），有索引index

import numpy as np
import pandas as pd

1）创建Series

s = pd.Series(data=np.arange(5),    # 序列值index=list('abcde'),  # 序列索引dtype=np.int16,       # 元素类型name='序列名字',       # 序列名字copy=False,fastpath=False )
s

2）序列索引查找

根据默认索引查找，默认的索引值是从0下标开始，length-1为结尾下标，查找规则和列表（list）切片一样，查找范围左闭右开

print(s[:2])
print(s[0])

根据指定索引查找，例如案例的索引是abcde，能理解吧，都告诉电脑了我要找确切的a索引所指向的值，所以查找区间是全闭合。

print(s['a':'b'])
print(s['c'])

2、Dataframe

俗称数据框，简写为df，和excel的格式类似，由于方法众多，且底层框架数据结构（类numpy，措辞不精准），所以处理数据方便且高效。

1）创建dataftame （ndarray、dict、series）

创建dataftame有多种方式，本文只列举常用的几种，如通过ndarray，字典和Series创建df。

通过ndarray创建数据框

metaData = np.random.randint(0,20,size = (4,3))
df1 = pd.DataFrame(data=metaData,index=list('ABCD'), # indexcolumns=['Python','Math','Eng'], # column_namedtype=np.float16  ) # 数据类型
df1

字典，每一个key是一个变量，它的value就是该列所有的值。

df2 = pd.DataFrame(data = {'Python':[66,99,128],'Math':[88,65,137],'Eng':[100,121,45]})
df2

series创建，一个series就是一条数据，也就是一行，series的name是它的所有

df3 = pd.DataFrame([pd.Series([1,2,3], name='pe'),pd.Series([11,12,13], name='math')])
df3

2）创建符合索引的dataframe

有时候我们需要复合索引，俗称多层或多级索引，例如，18年为一级索引，一、二、三月为二级索引，对应的水果销量，这里需要用到pd.MultiIndex.from_product([一级，二级])函数，详情看案例代码

data = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9],[11, 12, 13],[14, 15, 16],[17, 18, 19]])
df4 = pd.DataFrame(data=data,columns=['apple', 'banana', 'orange'],index = pd.MultiIndex.from_product([[ '18年', '19年' ],[ '一月','二月', '三月' ]]))
df4

3）数据信息概览

通常拿到一份数据，我们先会大致了解数据的一个基本情况，例如样本数量、维度、变量名、索引值、数据类型等，由于这些比较简单易于理解，这里不过多解释了。直接看代码和输出结果就行，你可以的。

df4.shape   # df的形状
df4.ndim    # 数据维度
df4.size    # 数据元素大小=shape的内积
df4.columns # 列索引
df4.values  # 值，返回的是NumPy数组
df4.dtypes  # 数据类型
display(df4.describe())  # 总体的统计summary()
df4.index   # 行索引
df4.info()  # 详细信息

3、数据的读取与保存

那么问题来了，前面介绍了它的基本属性，有了数据之后我们怎么把数据加载到python环境下，利用强大的库来做数据处理和数据分析呢？下面是pandas库花式加载各种类型文件，po码

1）读写excel文件

# 写
df2.to_excel('./df2.xls', encoding='utf-8')
# 读
pd.read_excel('./df2.xls')

2）读写csv文件

写入文件，pd.to_csv()函数

df2.to_csv('./df2.csv',sep=',',     # 分隔符index=False, # 不保存行索引header=True) # 把第一行当成变量名
print('保存成功')

读取文件，pd.read_csv()函数

df_csv = pd.read_csv('./df2.csv')
df_csv

一般情况，大多数是将文件保存为csv格式，一是读写速度快一些，而是csv格式更加稳定，至于为什么我也不懂。

3）读写HDF5文件

hdf5 内部可以保存多种类型数据，个人解读类似excel一样，表1，表2。比如深度学习中保存模型就是h5文件。
结构是group， dataset

df2.to_hdf('./df2.h5',key = 'score')
print('后h5文件保存成功！')pd.read_hdf('./df2.h5',key = 'score')

4）读写SQL文件

这里只简单展示如何连接sql文件，把sql文件转成dataframe在python中操作，处理数据

读取sql文件，利用pd.read_sql()函数，但是必须先连接上sql服务器

from sqlalchemy import create_engineengine = create_engine("mysql+pymysql://用户名:密码@localhost/数据库?charset=utf8",max_overflow=0,   # 超过连接池大小外最多创建的连接数pool_size=5,      # 连接池大小pool_timeout=30,  # 连接池中没有线程最多等待时间，否则报错pool_recycle=-1,  # 多久之后对连接池中的连接进行回收（重置）-1不回收
)
sql_query = 'select * from a limit 2'  # sql语句
res = pd.read_sql(sql_query, engine)
res

将文件写入sql数据库

df.to_sql('table_name', engine,if_exists='append',index=False,chunksize=1000)
print("数据写入成功!")

将DataFrame的数据储存到数据库表中，如果库里没有该表名，则会自动创建该表
if_exits：三个模式：fail，若表存在，则不输出；replace：若表存在，覆盖原来表里的数据；append：若表存在，将数据写到原表的后面。默认为fail
index：是否将df的index单独写到一列中
chunksize：设置一次入库的大小

4、DataFrame的部分数据获取

a）按顺序匹配df.iloc[row_index, col_index]

python中对于df的行和列，有默认行列索引，都从0开始，index=0，1，2…，取数的规则是根据索引index来取数

df2.iloc[1,2]
df2.iloc[:1, 2] # 类似切片，左闭右开
df[['Python', 'En']] # 选取多列

2）按名字索引匹配 df.loc[row_index, col_index]

df2.loc[1, 'python']
df2.loc[1:3, ['python', 'math']] # 按照索引匹配规则，全部匹配上，因为你告诉了它详细的地址

3）按布尔值匹配df[condition]

返回布尔值为True的该条数据

cond = df.Python > 80
# 将Python大于80分的成绩获取
df[cond]cond = df.mean(axis = 1) > 75
# 平均分大于75，优秀，筛选出来
df[cond]cond = (df.Python > 70) & (df.Math > 70)
df[cond]

5、数据集成之concat、merge、insert

准备数据：先创建了三位学生关于各科成绩的一个表格，如下图

d1 = pd.DataFrame(data = np.random.randint(0,20,3),columns=['Python'], index=['alex','jack','lisa'], dtype=np.float16)
d2 = pd.DataFrame(data = np.random.randint(0,20,3),columns=['Math'], index=['alex','jack','lisa'],dtype=np.float16)
d3 = pd.DataFrame(data = np.random.randint(0,20,3),columns=['En'], index=['alex','jack','lisa'],dtype=np.float16)d2

1）给dataframe增加一行

df.loc[row_index] = {key1:value1, key2:value2} 直接利用确切的行索引名字添加

d1.loc['ATM'] = {'Python':55}

pd.concat([df1, df2])，可以在垂直拼接（axis=0），也可以左右拼接（axis=1），通过axis的值来控制，还有更多参数，连接方式有全连接、内连接（和sql差不多）。

pd.concat([df1,df2],axis=0,join='outer',ignore_index: bool = False,keys=None,levels=None,names=None)pd.concat([d1,d2], axis=1) # 把同一个人的分数合并在一个表

df.insert(loc, column, value)

d1.insert(0, 'English', d3 )
# 就地修改的， 插入一列
d1

2）merge

由于和sql中的连接类似，各个参数的作用大家可以参考原函数或者官方文档，也可以百度，下面直接给案例吧（主要字码累了~）

df1 = pd.DataFrame(data = {'name':['softpo','Brandon','Ella','Daniel','张三'],'height':[175,180,169,177,168]}) # 身高df2 = pd.DataFrame(data = {'name':['softpo','Brandon','Ella','Daniel','李四'],'weight':[70,65,74,63,88]}) # 体重df3 = pd.DataFrame(data = {'名字':['softpo','Brandon','Ella','Daniel','张三'],'salary':np.random.randint(20,100,size = 5)}) # 薪水

内连接how=”inner“，只显示匹配成功的值
左合并，坐标所有数据保留，不对应位置，填充了空数据
外合并，所有数据保留，不对应位置，填充了空数据

pd.merge(df1,df2,how = 'inner')
# 根据共同name进行合并，两表合并，外键

pd.merge(df1,df2,how = 'left')

pd.merge(df1,df2,how = 'outer')

pd.merge(df1,df3, left_on='name',right_on='名字')  # 左右表完全显示

6、数据清洗

1）处理重复值

df = pd.DataFrame(data = {'color':['red','blue','red','green','green','blue',None,np.NaN,'green'],'price':[20,15,20,18,18,22,30,30,22]})# 重复数据删除
df.drop_duplicates() # 有返回值！非重复数据，索引7和索引6重复数据，None和NaN一回事

2）处理缺失值

df.isna() 判断是否缺失
df.drop() 控制参数删除一列数据或者一行数据
df.dropna() 默认一条数据只要出现缺失值，直接删除该条数据

# 删除指定的列
df.drop(labels='color',axis = 1)# 删除列，axis = 1
df.filter(items=['price'])
# 参数意思，保留数据price
df['size'] = 124
# 广播

3）filter过滤筛选某个列变量

df.filter(like = 'i')
# 模糊匹配，保留了带有i这个字母的索引df.filter(regex = 'e$')# 正则表达式，正则表达式，限制e必须在最后

4）根据某种条件过滤数据

如异常值过滤

a = np.random.randint(0, 1000,size = 20)# 异常值，大于800，小于 100算作异常，认为定义的。根据实际情况。
cond = (a <=800) & (a >=100)
a[cond]

7、数据转换

transform和apply都可以作用在整个df上，map只能作用在一列上，即map作用类Series。

df.rename() 更改数据索引或者数据列名
df.replace(old, new, inplace) 替换old数据值为new数据

df = pd.DataFrame(data = np.random.randint(0,10,size = (10,3)),columns=['Python','Tensorflow','Keras'],index = list('ABCDEFHIJK'))df.rename(index = {'A':'X','K':'Y'}, # 行索引columns={'Python':'人工智能'}, # 列索引修改inplace=True) # 替换原数据

df.replace(5, 50,inplace=True) # 针对全局的5换成50
df.replace([2,7],1024,inplace=True)

准备一个数据，代码如下：

boolean=[True,False]
gender=["男","女"]
color=["white","black","yellow"]
data=pd.DataFrame({"height":np.random.randint(150,190,100),"weight":np.random.randint(40,90,100),"smoker":[boolean[x] for x in np.random.randint(0,2,100)],"gender":[gender[x] for x in np.random.randint(0,2,100)],"age":np.random.randint(15,90,100),"color":[color[x] for x in np.random.randint(0,len(color),100) ]
})

数据如下：

1）map的用法

不论是利用字典还是函数进行映射，map方法都是把对应的数据逐个当作参数传入到字典或函数中，主要作用与Series，得到映射后的值。

# 1、使用字典进行映射
data["gender"] = data["gender"].map({"男":1, "女":0})

#2、使用函数
def gender_map(x):gender = 1 if x == "男" else 0return gender
#注意这里传入的是函数名，不带括号
data["gender"] = data["gender"].map(gender_map)

2）apply的用法

apply方法的作用原理和map方法类似，区别在于apply可以作用在series和dataframe上，而map只能作用在series上，并且apply能够传入功能更为复杂的函数。

# apply既可以操作Series又可以操作DataFrame
df['人工智能'].apply(lambda x : x + 100)
df['level'].apply(lambda x:1 if x else 0)
df.apply(lambda x : x + 1000) # apply对 所有的数据进行映射
def convert(x):return (x.median(),x.count(),x.min(),x.max(),x.std()) # 返回中位数，返回的是计数
df.apply(convert).round(1) # 默认操作列数据df.apply(convert,axis = 1) # axis = 1，操作数据就是行数据

3 transform

df = pd.DataFrame(np.random.randint(0,10,size = (10,3)),columns=['Python','Tensorflow','Keras'],index = list('ABCDEFHIJK'))# 可以针对一列数据，Series进行运算
df['Python'][:5].transform(lambda x : 1024 if x > 5 else -1024) # 这个功能和map，apply类似的

df['Tensorflow'].apply([np.sqrt, np.square, np.cumsum])     # 针对一列，进行不同的操作
df['Tensorflow'].transform([np.sqrt, np.square, np.cumsum]) # 针对一列，进行不同的操作

4）applymap针对每一个元素进行映射

df['gender'].applymap({’男':1, '女':0})

def convert(x):if x > 5:return Trueelse:return False
# 可以针对DataFrame进行运算
df.transform({'Python':np.cumsum,'Tensorflow':np.square,'Keras':convert}) # 对不同的列，执行不同的操作df.apply({'Python':np.cumsum,'Tensorflow':np.square,'Keras':convert}) # 对不同的列，执行不同的操作

4）打乱数据 np.random.permutation(length)，也可以用random.shuffle()

np.random.permutation（）的机制是随机打乱一个连续自然数的顺序，然后根据随机的index取出数据。

index = np.random.permutation(10) # 返回打乱顺讯的索引
print(index)
# 重排，索引打乱
df.take(index)

# 从大量数据中随机抽取数据
df.iloc[:5,].take(np.random.randint(0,10,size = 2)) # 随机抽样2个数据

类别型编码编码，有one-hot和哑变量编码，二者本质差不多，只是哑变量比独热编码要少一个字变量。
one-hot,哑变量；
str类型数据，经过哑变量变换可以使用数字表示

pd.get_dummies(df2,prefix='',prefix_sep='')
# 1表示 True；0表示 False

8、数据形状转变

df.T 行列互换
df.transpose() 行列互换

df.T # 转置，行变列，列变行

df2 = pd.DataFrame(np.random.randint(0,10,size = (6,3)),columns=['Python','Math','En'],index = pd.MultiIndex.from_product([list('ABC'),['期中','期末']])) # 多层索引df2

df.unstack(level) 将行索引变成列索引,-1表示最后一层(最里面一层）
将行索引变成列索引，-1表示最后一层(最里面一层）

df2.unstack(level=0)

df2.unstack(level=-1)

df.stack() 把列索引（列名字）放在行索引的位置，相当于减少列数，增加行数。

print(df2.stack())