Pandas 常用函数 数据整理与清洗

已于 2023-09-13 12:11:44 修改
阅读量390 收藏 4
点赞数 3
分类专栏： # Pandas Python 文章标签： pandas python 数据分析
于 2023-07-24 10:57:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengyj0505/article/details/131891590
版权

当有一定数据积累时，可以对数据进行较为详细的分析，数据处理一般分为三个阶段：数据整理与清洗、数据分析与建模、数据可视化与制表，其中Pandas 是处理数据最常用的工具。

文章目录

首先认识一下pandas的数据结构，分为Series和DataFrame两种，其中Series指带标签的一维同构数组，DataFrame是带标签的二维表格，他们在维数上有较大的区别。

0、数据结构

维数名称描述
1Series带标签的一维同构数组
2DataFrame带标签的，大小可变的，二维表格

以下列出了 Pandas 在进行数据整理与清洗时常用的一些函数及使用实例：

1、读取数据

函数说明
pd.read_csv(file_path)读取 CSV 文件
df.to_csv()导出CSV文件
pd.read_excel(file_path,sheet_name)读取 Excel 文件
df.to_excel()导出Excel文件
pd.read_sql(query, connection_object)从 SQL 数据库读取数据
pd.read_json(json_string)从 JSON 字符串中读取数据
pd.read_html(url)从 HTML 页面中读取数据

注： 最常用的是读取csv、excel、sql格式的数据。

import pandas as pd

#CSV
# 1.从CSV文件中读取数据
df = pd.read_csv('student_info.csv')
# 2.导出数据为csv格式
csv_data= df.to_csv('student_info.csv')

#Excel
# 1.从Excel文件中读取数据；文件路径，工作表名称；
df = pd.read_excel('student_info.xlsx',sheet_name='sheet1')
# 2.导出到一张表中
excel_data = df.to_excel('student_info.xlsx',sheet_name='sheet2')
# 3.导出多个数据集到一张表的不同sheet中
with pd.ExcelWriter(file_path + 'data_dowith.xlsx') as writer:  
    for i in range(len(str_sheet_name)):
        df = work_year(str_sheet_name[i])
        df.to_excel(writer, sheet_name='A0'+str(i+1))


# 从 SQL 数据库中读取数据
import sqlite3
conn = sqlite3.connect('database.db')
df = pd.read_sql('SELECT * FROM table_name', conn)

# 从 JSON 字符串中读取数据
json_string = '{"name": "John", "age": 30, "city": "New York"}'
df = pd.read_json(json_string)

# 从 HTML 页面中读取数据
url = 'https://blog.csdn.net/qq_54054566/article/details/125295320'
dfs = pd.read_html(url)
df = dfs[0] # 选择第一个数据框

2、查看数据

函数说明
df.head(n)显示前 n 行数据
df.tail(n)显示后 n 行数据；
df.index显示数据的索引
df.columns显示数据的列名
df.info()显示数据的信息，包括列名、数据类型、缺失值等
df.shape显示数据的行数和列数
df.size显示数据的元素个数
df.values以 ndarray 数组的形式返回 DataFrame 中的数据
df.describe()显示数据的基本统计信息，包括均值、方差、最大值、最小值等
# 已知数据如下
import pandas as pd
data = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2},
  {"name": "刘凯", "age": 35, "gender": "男","marks": 73.6},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9}
]

df = pd.DataFrame(data)
# 显示前三行数据
print(df.head(3))
'''
  name  age gender  marks
0   李明   25      男   85.4
1   田华   30      女   96.2
2   刘凯   35      男   73.6
'''

# 显示前最后两行数据
print(df.tail(2))
'''
  name  age gender  marks
2   刘凯   35      男   73.6
3   孙英   21      女   88.9
'''

# 显示数据的索引
print(df.index)
'''
RangeIndex(start=0, stop=4, step=1)
'''

# 显示数据的列名
print(df.columns)
'''
Index(['name', 'age', 'gender', 'marks'], dtype='object')
'''

# 显示数据信息
print(df.info())
'''
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   name    4 non-null      object 
 1   age     4 non-null      int64  
 2   gender  4 non-null      object 
 3   marks   4 non-null      float64
dtypes: float64(1), int64(1), object(2)
memory usage: 256.0+ bytes
None
'''

# 显示数据的行数和列数
print(df.shape)
'''
(4, 4)
'''

# 显示数据的元素个数
print(df.size)
'''
16
'''

# 显示基本统计信息
print(df.describe())
'''
             age      marks
count   4.000000   4.000000
mean   27.750000  86.025000
std     6.075909   9.426337
min    21.000000  73.600000
25%    24.000000  82.450000
50%    27.500000  87.150000
75%    31.250000  90.725000
max    35.000000  96.200000
'''

3、选择数据

数据的选择分为两种，分别是选择和投影，其中选择是指：从二维表中选择行；投影：从数据中选择列。

函数说明
df[column_name]通过列名选择指定的列
df[column_name].head(num)通过列名和head选择指定的连续行
df.loc[row_index, column_name]通过标签选择指定的行和列；前闭后闭
df.iloc[row_index, column_index]通过位置选择指定的行和列；前闭后开
df.sample(n)随机选择 n 行数据

注： 以下方法只适用于DataFrame框架。

# 选择指定的列
print(df['name'])
'''
0    李明
1    田华
2    刘凯
3    孙英
Name: name, dtype: object
'''
# 通过标签选择数据
print(df.loc[1, 'age'])
'''
30
'''

print(df.loc[0:2, 'adress'])
'''
0    河北省
1    北京市
2    浙江省
Name: adress, dtype: object
'''

print(df.loc[[0,2], ['age','adress']])
'''
   age adress
0   25    河北省
2   35    浙江省
'''

# 通过位置选择数据
print(df.iloc[1, 1])
'''
30
'''

print(df.iloc[0:2, 2])
'''
0    河北省
1    北京市
Name: adress, dtype: object
'''

print(df.iloc[[0,2], [1,2]])
'''
   age adress
0   25    河北省
2   35    浙江省
'''

# 随机选择 n 行数据
print(df.sample(n=1))
'''
  name  age adress
1   田华   30    北京市
'''

4、根据条件筛选数据

可以使用多个条件对数据进行查询，这里需要用到逻辑运算符。

函数说明
df[df[‘column_name’] > value]选择列中满足条件的行
df.query(‘column_name > value’)使用字符串表达式选择列中满足条件的行

注： 并和或用符号&、|表示，只有query可以使用and、or。

# 选择列中满足条件的行
print(df[df['age']>25])
'''
  name  age adress
1   田华   30    北京市
2   刘凯   35    浙江省
'''
print(df[df.age > 25].loc[:,'name'])
'''
1    田华
2    刘凯
Name: name, dtype: object
'''

print(df[df.age > 25].loc[:,['name','age']])
'''
  name  age
1   田华   30
2   刘凯   35
'''

# 使用字符串表达式选择列中满足条件的行
print(df.query("age > 25"))
'''
  name  age adress
1   田华   30    北京市
2   刘凯   35    浙江省
'''

print(df.query("age > 25").name)
'''
1    田华
2    刘凯
Name: name, dtype: object
'''

5、数据清洗

原始数据多数存在数据缺失、重复或者格式不统一的情况，那么如何对缺失值和重复数据进行处理呢？首先要查找到缺失或者重复的数据，然后才能对这些数据进行删除或者填充处理。

函数说明
df.isnull()检查行或列中是否有缺失值，返回布尔类型
df.isna().sum()统计每列的缺失值数量
df.dropna()删除包含缺失值的行或列，默认不改变原始数据
df.fillna(value)将缺失值替换为指定的值
df.replace(old_value, new_value)将指定值替换为新值
df.duplicated()检查是否有重复的数据
df.drop_duplicates()删除重复的数据
# 已知数据如下
import pandas as pd
data = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4},
  {"name": "田华", "gender": "女","marks": 96.2},
  {"name": "刘凯", "age": 35, "gender": "男",},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9}
]
df = pd.DataFrame(data)

#检查是否有缺失;
# 1.检查所有数据；
print(df.isnull())
'''
    name    age  gender  marks
0  False  False   False  False
1  False   True   False  False
2  False  False   False   True
3  False  False   False  False
4  False  False   False  False
'''
# 2.检查列；
print(df.isnull().any(axis=0))
'''
name      False
age        True
gender    False
marks      True
dtype: bool
'''

# 3.检查行；
print(df.isnull().any(axis=1))
'''
0    False
1     True
2     True
3    False
4    False
dtype: bool
'''

# 4.检查某一列；
print(df['marks'].isnull())
'''
0    False
1    False
2     True
3    False
4    False
Name: marks, dtype: bool
'''

# 5.检查某一行
print(df.iloc[2,:].isnull())
'''
name      False
age       False
gender    False
marks      True
Name: 2, dtype: bool
'''

#统计每列的缺失值数量
print(df.isna().sum())
'''
name      0
age       1
gender    0
marks     1
dtype: int64
'''

#删除包含缺失值的行或列，不改变原始数据
# 1.默认删除行
print(df.dropna())
'''
  name   age gender  marks
0   李明  25.0      男   85.4
3   孙英  21.0      女   88.9
4   孙英  21.0      女   88.9
'''
# 2.使用axis=1删除列
print(df.dropna(axis=1))
'''
  name gender
0   李明      男
1   田华      女
2   刘凯      男
3   孙英      女
4   孙英      女
'''

#将缺失值替换为指定的值
# 1.用固定值填充
print(df.fillna(0))
'''
 name   age gender  marks
0   李明  25.0      男   85.4
1   田华   0.0      女   96.2
2   刘凯  35.0      男    0.0
3   孙英  21.0      女   88.9
4   孙英  21.0      女   88.9
'''

# 2.对不同列填充不同值
max_age = max(df['age'])
print(df.fillna({'age':max_age,'marks':'一百'}))
'''
  name   age gender  marks
0   李明  25.0      男   85.4
1   田华  35.0      女   96.2
2   刘凯  35.0      男   一百
3   孙英  21.0      女   88.9
4   孙英  21.0      女   88.9
'''

# 2.用上一行的数据填充
print(df.fillna(method='ffill'))
'''
  name   age gender  marks
0   李明  25.0      男   85.4
1   田华  25.0      女   96.2
2   刘凯  35.0      男   96.2
3   孙英  21.0      女   88.9
4   孙英  21.0      女   88.9
'''

#将指定值替换为新值
# 1.替换一个值
print(df.replace(25.0, '77'))
'''
  name  age gender  marks
0   李明   77      男   85.4
1   田华  NaN      女   96.2
2   刘凯   35      男    NaN
3   孙英   21      女   88.9
4   孙英   21      女   88.9
'''

# 2.替换多个值
print(df.replace({30:-1,21:99}))
'''
  name   age gender  marks
0   李明  25.0      男   85.4
1   田华   NaN      女   96.2
2   刘凯  35.0      男    NaN
3   孙英  99.0      女   88.9
4   孙英  99.0      女   88.9
'''

# 检查是否有重复的数据；两行数据全部相同为重复
print(df.duplicated())
'''
0    False
1    False
2    False
3    False
4     True
dtype: bool
'''

# 删除重复的数据
print(df.drop_duplicates())
'''
  name   age gender  marks
0   李明  25.0      男   85.4
1   田华   NaN      女   96.2
2   刘凯  35.0      男    NaN
3   孙英  21.0      女   88.9
'''

6、数据排序

数据集可以按照索引、指定列的值以及列进行排序，其中最常用的就是对指定列（可以是多个列）的值升序或者降序。

函数说明
df.sort_values(column_name)按照指定列的值排序
df.sort_values([column_name1, column_name2], ascending=[True, False])按照多个列的值排序
df.sort_index()按照索引排序
# 已知数据如下
import pandas as pd
data = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2},
  {"name": "刘凯", "age": 30, "gender": "男","marks": 73.6},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9}
]

df = pd.DataFrame(data)

# 按照指定列的值排序，默认升序
print(df.sort_values('age'))
'''
  name  age gender  marks
3   孙英   21      女   88.9
0   李明   25      男   85.4
1   田华   30      女   96.2
2   刘凯   30      男   73.6
'''

# 按照多个列的值排序，
print(df.sort_values(['age', 'marks'], ascending=[False,True]))
'''
  name  age gender  marks
2   刘凯   30      男   73.6
1   田华   30      女   96.2
0   李明   25      男   85.4
3   孙英   21      女   88.9
'''

# 按照索引排序
print(df.sort_index())
'''
  name  age gender  marks
0   李明   25      男   85.4
1   田华   30      女   96.2
2   刘凯   30      男   73.6
3   孙英   21      女   88.9
'''

7、数据分组、窗口滑动和透视

对指定列进行分组并计算是最常用也是最基础的方法，另外在对数据集进行累计求和时需要用到滑动窗口函数或聚合窗口函数，在python中业可以做透视分析，有点类似excel的数据透视。

函数名称函数说明
分组函数df.groupby(column_name)按照指定列进行分组（并筛选分组数据）
滑动窗口函数df.rolling(window=n)按照指定窗口进行分组
累计窗口函数df.expanding(min_periods=n)从某一行开始逐个累计（扩展）窗口
聚合函数df.aggregate(function_name)对分组后的数据进行聚合操作
透视函数df.pivot_table(values, index, columns, aggfunc=function_name)生成透视表
(1) groupby
# 已知数据如下
import pandas as pd
import numpy as np
infos = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4,"course_id":"N01"},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2,"course_id":"N01"},
  {"name": "刘凯", "age": 30, "gender": "男","marks": 73.6,"course_id":"N02"},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9,"course_id":"N03"},
  {"name": "王三", "age": 21, "gender": "女","marks": 55.9,"course_id":"N01"}
]
df = pd.DataFrame(infos)

# 按照指定列进行分组；使用count(size)、max、min、sum、mean、median、std；对两个字段进行分组
print(df.groupby('gender')['name'].count())
'''
gender
女    3
男    2
Name: name, dtype: int64
'''

print(df.groupby('gender').name.size())
'''
gender
女    3
男    2
Name: name, dtype: int64
'''

print(df.groupby(['gender','name'])['marks'].sum())
'''
gender  name
女       孙英      88.9
        王三      55.9
        田华      96.2
男       刘凯      73.6
        李明      85.4
Name: marks, dtype: float64
'''

#处理分组后的计算结果;直接加运算符判断、使用apply函数、先统计后过滤
#方法一
print(df.groupby('gender').name.count()>2)
#方法二
print(df.groupby('gender').apply(lambda x:len(x)>2))
'''
gender
女     True
男    False
Name: name, dtype: bool
'''

#方法三
# 分组等级gender,统计数量
name_counts = df.groupby('gender')['name'].count()
# 过滤数量大于2的性别人数
print(name_counts[name_counts > 2])
'''
gender
女    3
Name: name, dtype: int64
'''

#方法四
# 通过 filter() 函数可以实现数据的筛选，该函数返回过滤后新的数据集。
print (df.groupby('gender').filter(lambda x: len(x) > 2))
'''
  name  age gender  marks course_id
1   田华   30      女   96.2       N01
3   孙英   21      女   88.9       N03
4   王三   21      女   55.9       N01
'''

#分组聚合
# 通过agg函数对分组后结果进行处理
grouped=df.groupby('gender')
print(grouped['marks'].agg([np.size,np.mean,np.std]))
'''
        size       mean        std
gender                            
女        3.0  80.333333  21.472385
男        2.0  79.500000   8.343860
'''
(2) rolling
import pandas as pd
infos = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4,"course_id":"N01"},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2,"course_id":"N01"},
  {"name": "刘凯", "age": 30, "gender": "男","marks": 73.6,"course_id":"N02"},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9,"course_id":"N03"},
  {"name": "王三", "age": 21, "gender": "女","marks": 55.9,"course_id":"N01"}
]
df = pd.DataFrame(infos)

#滑动窗口函数
'''
window=3表示是每一列中依次紧邻的每 3 个数求一次均值。
当不满足 3 个数时，所求值均为 NaN 值，因此前两列的值为 NaN，直到第三行值才满足要求 window =3。求均值的公式如下所示：
index2的计算方式为 (index0+index1+index2)/3，
index3 的计算方式是 (index1+index2+index3)/3，
index4 的计算方式是 (index2+index3+index4)/3
'''
print(df['marks'].rolling(window=3).mean())
'''
0          NaN
1          NaN
2    85.066667
3    86.233333
4    72.800000
Name: marks, dtype: float64
'''
(3) expanding
import pandas as pd
infos = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4,"course_id":"N01"},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2,"course_id":"N01"},
  {"name": "刘凯", "age": 30, "gender": "男","marks": 73.6,"course_id":"N02"},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9,"course_id":"N03"},
  {"name": "王三", "age": 21, "gender": "女","marks": 55.9,"course_id":"N01"}
]
df = pd.DataFrame(infos)

#累计窗口函数
'''
expanding() 又叫累计窗口函数，累计是指由序列的第一个元素开始，逐个向后计算元素的聚合值。min_periods = n表示向后移动 n 个值后开始求第一次的值
index0 的计算方式为 index0，
index1 的计算方式是 (index0+index1)/2，
index2的计算方式为 (index0+index1+index2)/3，
index3 的计算方式是 (index0+index1+index2+index3)/4，
index4 的计算方式是 (index0+index1+index2+index3+index4)/5
依次类推。
'''
print (df['marks'].expanding().sum())
'''
0     85.4
1    181.6
2    255.2
3    344.1
4    400.0
Name: marks, dtype: float64
'''

print (df['marks'].expanding(min_periods=3).sum())
'''
0      NaN
1      NaN
2    255.2
3    344.1
4    400.0
Name: marks, dtype: float64
'''
(4) aggregate
import pandas as pd
infos = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4,"course_id":"N01"},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2,"course_id":"N01"},
  {"name": "刘凯", "age": 30, "gender": "男","marks": 73.6,"course_id":"N02"},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9,"course_id":"N03"},
  {"name": "王三", "age": 21, "gender": "女","marks": 55.9,"course_id":"N01"}
]
df = pd.DataFrame(infos)

#聚合函数
print(df.aggregate(np.sum))
'''
name              李明田华刘凯孙英王三
age                      127
gender                 男女男女女
marks                    400
course_id    N01N01N02N03N01
dtype: object
'''

#聚合窗口函数
# 窗口大小为3，min_periods 最小观测值为1;没有窗口函数时，聚合函数就是从第一条开始累计到当前条
r = df.rolling(window=3,min_periods=1)

# 对整体聚合
print(r.aggregate(np.sum))
'''
    age  marks
0  25.0   85.4
1  55.0  181.6
2  85.0  255.2
3  81.0  258.7
4  72.0  218.4
'''

# 对 某一列聚合
print(r['marks'].aggregate(np.sum))
'''
0     85.4
1    181.6
2    255.2
3    258.7
4    218.4
Name: marks, dtype: float64
'''

# 对 两列聚合
print(r['age','marks'].aggregate(np.sum))
'''
    age  marks
0  25.0   85.4
1  55.0  181.6
2  85.0  255.2
3  81.0  258.7
'''

# 对 两列都进行两种不同计算方式的聚合
print(r['age','marks'].aggregate([np.mean,np.sum]))
'''
         age            marks       
        mean   sum       mean    sum
0  25.000000  25.0  85.400000   85.4
1  27.500000  55.0  90.800000  181.6
2  28.333333  85.0  85.066667  255.2
3  27.000000  81.0  86.233333  258.7
4  24.000000  72.0  72.800000  218.4
'''

# 对某一列进行一种聚合，另一列进行另一种聚合
print(r.aggregate({'age': np.mean,'marks': np.sum}))
'''
         age  marks
0  25.000000   85.4
1  27.500000  181.6
2  28.333333  255.2
3  27.000000  258.7
4  24.000000  218.4
'''
(5) pivot_table
# 已知数据如下
import pandas as pd
infos = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4,"course_id":"N01"},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2,"course_id":"N01"},
  {"name": "刘凯", "age": 30, "gender": "男","marks": 73.6,"course_id":"N02"},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9,"course_id":"N03"},
  {"name": "王三", "age": 21, "gender": "女","marks": 55.9,"course_id":"N01"}
]
course = [
  {"course_id": "N01", "course_name":"排球"},
  {"course_id": "N02", "course_name":"足球"},
  {"course_id": "N03", "course_name":"乒乓球"},
  {"course_id": "N04", "course_name":"羽毛球"},
  {"course_id": "N05", "course_name":"篮球"}
]
infos = pd.DataFrame(infos)
course = pd.DataFrame(course)

df = pd.merge(infos,course,on='course_id')

#数据透视的使用方法（pivot_table）.fillna(0)表示nan值使用0填充
print(df.pivot_table(values=['name'], index=['gender'], columns=['course_name'],aggfunc='count').fillna(0))
'''
            name          
course_name  乒乓球   排球   足球
gender                    
女            1.0  2.0  0.0
男            0.0  1.0  1.0
'''

8、数据合并和连接

对数据进行合并和连接的时候可以分别使用concat、merge。merge最常用，它可以将两个 DataFrame 数据集拼接成一个新的数据集，与其相似的还有join函数。

函数说明
pd.concat([df1, df2])将多个数据集按照行或列进行合并
pd.merge(df1, df2, how =merge_way,on=column_name)按照指定列将两个数据集进行连接
(1) concat
# 已知数据如下
import pandas as pd
infos1 = [
  {"name": "李明", "age": 25, "gender": "男","marks": 85.4},
  {"name": "田华", "age": 30, "gender": "女","marks": 96.2},
  {"name": "刘凯", "age": 30, "gender": "男","marks": 73.6},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9},
  {"name": "王三", "age": 21, "gender": "女","marks": 55.9}
]
infos2 = [
  {"name": "周和", "age": 12, "gender": "男","marks": 73.4},
  {"name": "贺田雨", "age": 20, "gender": "女","marks": 45.2},
  {"name": "杨三郎", "age": 40, "gender": "男","marks": 69.6},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9}
]
infos3 = [
  {"name": "周和", "age": 12, "gender": "男","marks": 73.4},
  {"name": "贺田雨", "age": 20, "gender": "女","marks": 45.2},
  {"name": "杨三郎", "age": 40, "gender": "男","marks": 69.6},
  {"name": "孙英", "age": 21, "gender": "女","marks": 88.9}
]
df1 = pd.DataFrame(infos1)
df2 = pd.DataFrame(infos2)
df3 = pd.DataFrame(infos3)

#将多个数据集按照行或列进行合并
# 1.行合并，不去重，不改变序号
print(pd.concat([df1, df2]))
'''
  name  age gender  marks
0   李明   25      男   85.4
1   田华   30      女   96.2
2   刘凯   30      男   73.6
3   孙英   21      女   88.9
4   王三   21      女   55.9
0   周和   12      男   73.4
1  贺田雨   20      女   45.2
2  杨三郎   40      男   69.6
3   孙英   21      女   88.9
'''

# 2.行合并，不去重，改变序号; ignore_index 等于 True
print(pd.concat([df1, df2],ignore_index=True))
'''
  name  age gender  marks
0   李明   25      男   85.4
1   田华   30      女   96.2
2   刘凯   30      男   73.6
3   孙英   21      女   88.9
4   王三   21      女   55.9
5   周和   12      男   73.4
6  贺田雨   20      女   45.2
7  杨三郎   40      男   69.6
8   孙英   21      女   88.9
'''

# 3.多个数据集行合并，去重，改变序号; 
print(pd.concat([df1, df2,df3],ignore_index=True))
'''
   name  age gender  marks
0    李明   25      男   85.4
1    田华   30      女   96.2
2    刘凯   30      男   73.6
3    孙英   21      女   88.9
4    王三   21      女   55.9
5    周和   12      男   73.4
6   贺田雨   20      女   45.2
7   杨三郎   40      男   69.6
8    孙英   21      女   88.9
9    周和   12      男   73.4
10  贺田雨   20      女   45.2
11  杨三郎   40      男   69.6
12   孙英   21      女   88.9
'''

# 4.列合并
print(pd.concat([df1,df2],axis=1))
'''
  name  age gender  marks name   age gender  marks
0   李明   25      男   85.4   周和  12.0      男   73.4
1   田华   30      女   96.2  贺田雨  20.0      女   45.2
2   刘凯   30      男   73.6  杨三郎  40.0      男   69.6
3   孙英   21      女   88.9   孙英  21.0      女   88.9
4   王三   21      女   55.9  NaN   NaN    NaN    NaN
'''
(2) merge
# 已知数据如下
import pandas as pd
infos = [
  {"course_id":"N01","name": "李明", "age": 25, "gender": "男","marks": 85.4},
  {"course_id":"N01","name": "田华", "age": 30, "gender": "女","marks": 96.2},
  {"course_id":"N02","name": "刘凯", "age": 30, "gender": "男","marks": 73.6},
  {"course_id":"N03","name": "孙英", "age": 21, "gender": "女","marks": 88.9},
  {"course_id":"N01","name": "王三", "age": 21, "gender": "女","marks": 55.9}
]
course = [
  {"course_id": "N01", "course_name":"排球"},
  {"course_id": "N02", "course_name":"足球"},
  {"course_id": "N03", "course_name":"乒乓球"},
  {"course_id": "N04", "course_name":"羽毛球"},
  {"course_id": "N05", "course_name":"篮球"}
]
infos = pd.DataFrame(infos)
course = pd.DataFrame(course)

# 按照指定列将两个数据集进行合并,默认内连接
print(pd.merge(infos,course,on='course_id'))
'''
  course_id name  age gender  marks course_name
0       N01   李明   25      男   85.4          排球
1       N01   田华   30      女   96.2          排球
2       N01   王三   21      女   55.9          排球
3       N02   刘凯   30      男   73.6          足球
4       N03   孙英   21      女   88.9         乒乓球
'''

#左连接
print(pd.merge(infos,course,how='left',on='course_id'))
'''
  course_id name  age gender  marks course_name
0       N01   李明   25      男   85.4          排球
1       N01   田华   30      女   96.2          排球
2       N02   刘凯   30      男   73.6          足球
3       N03   孙英   21      女   88.9         乒乓球
4       N01   王三   21      女   55.9          排球
'''

#右连接
print(pd.merge(infos,course,how='right',on='course_id'))
'''
  course_id name   age gender  marks course_name
0       N01   李明  25.0      男   85.4          排球
1       N01   田华  30.0      女   96.2          排球
2       N01   王三  21.0      女   55.9          排球
3       N02   刘凯  30.0      男   73.6          足球
4       N03   孙英  21.0      女   88.9         乒乓球
5       N04  NaN   NaN    NaN    NaN         羽毛球
6       N05  NaN   NaN    NaN    NaN          篮球
'''

#内连接
print(pd.merge(infos,course,how='inner',on='course_id'))
'''
  course_id name  age gender  marks course_name
0       N01   李明   25      男   85.4          排球
1       N01   田华   30      女   96.2          排球
2       N01   王三   21      女   55.9          排球
3       N02   刘凯   30      男   73.6          足球
4       N03   孙英   21      女   88.9         乒乓球
'''

#外连接
print(pd.merge(infos,course,how='outer',on='course_id'))
'''
  course_id name   age gender  marks course_name
0       N01   李明  25.0      男   85.4          排球
1       N01   田华  30.0      女   96.2          排球
2       N01   王三  21.0      女   55.9          排球
3       N02   刘凯  30.0      男   73.6          足球
4       N03   孙英  21.0      女   88.9         乒乓球
5       N04  NaN   NaN    NaN    NaN         羽毛球
6       N05  NaN   NaN    NaN    NaN          篮球
'''

9、统计函数

通过统计函数可以看出数据集的基本情况，包括分布的范围，稳定性，相关性、排名等等。

函数说明
df.describe()计算基本统计信息，如均值、标准差、最小值、最大值等
df.mean()计算每列的平均值
df.median()计算每列的中位数
df.mode()计算每列的众数
df.count()计算每列非缺失值的数量
df.sum()计算每列的和
df.max()计算每列的最大值
df.min()计算每列的最小值
df.std()计算每列的标准差
df.pct_change()每一个元素与上一个元素相比，变化了多少倍
df.cov()任意两列之间的协方差
df.corr()任意两列之间的相关系数
df.rank()对每一个元素排名，并返回排名值
(1) 常用统计函数
# 已知数据如下
import pandas as pd
import numpy as np
infos = [
  {"course_id":"N01","name": "李明", "age": 25, "gender": "男","marks": 85.4},
  {"course_id":"N01","name":np.nan,"age": 30, "gender": "女","marks": 96.2},
  {"course_id":"N02","name": "刘凯", "age": 30, "gender": "男","marks": 73.6},
  {"course_id":"N03","name": "孙英", "age": 21, "gender": "女","marks": 88.9},
  {"course_id":"N01","name": "王三", "age": 21, "gender": "女","marks": 55.9}
]
df = pd.DataFrame(infos)

#计算基本统计信息，如均值、标准差、最小值、最大值等。
print(df.describe())
'''
             age      marks
count   5.000000   5.000000
mean   25.400000  80.000000
std     4.505552  15.752619
min    21.000000  55.900000
25%    21.000000  73.600000
50%    25.000000  85.400000
75%    30.000000  88.900000
max    30.000000  96.200000
'''

#计算每列的平均值。
print(df.mean())
'''
age      25.4
marks    80.0
dtype: float64
'''

#计算每列的中位数。
print(df.median())
'''
age      25.0
marks    85.4
dtype: float64
'''

#计算每列的众数。
print(df.mode())
'''
  course_id name   age gender  marks
0       N01   刘凯  21.0      女   55.9
1       NaN   孙英  30.0    NaN   73.6
2       NaN   李明   NaN    NaN   85.4
3       NaN   王三   NaN    NaN   88.9
4       NaN    NaN   NaN    NaN   96.2
'''

#计算每列非缺失值的数量。
print(df.count())
'''
course_id    5
name         4
age          5
gender       5
marks        5
dtype: int64
'''

#计算每列的和。
print(df.sum())
'''
course_id    N01N01N02N03N01
name              李明刘凯孙英王三
age                      127
gender                 男女男女女
marks                    400
dtype: object
'''

#计算每列的最大值。
print(df.max())
'''
course_id     N03
name           田华
age            30
gender          男
marks        96.2
dtype: object
'''

#计算每列的最小值。
print(df.min())
'''
course_id     N01
name           刘凯
age            21
gender          女
marks        55.9
dtype: object
'''

#计算每列的标准差。
print(df.std())
'''
age       4.505552
marks    15.752619
dtype: float64
'''
(2) pct_change、cov、corr
# 已知数据如下
import pandas as pd
import numpy as np
df = [
  {"a":1,"b": 3,"c":5},
  {"a":2,"b": 9,"c":25},
  {"a":4,"b": 18,"c":56},
  {"a":16,"b": 27,"c":45}
]
df = pd.DataFrame(df)
print(df)
'''
    a   b   c
0   1   3   5
1   2   9  25
2   4  18  56
3  16  27  45
'''

#百分比函数
# 1.对行操作
print(df.pct_change())
'''
     a    b         c
0  NaN  NaN       NaN
1  1.0  2.0  4.000000
2  1.0  1.0  1.240000
3  3.0  0.5 -0.196429
'''
# 解释计算过程
'''
     a        b              c
0  NaN       NaN          NaN
1  (2-1)/1   (9-3)/3      (25-5)/5
2  (4-2)/2   (18-9)/9     (56-25)/25
3  (16-4)/4  (27-18)/18   (45-56)/56
'''

# 2.对列进行操作
print(df.pct_change(axis=1))
'''
    a       b         c
0 NaN  2.0000  0.666667
1 NaN  3.5000  1.777778
2 NaN  3.5000  2.111111
3 NaN  0.6875  0.666667
'''

#协方差
# 1.计算a与b之间的协方差值
print (df['a'].cov(df['b']))
'''
65.75
'''

# 2.计算所有列之间的协方差值
print (df.cov())
'''
           a       b           c
a  48.250000   65.75   81.916667
b  65.750000  110.25  198.750000
c  81.916667  198.75  506.916667
'''

#相关系数
# 1.计算2列的相关系数
print (df['b'].corr(df['c']))
'''
0.840716465224914
'''

# 2.计算所有列之间的相关系数
print (df.corr())
'''
          a         b         c
a  1.000000  0.901484  0.523788
b  0.901484  1.000000  0.840716
c  0.523788  0.840716  1.000000
'''
(3) rank
# 已知数据如下
import pandas as pd
import numpy as np
df = [
  {"a":1,"b": 3},
  {"a":2,"b": 9},
  {"a":4,"b": 18},
  {"a":16,"b": 27},
  {"a":2,"b":6}
]
df = pd.DataFrame(df)
print(df)
'''
    a   b
0   1   3
1   2   9
2   4  18
3  16  27
4   2   6
'''

#排名
print(df.rank())
'''
     a    b
0  1.0  1.0
1  2.5  3.0
2  4.0  4.0
3  5.0  5.0
4  2.5  2.0
'''

#将相同排名数据，设置为所在数组中数值的最大排名
print(df.rank(method="max"))
'''
     a    b
0  1.0  1.0
1  3.0  3.0
2  4.0  4.0
3  5.0  5.0
4  3.0  2.0
'''

#将相同排名数据，设置为所在数组中数值的最小排名
print(df.rank(method="min"))
'''
     a    b
0  1.0  2.0
1  1.0  2.0
2  1.0  2.0
3  1.0  2.0
4  1.0  2.0
'''

#对于相同排名数据，根据出现在数组中的顺序进行排名。
print(df.rank(method="first"))
'''
     a    b
0  1.0  2.0
1  1.0  2.0
2  1.0  2.0
3  1.0  2.0
4  1.0  2.0
'''

10、其他函数

上述函数基本上可以满足我们的日常对数据处理的需求，除此之外还有一些常用的辅助函数。

函数说明
df.reset_index()重置索引，原来的索引会作为数据列保留下来，如果不想保留就加上drop=True
df.rename()对行和列重命名
#已知数据如下
import pandas as pd
import numpy as np
df = pd.DataFrame([('刘凯', '21'), 
('孙英', '30'), 
('李明', '18'), 
('王三','26' )], 
index=['a', 'b', 'c', 'd'], 
columns=('name', 'age')) 
print(df)
'''
  name age
a   刘凯  21
b   孙英  30
c   李明  18
d   王三  26
'''

#重置索引
# 1.重置索引并保留原索引，不改变原始索引
print(df.reset_index())
'''
  index name age
0     a   刘凯  21
1     b   孙英  30
2     c   李明  18
3     d   王三  26
'''

# 2.重置索引并去掉原索引，不改变原始索引
print(df.reset_index(drop=True))
'''
  name age
0   刘凯  21
1   孙英  30
2   李明  18
3   王三  26
'''

#重命名
#对行和列重新命名
print (df.rename(columns={'name' : 'Name', 'age' : 'Age'},index = {'a' : '01', 'b' : '02', 'c' : '03', 'd':'04'}))
'''
   Name Age
01   刘凯  21
02   孙英  30
03   李明  18
04   王三  26
'''
酸菜鱼土豆大侠
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python数据攻略-数据分析常用的Pandas、NumPy进行数据清洗方法
Mr数据杨
05-15 7887
曾经有人问：“在数据分析中，有没有一种方式既直观又具有强大表达力？”答案是肯定的，而这正是 Python 的数据可视化工具如 pyecharts 所擅长的。在探究这个话题之前，有必要理解数据清洗和整理的重要性。例如家中的杂物堆积如山，要想在其中找到需要的物品，首先得做的就是清理和整理。同理在数据分析的世界里，一个整洁、有序的数据集是洞察力的源泉。这篇文章将深入探讨如何使用 Python 对 DataFrame 进行高效的数据清理，包括删除多余列、更改索引、重命名列和填充缺失值等。
pandas常用数据处理函数整理
every place is the center of the universe
05-31 795
pandas数据处理常用函数整理 参考：《joyfulpandas》 数据下载：https://www.heywhale.com/mw/dataset/625d2653e22b670017093353/file 分组 # 分组 # 1.分组模式及其对象 # 1.1分组的一般模式 # 想要实现分组操作，必须明确三个要素：分组一句、数据来源、操作及其返回结果 # df.groupby(分组依据)[数据来源].使用操作 df = pd.read_csv('data/learn_pandas.csv') # 按照性
Pandas常用函数整理
m0_48812571的博客
11-10 319
Pandas常用函数整理 一、生成数据表 导入应用模块： import pandas as pd Import numpy as np #numpy 通常搭配使用 （一）创建数据表 ①df=pd.DataFrame() #创建多维列表 ②df=pd.Series() #创建单行或单列数组 （二）读取数据表 ① excel：df=pd.read_excel('文件路径+文件名.xlsx') #编码错误则在文件路径前加r防转译(注意考虑：无表头的情况，默认第一行，否则设置表头) ②CSV..
Python数据清洗——Pandas
志存高远，亦须循序渐进
07-28 8500
文章目录一、Series的定义和使用1.1 Series索引标签的添加1.1.1 创建Series对象时添加1.1.2 建立好Series后用一个新的列表赋值到该Series的索引对象index中1.2 Series的名字1.2.1 创建Series对象的时候添加1.2.2 建立好Series后通过改变Series实例属性的方式添加1.2.3 Series索引名字的添加1.3 Pandas的Index对象1.4 Series的索引和切片1.4.1 数字下标去取1.4.2 标签名去取1.5 Series的.g
Pandas 数据清洗与整理(全)
qq_24937551的博客
03-31 765
# 数据清洗与整(全) # 1) 常见的数据清洗方法 # 2) 数据合并：多源数据的合并和连接 # 3) 数据重塑：针对层次化索引，学会 stack和 unstack # 4) 字符串处理：学会 DataFrame中字符串函数的使用 # 一，常见的数据清洗方法 # 1, 查看数据基本信息 # df.info() # df.describe() # df.head(n): 显示数据前n行,不指...
pandas常用函数，方法使用总结--[基于金融数据分析清洗]
whiskybug的博客
07-29 607
pandas常用函数，方法使用总结--[基于金融数据分析清洗]
【Python系列】（二）Pandas常用函数
xuyh_yuhan的博客
03-29 221
Pandas常用函数整理
超全整理100个 Pandas 函数，建议收藏！
cainiao_python的博客
12-28 2047
来源丨吊车尾学院人生苦短，快学Python！今天给大家整理了100个Pandas常用的函数。分别分为6类：统计汇总函数、数据清洗函数、数据筛选、绘图与元素级运算函数、时间序列函数和其他函数...
python划分数据集用pandas_python数据分析之pandas常用命令整理
weixin_42195569的博客
01-29 557
pandas 是基于NumPy的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。导入pandas库：import pandas as pd导入Series, DataFram...
Python pandas常用函数详解
12-25
本文研究的主要是pandas常用函数，具体介绍如下。 1 import语句 import pandas as pd import numpy as np import matplotlib.pyplot as plt import datetime import re 2 文件读取 df = pd.read_csv(path=’file....
Python数据清洗之Pandas与Numpy常用方法
10-28
适用刚开始学习数据清洗的人学习 适用有数据清洗基础，但是没有完整框概的人使用 里面包含了主流的常规用法
pandas常用函数
02-23
pandas常用函数：一维数组, 字典可以直接转化为series
Python pandas 数据清洗 基础教程
01-15
Python pandas 数据清洗 基础教程
十二届蓝桥杯Python组1月中/高级试题 第四题
走出那座山
05-09 469
输入一个正整数n，如果n为偶数，则计算1/2+1/4+1/6…+1/n的结果，如果n为奇数时，则计 算1/1+1/3+1/5…输出最后计算的结果。输入描述：输入一个正整数n 输出描述：输出最后计算的结果（最后结果保留两位小数，不要在每次除法时保留小数）输入为5，则计算1/1+1/3+1/5的结果，输出为1.53。例如：输入为4，则计算1/2+1/4的结果，输出为0.75。第四题（难度系数 4，30 个计分点）
继承与组合
g1446992400的博客
05-06 950
继承就是创建新类的一种方式，这个新类可以继承一个或者多个其他类的属性新的类如果有自己属性，那就叫派生如果属性不封的情况下，谁实例化得到的self 就去谁里面找如果属性封装的情况下 ，谁实例化得到的self 无效，只能在当前所在的类的名称空间里面找。
Python实战开发及案例分析（16）—— 遗传算法
最新发布
贾贾的博客
05-11 630
遗传算法（Genetic Algorithm, GA）是一种模拟自然选择和遗传学原理的搜索启发式算法。它们通常用于解决优化和搜索问题，基于“适者生存”的自然选择概念，通过选择、交叉（杂交）、变异操作在一系列迭代中逐步优化解决方案。
Python 自动化脚本系列：介绍
代码说，代码让世界更美好。
05-08 790
Python 自动化脚本系列：介绍
Kubernetes基础(二十九)-资源预留
sre救赎之路
05-05 948
如果还设置了对应的 --system-reserved-cgroup 和 --kube-reserved-cgroup参数，Pod能实际使用的资源上限不会改变（即kubepods.limit_in_bytes不变），但系统进程与kube进程也会受到资源上限的限制。比如某个节点的内存的allocatable为10Gi，有三个Pod（requests.memory=3Gi）已经调度到该节点上，那么第4个Pod就无法调度到该节点上，即使该Node上的空闲内存大于3Gi。
jupyter 数据整理
03-28
以下是一些常用的Jupyter数据整理技巧： 1. 导入数据：使用pandas库中的read_csv()函数、read_excel()函数等可以方便地导入各种格式的数据。 2. 数据清洗：使用pandas库中的dropna()函数、fillna()函数等可以方便...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值