pandas 常见函数的使用

Pandas 的使用

介绍:pandas 是 python 语言的的一个关于数据分析的扩展库；pandas 可以对各种数据进行操作, pandas 依赖于 numpy ，在常规的数据分析中，pandas 的使用范围是最宽广的;

参考文章:https://www.runoob.com/pandas/pandas-tutorial.html

原则：使用pandas处理数据的时候，尽量不要使用for循环去做操作，这样会使得 pandas 失去意义；

1.安装与导入

pip install pandas

导入

import pandas as pd

2.pandas 数据结构

pandas 的数据结构主要分为Series和DataFrame两种数据结构;

2.1 Series 数据结构

v = pd.Series([1,2,3,4,5,6])     # 构建结构
sv = pd.Series([1,2,3], index=['x','y','z'])

使用字典直接构建数据

sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myvar = pd.Series(sites)
myvar

2.2 DataFrame 数据结构

DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。

这种数据结构是我们最常用的数据结构的信息;

# 转换列表为数据对象
data = [['Google',10],['Runoob',12],['Wiki',13]]
df = pd.DataFrame(data,columns=['Site','Age'],dtype=float)  # 构建对象;
df

转换字典

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}
 
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data)
 
# 返回第一行
print(df.loc[0])
# 返回第二行
print(df.loc[1])
 
>>>
calories    420
duration     50
Name: 0, dtype: int64
calories    380
duration     40
Name: 1, dtype: int64
        
        
data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}
 
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data)
 
# 返回第一行和第二行
print(df.loc[[0, 1]])

3.Pandas的数据导入

数据导入主要看数据的来源与数据的形式，最常见的数据的形式是json,csv,sql,mongo,txt;

3.1 csv 数据的导入

# 读取数据消息
v = pd.read_csv('../data/tag.csv')
print(v.head())    # head(10)显示头部数据信息;
print(v.tail())    # tail(10) 显示末尾的数据信息;
v = pd.read_csv('../data/tag.csv', index_col=0)   # 读取数据不显示行索引;

pandas 的导入方式如上，还有原生的python操作文件的方式;

补充:.txt文件的使用是表格的时候，可以使用read_csv方法，将分隔符设置成为文件中的分隔符就可以;当.txt文件中是一段文本的时候，可以直接使用 python 的文件处理;

3.2 json 数据的导入

v = pd.read_json('s.json')
print(v.head())

3.3 sql 数据读取

import pandas as pd
 
from utils.db import db
 
# 已经封装好的模块获取数据库连接池中的连接;
conn = db.get_conn_cursor()[0]
sql_str = "select * from blogs"
v = pd.read_sql(sql_str, con=conn)
print(v.head())

说明： SQL 语句本身具备数据筛选与过滤的作用,如果可以在数据读取的时候直接使用复杂的 SQL 过滤掉一部分的数据,可以为数据预处理的部分省去很多的事情；

3.4 读取Mongo

pandas 读取 mongodb 的数据的时候直接，使用 pymongo 从非关系型数据库中读取数据，将数据转换成列表，在使用

import pandas as pd
 
from utils.db_mongo import mongo_helper
 
v = mongo_helper.fetch_all("test")   # 调用已经封装好的模块将信息成功，返回列表
sv = pd.DataFrame(v) # 加载成为 pandas 对象;
print(sv.head())

3.5 数据信息的统计

本部分属于额外补充,因为导入数据完成之后，会直接将数据信息设置，进行一下简单的统计;

v = mongo_helper.fetch_all("test")
sv = pd.DataFrame(v)
print(sv.shape)    # 获取数据的行数和列数;
print(sv.info())   # 显示各列的数据类型以及是否包含空值;

4.数据清洗

数据清洗，是数据预处理中的一个步骤;pandas 数据处理主要包含缺失值的处理和异常值处理

4.1 空值的清洗

缺失值的处理：对待缺失值的处理一般有两种方法，分别是插值法和删除法操作的类型也主要有两种，一种是有具体数值的，另一种是类别的离散值;

4.1.1 空值的删除

相关的函数

DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

参数说明：

• axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
• how：默认为 'any' 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how='all' 一行（或列）都是 NA 才去掉这整行。
• thresh：设置需要多少非空值的数据才可以保留下来的。
• subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
• inplace：如果设置 True，将计算得到的值直接覆盖之前的值并返回 None，修改的是源数据。

检查单元格是否为空isnull()，判断单元格是否为空;

4.1.2 空值的填充

使用较少,因为当数据量较大的时候删除一些空值数据并不影响具体的操作，当数据量较少的时候填充是非常不错的选择;

对于类别值或离散值,，我们将“NaN”视为一个类别。比如name列有"Tom"和“NaN”两个类别，pandas会自动将一列转化为两列，并且两列分别为“name_Tom”和"name_NaN"。并且转化为的两列中，每一行等于该列对应的类别的取1，否则取0。比如name_Tom列，只有第一行为1，其余行均为0，这里有点类似onehot编码。
这里用到get_dummies()函数，类似onehot编码。

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

按照上一行(下一行)进行数据的填充，参考文章：https://blog.csdn.net/weixin_46089741/article/details/122305108

# 上一行: 经常用在有分组信息的表里面
data = data.fillna(method='ffill', inplace=True)

4.2 重复值的处理

判断重复行

# 重复值为 True
DataFrame.duplicated()

删除重复行

# 重复值的删除
DataFrame.drop_duplicates()

默认是，当这一行与前面某一行所有元素都重复才删除。否则，需要指定判断重复的标志列。默认保留第一行重复值，也可指定保留最后一行;

df.drop_duplicates(['商品名称'], keep='last')
 
Out[2]: 
  商品名称  地区  销量
0  李老吉  北京  15
2  康帅傅  广州  28
3  娃啥啥  上海  13

4.3 经验异常值处理

经验指的是行业经验，即要结合具体业务。以气温为例子。放在全球来讲，气温最高也就 50 左右。那么可以简单认为超过 60 的气温数据就是异常。结合上一章讲的数据过滤即可实现。

df
 
Out[1]: 
    城市  温度
0   北京  -5
1   上海   5
2   广州  15
3  基加利  75
 
# 只选择温度小于60的
df[df['温度']<60]
 
Out[2]: 
   城市  温度
0  北京  -5
1  上海   5
2  广州  15

5.数据的类型转换与简单计算

dataframe.info()     # 查看数据的类型;与值的描述;
dataframe.dtypes     # 查看数据类型;

这里不在对数据类型进行介绍;只对常见的数据类型之间的转换进行记录

5.1 读取数据时直接指定数据类型

import pandas as pd
 
df = pd.read_excel('数据类型转换案例数据.xlsx',
                   dtype={
                       '国家':'string',
                       '向往度':'Int64'
                   }
                 )

使用astype()函数

df.受欢迎度.astype('float')

5.2 日期类型的转换

pd.to_datetime(s, unit='ns')      # 常见的情况
pd.to_datetime(s, format='%Y%m%d', errors='coerce')
# 时间差类型
pd.to_timedelta转化为时间差类型
In [23]: import numpy as np
 
In [24]: pd.to_timedelta(np.arange(5), unit='d')
Out[24]: TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'], dtype='timedelta64[ns]', freq=None)
 
In [25]: pd.to_timedelta('1 days 06:05:01.00003')
Out[25]: Timedelta('1 days 06:05:01.000030')
 
In [26]: pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan'])
Out[26]: TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015500', NaT], dtype='timedelta64[ns]', freq=None)

说明：时间字符串，日期和时间是有一个空格的2022-12-31 18.01.02，没有空格是无法转换的；

5.3 智能转换数据类型

convert_dtypes方法可以用来进行比较智能的数据类型转化，请看

6.数据的筛选

数据筛选是读取和预处理之后，

"""参考文章: https://blog.csdn.net/joker_zsl/article/details/119874694
"""
import pandas as pd
 
df = pd.DataFrame({'key': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C'], 'data': [0, 5, 10, 5, 10, 15, 10, 15, 20]})
 
 
def print_line():
    print("---------------------------------------------------------------------")
 
 
# 简单条件筛选; 类似于 SQL 的 where key = 'A'
print(df[df['key'] == 'A'])
"""
  key  data
0   A     0
3   A     5
6   A    10
"""
print_line()
# 复杂条件筛选, 选出大于均值的数据, 在将取到的值按照指定列进行升序排序;
print(df[df['data'] > df['data'].mean()].sort_values(by='data', ascending=False))
"""
  key  data
8   C    20
5   C    15
7   B    15
"""
 
print_line()
"""
loc : 通过索引 index 中取出具体的值;
iloc : 通过行号去数据;
参考文章: https://blog.csdn.net/weixin_44852067/article/details/122301685
"""
print(df.loc[1])  # 取出索引为 1 的数据;
print(df.iloc[0])  # 第 0 行数据;
# 取出 A列所有的行
 
"""
key     B
data    5
Name: 1, dtype: object
key     A
data    0
Name: 0, dtype: object
"""
print_line()
print(df.loc[:, ['key', 'data']])
"""
  key  data
0   A     0
1   B     5
2   C    10
3   A     5
4   B    10
5   C    15
6   A    10
7   B    15
8   C    20
"""
print_line()
# 按照条件提取
print(df.loc[(df['data'] > df['data'].mean()), ['key']])
"""
  key
5   C
7   B
8   C
"""
print_line()
# isin 函数使用包含筛选筛选
print(df.loc[df['data'].isin([0, 5, 15]), :])
"""
  key  data
0   A     0
1   B     5
3   A     5
5   C    15
7   B    15
"""
print_line()
# str.contains 字符串包含查询; 经常用在长字符串中;
print(df.loc[df['key'].str.contains('A'), :])
"""
  key  data
0   A     0
3   A     5
6   A    10
"""
 
print_line()
# where, 不满足条件的被赋值(默认赋空值)
cond = df['key'] == 'A'
print(df['key'].where(cond, inplace=False))  # 赋值空
print(df['key'].where(cond, other="Hello", inplace=False))  # 赋值 hello
"""
0      A
1    NaN
2    NaN
3      A
4    NaN
5    NaN
6      A
7    NaN
8    NaN
Name: key, dtype: object
0        A
1    Hello
2    Hello
3        A
4    Hello
5    Hello
6        A
7    Hello
8    Hello
Name: key, dtype: object
 
"""
 
print_line()
# query 查找
print(df.query('data > 10'))  # 与最开使得 df[df['data'] > 10] 相同
print(df.query('key.str.contains("A") & data > 5'))
# 上面的 query 一般情况下都是可以用原生的函数进行还原;
print(df[(df['key'].str.contains('A')) & (df['data'] > 5)])
"""
  key  data
5   C    15
7   B    15
8   C    20
  key  data
6   A    10
  key  data
6   A    10
 
"""
print_line()
# filter 过滤
"""
filter是另外一个独特的筛选功能。filter不筛选具体数据，而是筛选特定的行或列。它支持三种筛选方式：
    - items：固定列名
 
    - regex：正则表达式
 
    - like：以及模糊查询
 
axis：控制是行 index 或列 columns 的查询
"""
print(df.filter(items=['key']))
print(df.filter(regex='e', axis=1))  # 查找列
print(df.filter(regex='1', axis=0))  # 查找行
# 模糊匹配
print(df.filter(like='a', axis=1))
"""
  key
0   A
1   B
2   C
3   A
4   B
5   C
6   A
7   B
8   C
  key
0   A
1   B
2   C
3   A
4   B
5   C
6   A
7   B
8   C
  key  data
1   B     5
   data
0     0
1     5
2    10
3     5
4    10
5    15
6    10
7    15
8    20
"""
 
print_line()
"""
any方法意思是，如果至少有一个值为True结果便为True，all需要所有值为True结果才为True，比如下面这样。
any和all一般是需要和其它操作配合使用的，比如查看每列的空值情况。
"""
 
print(df['key'].any())
print(df.isnull())  # 检查是否存在空值,存在返回 True
print(df.isnull().any(axis=0))  #
print(df.isnull().any(axis=1).sum())  # 查看空值的函数
"""
---------------------------------------------------------------------
True
     key   data
0  False  False
1  False  False
2  False  False
3  False  False
4  False  False
5  False  False
6  False  False
7  False  False
8  False  False
key     False
data    False
dtype: bool
0
"""

8.数据分析常用函数与功能

pandas 可以完成数据统计分析的基础部分，因此也是必不可少的利器;

8.1 pandas 分组聚合

说明：当数据源是mysql等关系数据库的时候，可以使用group by进行数据的分组聚合，效果依旧很好，pandas 最长用在 csv 等数据集中；

pandas 分组聚合是简单的统计分析的利器，但是其中的函数特别容易混乱，不需要记住每个函数的信息，只需要知道逻辑是分组后的操作，就可以根据查询，或者自定义操作后的函数信息；

参考文章：https://blog.csdn.net/fullbug/article/details/122892358

# 构建数据数据集, 通过简单的数据集进行分析,可以更好的剖析每个函数的功能;
df=pd.DataFrame({'key':['A','B','C','A','B','C','A','B','C'],'data':[0,5,10,5,10,15,10,15,20]})
df.head()

8.1.1 数据分组

# 按照 key 进行分组,分组后没一个类别中相当于有一个字表
pd.DataFrame(df.groupby(['key']))
# 查看字表的信息;
pd.DataFrame(df.groupby(['key']))[1][0]

虽然这种方法可以查看到分组后的字表，但是不到万不得已，不要使用这种表嵌套的形式，该种方式不太符合展示与后期的程序处理，可以在中间过程试用一下作为中间数据的处理桥梁，但是步骤依旧繁琐，因此最好减少使用;

8.1.2 数据聚合

# 此处重新构建数据集，因为实际的数据分析中往往都是多列的数据信息
df=pd.DataFrame({
    'key':['A','B','C','A','B','C','A','B','C'],
    'data':[0,5,10,5,10,15,10,15,20],
    'v':[0,3,9,3,9,12,15,9,18]})
df

分组求和

# 求和，使用分组聚合之后,是对数据中得每一列都进行了聚合
v = df.groupby(['key']).sum()
v
# 只对某一列进行求和
sv = df.groupby(['key'])['v'].sum()
sv

# 其他的常见聚合函数
# 每一列求均值，求取单独一列的时候可以像上一步一样进行选取
df.groupby(['key']).mean()
df.groupby(['key']).max()
df.groupby(['key']).min()

其他常见的函数信息

函数名	描述
count	分组中非NA值的数量
sum	非NA值的和
mean	非NA值的平均值
median	非NA值的中位数
std, var	标准差和方差
min, max	非NA的最小值，最大值
prod	非NA值的乘积
first, last	非NA值的第一个,最后一个

更多的分组后的操作

使用自定义的聚合函数

# 求极差函数:
def peak_to_peak(arr: pd.Series):
    return arr.max() - arr.min()
# 执行自定义的函数信息;
df.groupby(['key']).agg(peak_to_peak)

分组后的过滤

def filter_sum(arr):
    if arr['data'].sum() > 20:
        return True  # 返回 true 
    else:
        return False # 不满足，被过滤
 
 
df.groupby('key').filter(filter_sum)

8.2 one-hot 编码

import pandas as pd
 
# 构建数据集
df = pd.DataFrame([
    ['green', 'A', 2],
    ['red', 'B', 3],
    ['blue', 'A', 2],
])
# 重新命名列名
df.columns = ['color', 'class', 'num']
print(df)
# 进行 one-hot 编码
print(pd.get_dummies(df))

8.3 apply() 的使用

参考文章：https://blog.csdn.net/weixin_44852067/article/details/122364306

Pandas 的apply()方法是用来调用一个函数(python method)，让自定义的函数对数据进行批处理。Pandas 的很多对象都可以使用 apply() 来调用函数，如 Dataframe、Series、分组对象、各种时间序列等。

# apply(函数), 最常见的是内部传入的是匿名函数信息;
import pandas as pd
import numpy as np
 
df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
print(df)
 
# pandas 使用 numpy 的函数;
print(df.apply(np.sqrt))  # 求开方后的值
print(df.apply(np.sum, axis=1))  # axis=1 横向,axis=0 纵向;
# 使用匿名函数;
print(df.apply(lambda x: x + 2))  # 每一个值加 2
 
 
# 使用自定义的函数
def square(x):
    return x ** 2
 
 
print(df.apply(square))
 
"""
   A  B
0  4  9
1  4  9
2  4  9
     A    B
0  2.0  3.0
1  2.0  3.0
2  2.0  3.0
0    13
1    13
2    13
dtype: int64
   A   B
0  6  11
1  6  11
2  6  11
    A   B
0  16  81
1  16  81
2  16  81
"""

8.4 导出为 python数据类型

# 经常用在使用 python 原生数据中,常见的是 Pyecharts 的可视化操作中;
print(df['A'].tolist())
print(df['A'].to_dict())

8.5 pandas 计算分位数

import pandas as pd
 
df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': ['d', 'e', 'f']})
print(df['a'].quantile(0.25))

9.数据的合并与导出

数据的导出主要分为SQL的导出和csv文件的导出；当数据量不是特别巨大的时候 csv 文件是不错的选择，因为SQL导出的时候会将数据之间的相关的关联与约束全部取消掉;

9.1 表连接

表的连接分为横向和纵向两个方向；

9.1.1 横向连接

不到万不得已的情况下不要使用表的拼接；

# 只能实现两张表的合并,按照指定的列进行合并
import pandas as pd
import numpy as np
 
df1 = pd.DataFrame(np.arange(12).reshape(3, 4), columns=['a', 'b', 'c', 'd'])
print(df1)
df2 = pd.DataFrame({'b': [1, 5], 'd': [3, 7], 'a': [0, 4]})
print(df2)
# 横向连接重叠列自动
print("------------------")
print(pd.merge(df1, df2))  # 只会留下数据相同的列;
"""
   a  b   c   d
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
   b  d  a
0  1  3  0
1  5  7  4
------------------
   a  b  c  d
0  0  1  2  3
1  4  5  6  7
"""

直接拼接

print(pd.concat([df1, df2], axis=1))
"""
    A   B   C   D   E   A   B   C   D   F
0  A0  B0  C0  D0  E0  A4  B4  C4  D4  F4
1  A1  B1  C1  D1  E1  A5  B5  C5  D5  F5
2  A2  B2  C2  D2  E2  A6  B6  C6  D6  F6
3  A3  B3  C3  D3  E3  A7  B7  C7  D7  F7
"""

concat 的函数模式较多不做过多的描述;

9.1.2 纵向连接

import pandas as pd
 
 
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3'],
                    'E': ['E0', 'E1', 'E2', 'E3']
                    })
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7'],
                    'F': ['F4', 'F5', 'F6', 'F7']
                    })
# 默认的concat，参数为axis=0、join=outer、ignore_index=False
print(pd.concat([df1, df2]))
"""
    A   B   C   D    E    F
0  A0  B0  C0  D0   E0  NaN
1  A1  B1  C1  D1   E1  NaN
2  A2  B2  C2  D2   E2  NaN
3  A3  B3  C3  D3   E3  NaN
0  A4  B4  C4  D4  NaN   F4
1  A5  B5  C5  D5  NaN   F5
2  A6  B6  C6  D6  NaN   F6
3  A7  B7  C7  D7  NaN   F7
"""

9.2 数据导出

# 导出到 csv
df.to_csv("data.csv", encoding="utf-8")
# 其他导出 json 文件的方法与之类似;

导出数据到数据库中

import pymysql
from sqlalchemy import create_engine
 
# 创建数据库引擎，传入uri规则的字符串
engine = create_engine('mysql+pymysql://root:chuanzhi@127.0.0.1:3306/python?charset=utf8')
# 数据库中会创建对应的表, 但是对应之间关系没有,数据类型约束可能也没有
df.to_sql('tb_scientists', engine, index=False, if_exists='append')

继续努力，终成大器！