Pandas基础
pandas介绍
安装方法: pip install pandas
- 名称:Python Data Analysis Library 或 pandas
- 介绍:是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型,提供了高效地操作大型数据集所需的工具。
- 定义1:pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
- 定义2:pandas是python里面分析结构化数据的工具集,基础是numpy,图像库是matplotlib
pandas核心数据结构
数据结构是计算机存储、组织数据的方式。 通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。
Pandas中有2个核心数据结构:
类型 | 说明 |
---|---|
Series | 一维数组 |
DataFrame | 二维数组 |
Series
Series可以理解为一个一维的数组,只是index名称可以自己改动。类似于定长的有序字典,有Index和 value。
- Series的创建
import pandas as pd
import numpy as np
# 创建一个空的系列
s = pd.Series()
# 从ndarray创建一个Series
data = np.array(['张三','李四','王五','赵柳'])
s = pd.Series(data)
s = pd.Series(data,index=['100','101','102','103'])
# 从字典创建一个Series
data = {'100' : '张三', '101' : '李四', '102' : '王五'}
s = pd.Series(data)
# 从标量创建一个Series
s = pd.Series(5, index=[0, 1, 2, 3])
- 访问Series中的数据:
"""
切片使用与列表、数组等一致
利用index标签 和下标均可以访问
注意: 利用index值进行切片 闭区间即包含结束的index
"""
# 使用索引检索元素
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(s[0], s[:3], s[-3:])
# 使用标签检索数据(注意:标签切片,头尾索引都包含)
print(s['a'], s[['a','c','d']],s["a":"c"])
- Series常用属性:
s1.values 将序列的数据作为ndarray返回
s1.index 将序列的索引作为ndarray返回
s1.dtype
s1.size
s1.ndim
s1.shape
pandas日期类型数据处理
# pandas识别的日期字符串格式
dates = pd.Series(['2011', '2011-02', '2011-03-01', '2011/04/01',
'2011/05/01 01:01:01', '01 Jun 2011',
'20110701','2011/8/1'])
# to_datetime() 转换日期数据类型
dates = pd.to_datetime(dates)
print(dates, dates.dtype, type(dates))
# 获取时间的某个日历字段的数值
print(dates.dt.day)
Series.dt提供了很多日期相关操作,如下:
Series.dt.year The year of the datetime. 年
Series.dt.month The month as January=1, December=12. 月
Series.dt.day The days of the datetime. 日
Series.dt.hour The hours of the datetime. 时
Series.dt.minute The minutes of the datetime. 分
Series.dt.second The seconds of the datetime. 秒
Series.dt.microsecond The microseconds of the datetime. 微秒
Series.dt.week The week ordinal of the year. 一年当中的第几周
Series.dt.weekofyear The week ordinal of the year.一年当中的第几周
Series.dt.dayofweek The day of the week with Monday=0, Sunday=6. 星期几
Series.dt.weekday The day of the week with Monday=0, Sunday=6.星期几
Series.dt.dayofyear The ordinal day of the year. 一年当中的第几天
Series.dt.quarter The quarter of the date. 季度
Series.dt.is_month_start Indicates whether the date is the first day of the month.
Series.dt.is_month_end Indicates whether the date is the last day of the month.
Series.dt.is_quarter_start Indicator for whether the date is the first day of a quarter.
Series.dt.is_quarter_end Indicator for whether the date is the last day of a quarter.
Series.dt.is_year_start Indicate whether the date is the first day of a year.
Series.dt.is_year_end Indicate whether the date is the last day of the year.
Series.dt.is_leap_year Boolean indicator if the date belongs to a leap year. 是不是闰年
Series.dt.days_in_month The number of days in the month. 一个月当中的第几天
日期运算:
# datetime日期运算
delta = dates - pd.to_datetime('1970-01-01')
print(delta, delta.dtype, type(delta))
# 把时间偏移量换算成天数
print(delta.dt.days) 在这只能timedelta64.dt.days 不能写其他的
通过指定周期和频率,使用date_range()
函数就可以创建日期序列。 默认情况下,频率是’D’。
import pandas as pd
# 以日为频率
datelist = pd.date_range('2019/08/21', periods=5)
print(datelist) # 21~25
# 以月为频率 ['2019-08-31', '2019-09-30', '2019-10-31', '2019-11-30','2019-12-31'] # 不能保证每个月都有你要生成的日期,统一拿到当前月的最后一天
datelist = pd.date_range('2019/08/21', periods=5,freq='M')
print(datelist)
# 构建某个区间的时间序列
start = pd.datetime(2017, 11, 1)
end = pd.datetime(2017, 11, 5)
dates = pd.date_range(start, end)
print(dates)
bdate_range()
用来表示商业日期范围,不同于date_range()
,它不包括星期六和星期天。
import pandas as pd
datelist = pd.bdate_range('2011/11/03', periods=5)
print(datelist)
datelist = pd.date_range('2019/08/21', periods=5,freq ='B')
print(datelist)
DataFrame
DataFrame是一个类似于表格(有行有列)的数据类型,可以理解为一个二维数组,索引有两个维度(行级索引,列级索引),可更改。DataFrame具有以下特点:
- 列和列之间可以是不同的类型 :不同的列的数据类型可以不同
- 大小可变 (扩容)
- 标记轴(行级索引 和 列级索引)
- 针对行与列进行轴向统计(水平,垂直)
pandas的创建
import pandas as pd
# 创建一个空的DataFrame
df = pd.DataFrame()
print(df)
# 从列表创建DataFrame
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])# 列标签
print(df)
# 指定数据类型
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print(df)
# 从字典来创建DataFrame
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['s1','s2','s3','s4'])
print(df)
# 使用列表两列的个数必须相同,使用Series两列不同则可以自动填充NaN
data = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
print(df)
DataFrame常用属性
属性或方法 | 编号 | 描述 |
---|---|---|
axes |
1 | 返回 行/列 标签(index)列表。 |
columns |
2 | 返回列标签 |
index |
3 | 返回行标签 |
dtypes |
4 | 返回对象的数据类型(dtype )。 |
empty |
5 | 如果系列为空,则返回True 。 |
ndim |
6 | 返回底层数据的维数,默认定义:2 。 |
size |
7 | 返回基础数据中的元素数。 |
values |
8 | 将系列作为ndarray 返回。 |
head(n) |
9 | 返回前n 行。n默认为5 |
tail(n) |
10 | 返回最后n 行。n默认为5 |
实例代码:
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['s1','s2','s3','s4'])
df['score']=pd.Series([90, 80, 70, 60], index=['s1','s2','s3','s4'])
print(df)
print(df.axes)
print(df['Age'].dtype)
print(df.empty)
print(df.ndim)
print(df.size)
print(df.values)
print(df.head(3)) # df的前三行
print(df.tail(3)) # df的后三行
核心数据结构操作
行和列的增删改查操作:一行一样本,一列一特征
列访问
DataFrame的单列数据为一个Series。根据DataFrame的定义可以 知晓DataFrame是一个带有标签的二维数组,每个标签相当每一列的列名。
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
'three' : pd.Series([1, 3, 4], index=['a', 'c', 'd'])}
df = pd.DataFrame(d)
df['one']
df[['one','two']]
df[df.columns[:2]]
列添加
DataFrame添加一列的方法非常简单,只需要新建一个列索引。并对该索引下的数据进行赋值操作即可。
import pandas as pd
df['four']=pd.Series([90, 80, 70, 60], index=['a', 'b', 'c', 'd'])
print(df)
注意:
创建新的列时,要给出原有dataframe的index
列删除
删除某列数据需要用到pandas提供的方法pop,pop方法的用法如下:
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']),
'three' : pd.Series([10, 20, 30], index=['a', 'b', 'c'])}
df = pd.DataFrame(d)
print("dataframe is:")
print(df)
# 删除一列: one
del(df['one'])
del df['one']
print(df)
#如果想要删除多列呢?
#删除多列 drop 轴向axis=1是必须给的 默认axis=0删除行的 ,不会修改原数据
# inplace=False 不修改原数据
df2 = df.drop(['one','four'],axis=1,inplace=True)
print(df2)
行访问
如果只是需要访问DataFrame某几行数据的实现方式则采用数组的选取方式,使用 “:” 即可:
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df[2:4])
loc是针对DataFrame索引名称的切片方法。loc方法使用方法如下:
只支持索引名称,不支持索引位置
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df.loc['b'])
print(df.loc[['a', 'b']])
iloc和loc区别是iloc接收的必须是行索引和列索引的位置。iloc方法的使用方法如下:
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df.iloc[2])
print(df.iloc[[2, 3]])
行添加
import pandas as pd
df = pd.DataFrame([['zs', 12], ['ls', 4]], columns = ['Name','Age'])
df2 = pd.DataFrame([['ww', 16], ['zl', 8]], columns = ['Name','Age'])
df = df.append(df2)
print(df)
行删除
使用索引标签从DataFrame中删除或删除行。 如果标签重复,则会删除多行。
import pandas as pd
df = pd.DataFrame([['zs', 12], ['ls', 4]], columns = ['Name','Age'])
df2 = pd.DataFrame([['ww', 16], ['zl', 8]], columns = ['Name','Age'])
df = df.append(df2)
# 删除index为0的行
df = df.drop(0)
print(df)
数据加载
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TkTMQI8d-1661341007888)(.\images\IOtools.png)]
读HTML中的内容,要求:在HTML中必须要有table标签
处理普通文本
读取文本:read_csv() read_table()
csv文件 逗号分隔符文件 数据与数据之间使用逗号分隔
方法参数 | 参数解释 |
---|---|
filepath_or_buffer | 文件路径 |
sep | 列之间的分隔符。read_csv()默认为为’,‘, read_table()默认为’\t’ |
header | 默认将首行设为列名。header=None 时应手动给出列名。 |
names |
header=None 时设置此字段使用列表初始化列名。 |
index_col | 将某一列作为行级索引。若使用列表,则设置复合索引。 |
usecols | 选择读取文件中的某些列。设置为为相应列的索引列表。 |
skiprows | 跳过行。可选择跳过前n行或给出跳过的行索引列表。 |
encoding | 编码。 |
写入文本:dataFrame.to_csv()
方法参数 | 参数解释 |
---|---|
filepath_or_buffer | 文件路径 |
sep | 列之间的分隔符。默认为’,’ |
na_rep | 写入文件时dataFrame中缺失值的内容。默认空字符串。 |
columns | 定义需要写入文件的列。 |
header | 是否需要写入表头。默认为True。 |
index | 会否需要写入行索引。默认为True。 |
encoding | 编码。 |
案例:读取电信数据集。
pd.read_csv('../data/CustomerSurvival.csv', header=None, index_col=0)
处理JSON
读取json:read_json()
方法参数 | 参数解释 |
---|---|
filepath_or_buffer | 文件路径 |
encoding | 编码。 |
案例:读取电影评分数据:
pd.read_json('../data/ratings.json')
写入json:to_json()
方法参数 | 参数解释 |
---|---|
filepath_or_buffer | 文件路径; 若设置为None,则返回json字符串 |
orient | 设置面向输出格式:[‘records’, ‘index’, ‘columns’, ‘values’] |
force_ascii | 强制编码字符串为 ASCII,默认为 True |
案例:
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['s1','s2','s3','s4'])
df.to_json(orient='records')
读取excel文件内容:read_excel()
其他文件读取方法参见:https://www.pypandas.cn/docs/user_guide/io.html
数值型描述统计
算数平均值
$S = [s_1, s_2, …, s_n] $
m e a n = ( s 1 + s 2 + . . . + s n ) n mean = \frac{(s_1 + s_2 + ... + s_n) }{n} mean=n(s1+s2+...+sn)
算数平均值表示对真值的无偏估计。
m = np.mean(array)
m = array.mean()
m = df.mean(axis=0) # 每列的均值
案例:针对电影评分数据做均值分析:
mean = ratings['John Carson'].mean()
mean = np.mean(ratings['John Carson'])
means = ratings.mean(axis=1)
加权平均值
求平均值时,考虑不同样本的重要性,可以为不同的样本赋予不同的权重。
样本: S = [ s 1 , s 2 , s 3 . . . s n ] S = [s_1, s_2, s_3 ... s_n] S=[s1,s2,s3...sn]
权重: W = [ w 1 , w 2 , w 3 . . . w n ] W =[w_1, w_2, w_3 ... w_n] W=[w1,w2,w3...wn]
加权平均值:
a
=
s
1
w
1
+
s
2
w
2
+
.
.
.
+
s
n
w
n
w
1
+
w
2
+
.
.
.
+
w
n
a = \frac{s_1w_1 + s_2w_2 + ... + s_nw_n}{w_1+w_2+...+w_n}
a=w1+w2+...+wns1w1+s2w2+...+snwn
代码实现:
a = np.average(array, weights=volumes)
案例:自定义权重,求加权平均。
# 加权均值
w = np.array([3,1,1,1,1,1,1])
np.average(ratings.loc['Inception'], weights=w)
最值
np.max() / np.min() / np.ptp(): 返回一个数组中最大值/最小值/极差(最大值减最小值)
import numpy as np
# 产生9个介于[10, 100)区间的随机数
a = np.random.randint(10, 100, 9)
print(a)
print(np.max(a), np.min(a), np.ptp(a))
np.argmax() np.argmin(): 返回一个数组中最大/最小元素的下标
在np中,使用argmax获取到最大值的下标
print(np.argmax(a), np.argmin(a))
在pandas中,使用idxmax获取到最大值的下标
print(series.idxmax(), series.idxmin())
print(dataframe.idxmax(), dataframe.idxmin())
np.maximum() np.minimum(): 将两个同维数组中对应元素中最大/最小元素构成一个新的数组
print(np.maximum(a, b), np.minimum(a, b), sep='\n')
# 1 2 3 4 5 6 7 8 9
# 9 8 7 6 5 4 3 2 1
# 9 8 7 6 5 6 7 8 9 <--maximum
中位数
将多个样本按照大小排序,取中间位置的元素。
若样本数量为奇数,中位数为最中间的元素
[ 1 , 2000 , 3000 , 4000 , 10000000 ] [1, 2000, 3000, 4000, 10000000] [1,2000,3000,4000,10000000]
若样本数量为偶数,中位数为最中间的两个元素的平均值
[ 1 , 2000 , 3000 , 4000 , 5000 , 10000000 ] [1,2000,3000,4000,5000,10000000] [1,2000,3000,4000,5000,10000000]
salary = [1,2000,3000,4000,100000000] 某公司所有员工薪资 求该公司平均薪资
# np.median() 中位数
median = np.median(salary)
print(median)
四分位数 (连续性数据)
所谓四分位数,即把数值由小到大排列并分成四等份,处于三个分割点位置的数值就是四分位数。
- 第1四分位数 (Q1),又称“较小四分位数”,等于该样本中所有数值由小到大排列后第25%的数字。
- 第2四分位数 (Q2),又称“中位数”,等于该样本中所有数值由小到大排列后第50%的数字。
- 第3四分位数 (Q3),又称“较大四分位数”,等于该样本中所有数值由小到大排列后第75%的数字。
第3四分位数与第1四分位数的差距又称四分位距(InterQuartile Range,IQR)
ary = np.array([1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,5,5,5])
s = pd.Series(ary)
s.quantile([.0, .25, .5, .75, 1.])
标准差
样本(sample):
S
=
[
s
1
,
s
2
,
s
3
,
.
.
.
,
s
n
]
S = [s_1, s_2, s_3, ..., s_n]
S=[s1,s2,s3,...,sn]
平均值:
m
=
s
1
+
s
2
+
s
3
+
.
.
.
+
s
n
n
m = \frac{s_1 + s_2 + s_3 + ... + s_n}{n}
m=ns1+s2+s3+...+sn
离差(deviation):表示某组数据距离某个中心点的偏离程度
D
=
[
d
1
,
d
2
,
d
3
,
.
.
.
,
d
n
]
d
i
=
S
i
−
m
D = [d_1, d_2, d_3, ..., d_n]\\ d_i = S_i-m
D=[d1,d2,d3,...,dn]di=Si−m
离差方:
Q
=
[
q
1
,
q
2
,
q
3
,
.
.
.
,
q
n
]
q
i
=
d
i
2
Q = [q_1, q_2, q_3, ..., q_n]\\ q_i=d_i^2
Q=[q1,q2,q3,...,qn]qi=di2
总体方差(variance):
v
=
(
q
1
+
q
2
+
q
3
+
.
.
.
+
q
n
)
n
v = \frac{(q_1+q_2+q_3 + ... + q_n)}{n}
v=n(q1+q2+q3+...+qn)
方差越大,震荡越剧烈
方差越小,震荡越平缓
总体标准差(standard deviation):
s
=
v
s = \sqrt{v}
s=v
样本方差:
v
′
=
(
q
1
+
q
2
+
q
3
+
.
.
.
+
q
n
)
n
−
1
v' = \frac{(q_1+q_2+q_3 + ... + q_n)}{n-1}
v′=n−1(q1+q2+q3+...+qn)
其中,n-1称之为“贝塞尔校正”,这是因为抽取样本时候,采集的样本主要是落在中心值附近,那么通过这些样本计算的方差会小于等于对总体数据集方差的无偏估计值。为了能弥补这方面的缺陷,那么我们把公式的n改为n-1,以此来提高方差的数值。称为贝塞尔校正系数。
样本标准差:
s
′
=
v
′
s' = \sqrt{v'}
s′=v′
案例: 根据标准差理论,针对评分数据进行方差分析:
ratings.std(axis=0) # 样本标准差
np.std() #总体标准差
类别型特征的描述性统计
-
描述类别型特征的分布状况,可以使用频数统计表。pandas库中实现频数统计的方法为value_counts。
-
describe方法除了支持传统数值型以外,还能够支持对数据进行描述性统计,四个统计量分别为列非空元素的数目,类别的数目,数目最多的类别,数目最多类别的数目
频数与众数(离散数据)
频数指一组数据中各离散值出现的次数,而众数则是指一组数据中出现次数最多的值。
cars = np.array(['bmw', 'bmw', 'bz', 'audi', 'bz', 'bmw'])
cars = pd.Series(cars)
cars.value_counts() #频数
cars.mode() #众数
Pandas数据预处理
apply函数
pandas提供了apply函数方便的处理Series与DataFrame;apply函数支持逐一处理数据集中的每个元素都会执行一次目标函数,把返回值存入结果集中。
# series.apply()
ary = np.array(['80公斤','83公斤','78公斤','74公斤','84公斤'])
s = pd.Series(ary)
def func(x):
return x[:2]
s.apply(func)
# dataframe.apply()
def func(x):
# pd.isna()检测数组对象缺失值
x[pd.isna(x)] = x.mean()
return x
ratings.apply(func, axis=1)
排序
Pandas有两种排序方式,它们分别是按标签与按实际值排序。
import numpy as np
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack','Lee','David','Gasper','Betina','Andres']),
'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])}
unsorted_df = pd.DataFrame(d)
按标签(行)排序
使用sort_index()
方法,通过传递axis
参数和排序顺序,可以对DataFrame
进行排序。 默认情况下,按照升序对行标签进行排序。
# 按照行标进行排序
sorted_df=unsorted_df.sort_index()
print (sorted_df)
# 控制排序顺序
sorted_df = unsorted_df.sort_index(ascending=False)
print (sorted_df)
按标签(列)排序
# 按照列标签进行排序
sorted_df=unsorted_df.sort_index(axis=1)
print (sorted_df)
按某列值排序
像索引排序一样,sort_values()
是按值排序的方法。它接受一个by
参数,它将使用要与其排序值的DataFrame
的列名称。
sorted_df = unsorted_df.sort_values(by='Age')
print (sorted_df)
# 先按Age进行升序排序,然后按Rating降序排序
sorted_df = unsorted_df.sort_values(by=['Age', 'Rating'], ascending=[True, False])
print (sorted_df)
数据合并
concat
concat函数是在pandas的方法,可以根据不同的轴合并数据集。
r = pd.concat(datas, # 数据源 多个数据集使用列表[a1,a2,a3,,]
axis=0, # 纵向合并
join='outer', # 默认外连接,保留所有表的信息
ignore_index=False, # 是否产生新的行索引
keys=['x', 'y', 'z']) # 保留数据来源信息
纵向合并:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-032cCnvk-1661341007889)(/images/concat_0.png)]
横向合并:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cG7k3xPh-1661341007889)(/images/concat_1.png)]
merge & join
panda具有全功能、高性能的内存连接操作,与SQL之类的关系数据库非常相似。与其他开源实现相比,这些方法的性能要好得多(在某些情况下要好一个数量级以上)
pandas提供了merge函数实现高效的内存链接操作:
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,left_index=False, right_index=False)
参数名称 | 说明 |
---|---|
left | 接收DataFrame或Series。表示要添加的新数据。无默认。 |
right | 接收DataFrame或Series。表示要添加的新数据。无默认。 |
how | 接收inner,outer,left,right。表示数据的连接方式。默认为inner。 |
on | 接收string或sequence。表示外键字段名。默认为None。 |
left_on | 接收string或sequence。关联操作时左表中的关联字段名(可以是一个字段,也可以是多个字段,多个字段用列表表示)。 |
right_on | 接收string或sequence。关联操作时右表中的关联字段名(可以是一个字段,也可以是多个字段,多个字段用列表表示)。 |
left_index | 接收boolean。表示是否将left参数接收数据的index作为连接主键。默认为False。 |
right_index | 接收boolean。表示是否将right参数接收数据的index作为连接主键。默认为False。 |
sort | 接收boolean。表示是否根据连接键对合并后的数据进行排序。默认为False。 |
suffixes | 接收接收tuple。表示用于追加到left和right参数接收数据重叠列名的尾缀默认为('_x', '_y') 。 |
左表中 : name
右表中 : name
合并两个DataFrame:
import pandas as pd
left = pd.DataFrame({
'student_id':[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],
'student_name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung', 'Billy', 'Brian', 'Bran', 'Bryce', 'Betty', 'Emma', 'Marry', 'Allen', 'Jean', 'Rose', 'David', 'Tom', 'Jack', 'Daniel', 'Andrew'],
'class_id':[1,1,1,2,2,2,3,3,3,4,1,1,1,2,2,2,3,3,3,2],
'gender':['M', 'M', 'F', 'F', 'M', 'M', 'F', 'F', 'M', 'M', 'F', 'F', 'M', 'M', 'F', 'F', 'M', 'M', 'F', 'F'],
'age':[20,21,22,20,21,22,23,20,21,22,20,21,22,23,20,21,22,20,21,22],
'score':[98,74,67,38,65,29,32,34,85,64,52,38,26,89,68,46,32,78,79,87]})
right = pd.DataFrame(
{'class_id':[1,2,3,5],
'class_name': ['ClassA', 'ClassB', 'ClassC', 'ClassE']})
# 合并两个DataFrame
data = pd.merge(left,right)
print(data)
其他合并方法同数据库相同:
合并方法 | SQL等效 | 描述 |
---|---|---|
left |
LEFT OUTER JOIN |
使用左侧对象的键 |
right |
RIGHT OUTER JOIN |
使用右侧对象的键 |
outer |
FULL OUTER JOIN |
使用键的联合 |
inner |
INNER JOIN |
使用键的交集 |
实验:
# 合并两个DataFrame (左连接)
rs = pd.merge(left,right,on='subject_id', how='right')
print(rs)
# 合并两个DataFrame (左连接)
rs = pd.merge(left,right,on='subject_id', how='outer')
print(rs)
# 合并两个DataFrame (左连接)
rs = pd.merge(left,right,on='subject_id', how='inner')
print(rs)
79,87]})
right = pd.DataFrame(
{‘class_id’:[1,2,3,5],
‘class_name’: [‘ClassA’, ‘ClassB’, ‘ClassC’, ‘ClassE’]})
合并两个DataFrame
data = pd.merge(left,right)
print(data)
其他合并方法同数据库相同:
| 合并方法 | SQL等效 | 描述 |
| -------- | ------------------ | ---------------- |
| `left` | `LEFT OUTER JOIN` | 使用左侧对象的键 |
| `right` | `RIGHT OUTER JOIN` | 使用右侧对象的键 |
| `outer` | `FULL OUTER JOIN` | 使用键的联合 |
| `inner` | `INNER JOIN` | 使用键的交集 |
实验:
```python
# 合并两个DataFrame (左连接)
rs = pd.merge(left,right,on='subject_id', how='right')
print(rs)
# 合并两个DataFrame (左连接)
rs = pd.merge(left,right,on='subject_id', how='outer')
print(rs)
# 合并两个DataFrame (左连接)
rs = pd.merge(left,right,on='subject_id', how='inner')
print(rs)
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。