pandas相关笔记

最新推荐文章于 2024-10-06 21:18:37 发布
最新推荐文章于 2024-10-06 21:18:37 发布
阅读量669 收藏 13
点赞数 12
文章标签： pandas 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80780428/article/details/140584844
版权

Pandas

Pandas的优势

1、增强图表可读性
2、便捷的数据处理能力
3、读取文件方便
4、封装了Matplotlib、Numpy的画图和计算
Pandas一共有三种数据结构：
1、Series：一个类似于一维数组的数据结构，由数据和索引两部分构成。
2、DataFrame：：二维的表格型数据结构有行索引，又有列索引
3、Multilndex：三维的数据结构

Series

# Series的创建
import pandas as pd 
pd.Series(data=None, index=None,dtype=None)
# 参数：
# data：传入的数据，可以是ndarray、list等
# index：索引，必须是唯一的，且与数据的长度相等。如果没有传入索引参数，则默认会自动创建一个从0-N的整数索引。
# dtype：数据的类型
import pandas as pd
import numpy as np
# # 1.通过已有数据创建，指定内容，默认索引，即从0开始
# pd.Series(np.arange(3))
​
# 2.通过已有数据创建，指定内容，指定索引
pd.Series(np.arange(3),[1,3,4])
​
# 3.通过字典创建数据，这样索引就会被设置为key值
pd.Series({'name':'小明','gender':'男','age':'20'}

# index和values属性
a=pd.Series({'name':'小明','gender':'男','age':'20'})
a.index
a.values

DataFrame

# 行索引，表明不同行，横向索引，叫index
# 列索引，表名不同列，纵向索引，叫columns
​
# 创建DataFrame
import pandas as pd
pd.DataFrame(data=None, index=None, columns=None)
# index：行标签。如果没有传入索引参数，则默认会自动创建一个从0-N的整数索引。
# columns：列标签。如果没有传入索引参数，则默认会自动创建一个从0-N的整数索引
import pandas as pd
# 创建成绩，取值范围0-100，生成3行5列
score=np.random.randint(0, 100, (3, 6))
index_label=['小王','小张','小明']
columns_label=['语文','数学','英语','政治','历史','地理']
pd.DataFrame(data=score,index=index_label,columns=columns_label)

</style>

​

语文数学英语政治历史地理
小王9043372354
小张374876906919
小明60652556885

​

</div>

# 属性
# .shape：数组形状
# .index：行索引值
# .columns：列索引值
# .values：array的值，即将二维数组所有数据打印
# head()：显示前n行，默认显示全部
# tail()：显示后n行，默认显示全部
# .T：转置
​
score=np.random.randint(0, 100, (3, 6))
index_label=['小王','小张','小明']
columns_label=['语文','数学','英语','政治','历史','地理']
a=pd.DataFrame(data=score,index=index_label,columns=columns_label)
# # 查看数组形状
# a.shape
​
# # 查看行索引
# a.index
​
# # 查看列索引
# a.columns
​
# # 查看array的值
# a.values
​
# # 显示部分行
# # 显示前n行
# a.head(1)
​
# # 显示后n行
# a.tail(1)
​
# 转置
a.T
小王小张小明
语文113079
数学18014
英语524596
政治212799
历史73468
地理90276

# 索引修改
# 要修改索引必须全部都修改
stu = ["学生_" + str(i) for i in range(score_df.shape[0])]
​
# 必须整体全部修改
data.index = stu
​
# 错误修改方式
data.index[3] = '学生_3'

重设索引—reset_index(drop=False)

设置新的下标索引
drop:默认为False，不删除原来索引，而是在原来列索引前新建一列；如果为True，则是删除原来的索引值

将某列设置为新的索引—set_index(keys, drop=True)

keys : 列索引名成或者列索引名称的列表
drop: boolean, default True.当做新的索引，删除原来的列，False则保留原来的列
若keys值设置多个，则表示多个索引，那么就会变为一个具有MultiIndex的DataFrame。

Malutindex

# 创建Multiindex
import pandas as pd
pd.MultiIndex.from_arrays(levels,names)
# levels：每个level的元组值
# names:levels的名称
arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
a=pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
# a
a.levels

操作与运算

一、基本操作
    1、索引
    2、赋值
    3、排序
        （1）Series排序
        （2)DataFrame排序
二、DataFrame运算
    1、算术运算
    2、逻辑运算
    3、统计运算
        （1）、综合统计函数
        （2）、统计函数
        （3）、累积统计函数
        （4）自定义运算

# 索引
# 直接索引—先列后行
# loc—先行后列，需要通过索引的字符串进行获取
# iloc—先行后列，通过下标进行索引
​
score=np.random.randint(0, 100, (3, 6))
index_label=['小王','小张','小明']
columns_label=['语文','数学','英语','政治','历史','地理']
a=pd.DataFrame(data=score,index=index_label,columns=columns_label)
# # 1.获取'语文'列'小张'和'小王'行的数据
# a['语文']['小王':'小张']
​
# # 2.获取'小张'和'小王'行'语文'列的数据
# a.loc['小王':'小张']['语文']
​
# 3.获取前三行前三列的数据
a.iloc[:3, :3]
​
# # 4获取第一行到第三行语文、数学、英语的成绩(同3相同)
# a.loc[a.index[0:3],['语文','数学','英语']]
# a.iloc[0:3,a.columns.get_indexer(['语文','数学','英语'])]
​

# 赋值
# 对DataFrame当中的某一列进行重新赋值（若该列不存在，则会在所有列最后面新建该列并赋值）
# 将'语文'列所有值都赋值1
a['语文']=1
# 因为没有‘总分’列，所以会在所有列后新建一列并复制
a['总分']=[1,2,3]
a
语文数学英语政治历史地理总分
小王149637020701
小张115518041962
小明133276313

# 排序
# 排序可以对索引排序，也可以对内容进行排序
​
# ①Series排序
# Series排序时，只有一列，不需要参数
​
# # .sort_index()：对索引进行排序
# a=pd.Series([1,3,5,2,4,6],index=[11,18,13,20,15,16])
# b=a.sort_index()
# b
​
# # .sort_values(ascending=True)：对内容值进行排序
# a=pd.Series([1,3,5,2,4,6],index=[11,18,13,20,15,16])
# b=a.sort_values()
# b


# ②DataFrame排序
score=np.array([[98, 89, 33],
       [90, 28, 66],
       [52, 32, 79],
       [92, 58, 81]])
index_label=np.array(['No._%d'%i for i in range(0,4)])
​
# 即index的值为No.0,No.1,No.2,No.3
columns_label=np.array(['语文','数学','英语'])
a=pd.DataFrame(score,index_label,columns_label)
​
# # .sort_index(ascending=True,inplace=True)：对索引进行排序
# # ascending：False:降序、True:升序，默认升序
# # inplace：是否是对原数据进行操作，True则会改变原数据，默认False，需要新建变量保存
# # 以index进行排名
# a.sort_index(ascending=False)
​
# # .sort_values(by=, ascending=True)：对内容值进行排序
# # by：指定排序参考的键
# # ascending：False:降序、True:升序，默认升序
# # 以'语文'分数进行排名
# a.sort_values('语文')
语文数学英语
No._2523279
No._1902866
No._3925881
No._0988933

# DataFrame运算
# 1、算术运算
​
score=np.array([[50, 50, 50],
       [90, 28, 66],
       [52, 32, 79],
       [92, 58, 81]])
index_label=np.array(['No._%d'%i for i in range(0,4)])
# 即index的值为No.4,No.3,No.2,No.1
columns_label=np.array(['语文','数学','英语'])
a=pd.DataFrame(score,index_label,columns_label)
所有人的语文分数加上自己的数学分数
a['语文'].add(a['数学'])
# 所有人语文分数减2分
a['语文'].sub(2)

# 2、逻辑运算

# # 判断语文成绩及格的
# a['语文']>60
# # ①a[判断语句].head()  筛选为True的数据
# a[a['语文']>60].head()
# # ②a.query(判断语句).head()    更加方便简单
# a.query('语文>60').head()

# # 判断语文成绩在50-80之间
# (a['语文']>50)&(a['语文']<80)
# ③a[a[判断语句].isin(values)]    判断是否为一组数据中的一个
a[(a['语文']>50)&(a['语文']<80)].head()
a.query('语文>50&语文<80').head()

# # 判断是否有人分数为[50,52,90]
# a[a['语文'].isin([50,52,90])].head()
语文数学英语
No._2523279

# 3、统计运算
# 通过统计运算，可以得出比如min(最小值), max(最大值), mean(平均值), 
# median(中位数), var(方差), std(标准差),mode(众数)等等结果
x=a['语文'].max()
x
x=a['数学'].min()
x

①综合统计函数—对象.describe()
describe(): 综合统计函数，可以同时返回数据中的数据量、均值、标准差、最小值、最大值，以及25%、50%、75%分位数。
②统计函数
函数  作用
.count()    数量
.sum()  所有数据的和
.mean() 数据的平均值
.min()  最小值
.max()  最大值
.mode() 众数
.median()   中位数
.abs()  绝对值
.std()  标准差
.var()  方差
.idxmax()   最大值索引
.idxmin()   最小值索引
③累积统计函数
函数  作用
.cumsum()   计算前n个数的和
.cummax()   计算前n个数的最大值
.cummin()   计算前n个数的最小值
.cumprod()  计算前n个数的积
④自定义运算—apply(func, axis=0)
func:自定义函数
axis=0:默认是列，axis=1为行进行运算

Pandas绘图

1.Series画图—pandas.Series.plot()

# 加入数据，创建DataFrame数组
​
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
​
# 设置中文字体，确保 matplotlib 能够显示中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 指定默认字体为黑体
plt.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
​
# 加入数据，创建 Series 对象
score=np.array([160, 175, 170,180])
index_label=['小王','小张','小明','小光']
a=pd.Series(data=score,index=index_label)
​
# 创建画布
plt.figure(figsize=(5,5), dpi=100)
# 绘制图像
a.plot()
# 设置x轴y轴刻度
plt.xticks(range(0,len(index_label)),index_label)
plt.yticks(range(150,200,10))
# 添加x轴、y轴描述信息及标题
plt.xlabel('学生')
plt.ylabel('身高cm')
plt.title('学生身高表', fontsize=20)
# 添加网格
plt.grid(True, linestyle='--', alpha=0.5)
​
# 显示图像
plt.show()
​

2.DataFrame画图—pandas.DataFrame.plot()

# Index值为x轴，数值为y轴，columns值为图像名
# 加入数据，创建DataFrame数组
​
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
​
# 设置中文字体，确保 matplotlib 能够显示中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 指定默认字体为黑体
plt.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
​
score=np.array([[60, 60, 60],
       [90, 28, 66],
       [52, 32, 79],
       [92, 58, 81]])
index_label=['小王','小张','小明','小光']
columns_label=['语文','数学','英语']
a=pd.DataFrame(data=score,index=index_label,columns=columns_label)
b=a.T
# 创建画布
plt.figure(figsize=(5,5), dpi=100)
# 绘制图像
b.plot()
# 设置x轴y轴刻度
plt.xticks(range(0,len(columns_label)),columns_label)
plt.yticks(range(0,101,10))
# 添加x轴、y轴描述信息及标题
plt.xlabel('科目')
plt.ylabel('分数')
plt.title('学生成绩表', fontsize=20)
# 添加网格
plt.grid(True, linestyle='--', alpha=0.5)
# 显示图像
plt.show()

文件读取与存储

1、CSV

# (1)读取文件—read_csv
# pandas.read_csv(filepath_or_buffer, sep =',', usecols )
# filepath_or_buffer:文件路径
# sep :分隔符，默认用","隔开
# usecols:指定读取的列名，列表形式
​
# 读取文件,并且指定只获取'语文', '数学'列数据
data = pd.read_csv(r"C:\Users\Q\Student_score_test.csv", usecols=['语文', '数学','英语'])
data
​
语文数学英语
0小王6060
1小张9028
2小明5232
3小光9258

# (2)保存读取的文件—to_csv
# DataFrame.to_csv(path_or_buf=None, sep=',’, columns=None, header=True, index=True, mode='w', encoding=None)
# path_or_buf :文件路径
# sep :分隔符，默认用","隔开
# columns :选择需要的列索引
# header :boolean or list of string, default True,是否写进列索引值
# index:是否写进行索引
# mode:‘w’：重写, ‘a’ 追加
# 选取2行数据保存到Student_score_test.csv文件中,便于观察
data[:10].to_csv(r"C:\Users\Q\Student_score_test.csv", columns=['语文', '数学'])
​
# 将语文=100,数学=100,英语=100追加到Student_score_test.csv文件
a=pd.DataFrame(data=[[100,100,100]],index=[4],columns=['语文','数学','英语'])
a.to_csv(r"C:\Users\Q\Student_score_test.csv",header=False,mode='a')
​

2、HDF5

read_hdf与to_hdf
    pandas.read_hdf(path_or_buf，key =None，** kwargs)
    DataFrame.to_hdf(path_or_buf, key, **kwargs)
path_or_buffer:文件路径
key:读取的键

3、JSON

read_json与to_json：
    pandas.read_json(path_or_buf=None, orient=None, typ='frame', lines=False)
       path_or_buf：文件路径或者json格式的字符串。
       orient : 存储的json形式，{‘split’,’records’,’index’,’columns’,’values’} 
           split :  dict like {index -> [index], columns -> [columns], data -> [values]}有索引，列字段和数据构成的json格式。key名称只能是index,columns和data。
           records: list like [{column -> value}, … , {column -> value}]成员为字典的列表。
           index : dict like {index -> {column -> value}}以索引为key,以列字段构成的字典为键值
           columns: dict like {column -> {index -> value}}这种处理的就是以列为键，对应一个值字典的对象。这个字典对象以索引为键,以值为键值构成的json字符串。
​
           values : 一个嵌套的列表
        lines : boolean, default False，按照每行读取json对象  
        typ : default ‘frame’， 指定转换成的对象类型series或者dataframe
    DataFrame.to_json(path_or_buf=None, orient=None, lines=False)
        lines:一个对象存储为一行

高级处理

1、缺失值处理

当该数据并无数据时，需要使用缺失值进行标记，并对这些缺失值进行处理
获取缺失值的标记方式有NaN或者其他标记方式)
# （1）、判断数据中是否由NaN
import pandas as pd
​
# 读取学生表信息
data=pd.read_csv(r"C:\Users\Q\Student_score_test.csv")
print(pd.isnull(data))  # 是否存在NaN
print()
print(pd.notnull(data)) #是否不存在NaN
       语文     数学     英语
小王  False  False  False
小张  False  False  False
小明  False  False  False
小光  False  False  False

      语文    数学    英语
小王  True  True  True
小张  True  True  True
小明  True  True  True
小光  True  True  True

# 2、若存在缺失值

# ①NaN：.dropna(axis='rows')、.fillna(value,inplace=True)
import pandas as pd
data=pd.read_csv(r"C:\Users\Q\Student_score_test.csv")
# 1.删除缺失值，不会修改原数据，需要变量保存
# dropna() 方法默认会删除包含任何 NaN 值的行或列，具体取决于 axis 参数的设置。
# 如果要删除含有 NaN 的行，可以使用 data.dropna(axis='rows')。
# 如果要删除含有 NaN 的列，可以使用 data.dropna(axis='columns')。
data.dropna()
# 2.替换缺失值，value:替换成的值，inplace:是否修改原数据,
# 可以将所有 NaN 值替换为指定的 value
data.fillna(value,inplace=True)

# ②如果缺失值没有使用NaN标记，则先将标记替换为np.nan，然后继续处理
# 比如标记为’?'，若使用read_csv时会报错

</style>

​

语文数学英语
小王606060
小张902866
小明523279
小光925881

​

</div>

2、数据离散化

连续属性离散化的目的是为了简化数据结构，减少连续属性值的个数。离散化方法经常作为数据挖掘的工具。连续属性的离散化就是在连续属性的值域上，将值域划分为若干个离散的区间，最后用不同的符号或整数值代表落在每个子区间中的属性值。

# （1）读取数据
​
import pandas as pd
data = pd.read_csv(r"C:\Users\Q\Student_score_test.csv")
score= data['语文']
score

小王    60
小张    90
小明    52
小光    92
Name: 语文, dtype: int64

# （2）将数据进行分组

# # pd.qcut(data, q)：
# # 对数据进行分组将数据分组，一般会与value_counts搭配使用，统计每组的个数
# qcut = pd.qcut(score, 5)
# qcut
# # pd.cut(data, bins)：自定义区间分组，bins是区间
# bins=[0,60,80,100]
# cut = pd.cut(score, bins)
# cut
# # series.value_counts()：计算分到每个组数据个数
cut.value_counts()

(0, 60]      2
(80, 100]    2
(60, 80]     0
Name: 语文, dtype: int64

# 3、分组数据转成one-hot编码
# one-hot编码：把每个类别生成一个布尔列，
# 这些列中只有一列可以为这个样本取值为1.其又被称为独热编码。
# pandas.get_dummies(data, prefix=None)
# data:array-like, Series, or DataFrame
# prefix:分组名字

# 得出one-hot编码矩阵
dummies = pd.get_dummies(cut, prefix="rise")
dummies

​​

.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}

</style>

​

rise_(0, 60]rise_(60, 80]rise_(80, 100]
小王100
小张001
小明100
小光001

​

</div>

3、合并

如果数据由多张表组成，那么有时候需要将不同的内容合并在一起分析
# (1)pd.concat([data1, data2], axis=1)0列1行
data=[[1,2,3],[4,5,6],[7,8,9]]
index=['N0.%d'%i for i in range(0,3)]
columns=['语文','数学','英语']
a=pd.DataFrame(data=data,index=index,columns=columns)
data2=[[10,20,30],[40,50,60],[70,80,90]]
index2=['N0.%d'%i for i in range(3,6)]
columns2=['语文','数学','英语']
b=pd.DataFrame(data=data2,index=index2,columns=columns2)
​
# # 合并，按列合并
# pd.concat([a,b],axis=0)
# # # 合并，按行合并
pd.concat([a,b],axis=1)
​

​​

.dataframe tbody tr th {
    vertical-align: top;
}

.dataframe thead th {
    text-align: right;
}

</style>

​

语文数学英语语文数学英语
N0.01.02.03.0NaNNaNNaN
N0.14.05.06.0NaNNaNNaN
N0.27.08.09.0NaNNaNNaN
N0.3NaNNaNNaN10.020.030.0
N0.4NaNNaNNaN40.050.060.0
N0.5NaNNaNNaN70.080.090.0

​

</div>

# (2)pd.merge(left, right, how='inner', on=None)
# 可以指定按照两组数据的共同键值对合并或者左右各自
# left: DataFrame
# right: 另一个DataFrame
# on: 连接的键的依据是哪几个
# how:按照什么方式连接
# left左连接
# right右连接
# outer外连接
# inner内连接(默认)
data=[[1,2,3],[4,5,6],[7,8,9]]
index=['N0.%d'%i for i in range(0,3)]
columns=['语文','数学','英语']
a=pd.DataFrame(data=data,index=index,columns=columns)
data2=[[1,2,3],[40,50,60],[70,80,90]]
index2=['N0.%d'%i for i in range(3,6)]
columns2=['语文','政治','历史']
b=pd.DataFrame(data=data2,index=index2,columns=columns2)
# 左连接：将左表全部显示，右表进行合并，若没有的用NaN
pd.merge(a,b,how='left')
# 右连接：将右表全部显示，左表进行合并，若没有的用NaN
pd.merge(a,b,how='right')
# 外连接：将两表都显示，没有的NaN
pd.merge(a,b,how='outer')
# 内连接：双方只显示相同的
pd.merge(a,b)

​​

.dataframe tbody tr th {
    vertical-align: top;
}
​
.dataframe thead th {
    text-align: right;
}

</style>

​

语文数学英语政治历史
012323

​

</div>

4、交叉表与透视表

（1）、交叉表

交叉表用于计算一列数据对于另外一列数据的分组个数(用于统计分组频率的特殊透视表)，即是计算次数的
data=[[1,2,3],[4,5,6],[7,8,9]]
index=['N0.%d'%i for i in range(0,3)]
columns=['语文','数学','英语']
a=pd.DataFrame(data=data,index=index,columns=columns)
c=pd.crosstab(a['语文'],a['英语'])
c.plot.bar()
plt.show()

（2）、透视表

透视表是将原有的DataFrame的列分别作为行索引和列索引，然后对指定的列应用聚集函数。即指定某一列对另一列的比例关系
data=[[1,2,3],[4,5,6],[7,8,9]]
index=['N0.%d'%i for i in range(0,3)]
columns=['语文','数学','英语']
a=pd.DataFrame(data=data,index=index,columns=columns)
c=a.pivot_table(['语文'],index='英语')
c.plot.bar()
plt.show()

5、分组与聚合

# data.groupby(key, as_index=False)----data为DataFrame
# key:分组的列数据，可以多个
# 查看性别和年龄对语文成绩的影响
# # 分组聚合，按照性别和年龄分组

# 获取数据
import pandas as pd
import matplotlib.pyplot as plt

# 设置中文字体，确保 matplotlib 能够显示中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 指定默认字体为黑体
plt.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题

data=pd.read_csv(r"C:\Users\Q\Student.csv",encoding='utf-8')

# # 分组聚合，按照性别分组
count=data.groupby(['性别']).size() 
# 可视化展示，绘制条形图
count.plot(kind='bar', rot=0)
plt.title('学生性别分布')
plt.xlabel('性别')
plt.ylabel('人数')
plt.show()

count=data.groupby(['性别','年龄']).count()
count.plot(kind='bar')
plt.xlabel('性别')
plt.ylabel('平均语文成绩')
plt.title('性别与语文成绩对比')
plt.show()

Seaborn

1、可视化数据的分布
当处理一组数据时，通常先要做的就是了解变量是如何分布的。
    对于单变量的数据来说 采用直方图或核密度曲线是个不错的选择，
    对于双变量来说，可采用多面板图形展现，比如 散点图、二维直方图、核密度估计图形等。
2、绘制单变量分布
可以采用最简单的直方图描述单变量的分布情况。 Seaborn中提供了 distplot()函数，它默认绘制的是一个带有核密度估计曲线的直方图。
distplot()函数的语法格式如下。
seaborn.distplot(a, bins=None, hist=True, kde=True, rug=False, fit=None, color=None)
上述函数中常用参数的含义如下：
    (1) a：表示要观察的数据，可以是 Series、一维数组或列表。
    (2) bins：用于控制条形的数量。
    (3) hist：接收布尔类型，表示是否绘制(标注)直方图。
    (4) kde：接收布尔类型，表示是否绘制高斯核密度估计曲线。
    (5) rug：接收布尔类型，表示是否在支持的轴方向上绘制rugplot。
import numpy as np
import seaborn as sns
sns.set()
np.random.seed(0) # 确定随机数生成器的种子,如果不使用每次生成图形不一样
arr = np.random.randn(100) # 生成随机数组
ax = sns.distplot(arr, bins=20,hist=True, kde=True, rug=True) # 绘制直方图

3、绘制双变量分布
在 Seaborn中最简单的方法是使用 jointplot()函数，该函数可以创建一个多面板图形，比如散点图、二维直方图、核密度估计等，以显示两个变量之间的双变量关系及每个变量在单坐标轴上的单变量分布。
jointplot()函数的语法格式如下：seaborn.jointplot(x, y, data=None,kind='scatter', stat_func=None, color=None,ratio=5, space=0.2, dropna=True)
上述函数中常用参数的含义如下：
    (1) kind：表示绘制图形的类型。
    (2) stat_func：用于计算有关关系的统计量并标注图。
    (3) color：表示绘图元素的颜色。
    (4) size：用于设置图的大小(正方形)。
    (5) ratio：表示中心图与侧边图的比例。该参数的值越大，则中心图的占比会越大。
    (6) space：用于设置中心图与侧边图的间隔大小。
# （1）、绘制散点图
import pandas as pd
import seaborn as sns
# 创建DataFrame对象
dataframe_obj = pd.DataFrame({"x": np.random.randn(500),"y": np.random.randn(500)})
# 绘制散布图
sns.jointplot(x="x", y="y", data=dataframe_obj)

<seaborn.axisgrid.JointGrid at 0x1fdb87688b0>

# （2）、绘制二维直方图
# 绘制二维直方图
sns.jointplot(x="x", y="y", data=dataframe_obj, kind="hex")

<seaborn.axisgrid.JointGrid at 0x1fdb859a130>

# （3）、绘制核密度估计图形
sns.jointplot(x="x", y="y", data=dataframe_obj, kind="kde")

<seaborn.axisgrid.JointGrid at 0x1fdb87a6d60>

4、绘制成对的双变量分布
可以使用pairplot()函数实现，该函数会创建一个坐标轴矩阵，并且显示Datafram对象中每对变量的关系。另外，pairplot()函数也可以绘制每个变量在对角轴上的单变量分布。
# 加载seaborn中的数据集
import seaborn as sns
dataset = sns.load_dataset("iris")
dataset.head()
# 绘制多个成对的双变量分布
sns.pairplot(dataset)

用分类数据绘图

Seaborn针对分类数据提供了专门的可视化函数，这些函数大致可以分为如下三种:
    分类数据散点图: swarmplot()与 stripplot()。
    类数据的分布图: boxplot() 与 violinplot()。
    分类数据的统计估算图:barplot() 与 pointplot()。

1、类别散点图

通过 stripplot()函数可以画一个散点图， stripplot0函数的语法格式如下。
seaborn.stripplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None, jitter=False)
上述函数中常用参数的含义如下
    (1) x，y，hue：用于绘制长格式数据的输入。
    (2) data：用于绘制的数据集。如果x和y不存在，则它将作为宽格式，否则将作为长格式。
    (3) jitter：表示抖动的程度(仅沿类別轴)。当很多数据点重叠时，可以指定抖动的数量或者设为Tue使用默认值。
# 获取tips数据
import seaborn as sns
import matplotlib.pyplot as plt
tips = sns.load_dataset("tips")
sns.stripplot(x="day", y="total_bill", data=tips)
plt.show()

题

# 为了准备一个独特的颁奖典礼，组织者在会场的一片矩形区域（可看做是平面直角坐标系的第一象限）铺上一些矩形地毯。一共有 n 张地毯，编号从 1 到 
# n。现在将这些地毯按照编号从小到大的顺序平行于坐标轴先后铺设，后铺的地毯覆盖在前面已经铺好的地毯之上。
# 地毯铺设完成后，组织者想知道覆盖地面某个点的最上面的那张地毯的编号。注意：在矩形地毯边界和四个顶点上的点也算被地毯覆盖。
def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    
    if len(data) < 3:
        print("Error: Insufficient input data.")
        return
    
    try:
        n = int(data[0])  # 总共有n张地毯
        index = 1
        carpets = []
        
        for i in range(n):
            a = int(data[index])
            b = int(data[index + 1])
            g = int(data[index + 2])
            k = int(data[index + 3])
            carpets.append((a, b, g, k))
            index += 4
        
        x = int(data[index])    # 查询点的x坐标
        y = int(data[index + 1])  # 查询点的y坐标
        
        # 寻找覆盖查询点的最上面的地毯
        top_carpet = -1
        max_level = -1
        
        for i in range(n):
            (a, b, g, k) = carpets[i]
            x1 = a
            x2 = a + g
            y1 = b
            y2 = b + k
            
            if x >= x1 and x <= x2 and y >= y1 and y <= y2:
                current_level = b + k
                if current_level > max_level:
                    max_level = current_level
                    top_carpet = i + 1  # 因为题目中编号从1开始
        
        print(top_carpet)
    
    except ValueError as e:
        print(f"Error: {e}")
    except IndexError as e:
        print(f"Error: {e}")
​
if __name__ == "__main__":
    main()
# 小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。一次素质拓展活动中，班上同学安排坐成一个 m 行 n 列的矩阵，而小渊和小轩被安排
# 在矩阵对角线的两端，因此，他们就无法直接交谈了。幸运的是，他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，
# 坐标 (1,1)，小轩坐在矩阵的右下角，坐标 (m,n)。从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。在活动
# 进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条
# 的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙。反之亦然。还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低
# 找到来回两条传递路径，使得这两条路径上同学的好心程度之和最大。现在，请你帮助小渊和小轩找到这样的两条路径。
def max_paper_passing(m, n, matrix):
    # Initialize DP tables for two passes: from (1,1) to (m,n) and from (m,n) to (1,1)
    dp1 = [[0] * n for _ in range(m)]
    dp2 = [[0] * n for _ in range(m)]
    
    # Fill dp1: from (1,1) to (m,n) - only can move down or right
    for i in range(m):
        for j in range(n):
            if i == 0 and j == 0:
                dp1[i][j] = matrix[i][j]
            elif i == 0:
                dp1[i][j] = dp1[i][j-1] + matrix[i][j]
            elif j == 0:
                dp1[i][j] = dp1[i-1][j] + matrix[i][j]
            else:
                dp1[i][j] = max(dp1[i-1][j], dp1[i][j-1]) + matrix[i][j]
    
    # Fill dp2: from (m,n) to (1,1) - only can move up or left
    for i in range(m-1, -1, -1):
        for j in range(n-1, -1, -1):
            if i == m-1 and j == n-1:
                dp2[i][j] = matrix[i][j]
            elif i == m-1:
                dp2[i][j] = dp2[i][j+1] + matrix[i][j]
            elif j == n-1:
                dp2[i][j] = dp2[i+1][j] + matrix[i][j]
            else:
                dp2[i][j] = max(dp2[i+1][j], dp2[i][j+1]) + matrix[i][j]
    
    # Find the maximum sum of good-heartedness for the round trip
    max_sum = 0
    for i in range(m):
        for j in range(n):
            if (i == 0 and j == 0) or (i == m-1 and j == n-1):
                continue
            round_trip_sum = dp1[i][j] + dp2[i][j] - matrix[i][j]
            max_sum = max(max_sum, round_trip_sum)
    
    return max_sum
​
# Read input
import sys
input = sys.stdin.read
data = input().splitlines()
​
m, n = map(int, data[0].split())
matrix = []
for i in range(1, m+1):
    row = list(map(int, data[i].split()))
    matrix.append(row)
​
# Calculate the maximum good-heartedness sum for round trip passing of papers
result = max_paper_passing(m, n, matrix)
​
# Print the result
print(result)
​
# 将 1,2,…,9 共 9个数分成 3 组，分别组成 3 个三位数，且使这 3 个三位数构成 1:2:3 的比例，试求出所有满足条件的 3 个三位数。
from itertools import permutations
​
def find_three_digit_groups():
    # Generate all permutations of digits 1 to 9
    digits = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    perms = permutations(digits, 9)
    
    results = []
    
    # Iterate through permutations
    for perm in perms:
        # Split into three groups of three digits
        group1 = perm[:3]
        group2 = perm[3:6]
        group3 = perm[6:]
        
        # Check if they form 1:2:3 ratio
        num1 = 100 * group1[0] + 10 * group1[1] + group1[2]
        num2 = 100 * group2[0] + 10 * group2[1] + group2[2]
        num3 = 100 * group3[0] + 10 * group3[1] + group3[2]
        
        # Check ratio conditions
        if num1 * 2 == num2 and num1 * 3 == num3:
            results.append((num1, num2, num3))
    
    return results
​
# Find and print all valid groups
valid_groups = find_three_digit_groups()
for group in valid_groups:
    print(group)
​
# 用高精度计算出 
# S=1!+2!+3!+⋯+n!（n≤50）。其中 ! 表示阶乘，定义为 n!=n×(n−1)×(n−2)×⋯×1。例如，5!=5×4×3×2×1=120。
import math
​
def calculate_S(n):
    S = 0
    for i in range(1, n+1):
        S += math.factorial(i)
    return S
​
n = 50  # 最大的 n 值
result = calculate_S(n)
print("S =", result)
​
# 火车从始发站（称为第 1 站）开出，在始发站上车的人数为 a，然后到达第 2 站，在第 2 站有人上、下车，但上、下车的人数相同，因此在第 
# 2 站开出时（即在到达第 3 站之前）车上的人数保持为 a 人。从第3 站起（包括第 3 站）上、下车的人数有一定规律：上车的人数都是前两站上车人数之和，
# 而下车人数等于上一站上车人数，一直到终点站的前一站（第 n−1 站），都满足此规律。现给出的条件是：共有 n 个车站，始发站上车的人数为 
# a，最后一站下车的人数是 m（全部下车）。试问 x 站开出时车上的人数是多少？
def calculate_people_on_train(n, a, m, x):
    # Initialize an array to keep track of people on the train after each station
    people_on_train = [0] * (n + 1)
    people_on_train[1] = a  # 初始站上车人数为 a
    
    # Simulate the process from station 2 to station n-1
    for i in range(2, n):
        # Calculate people getting on at station i
        getting_on = people_on_train[i-1] + people_on_train[i-2]
        # Calculate people getting off at station i
        getting_off = people_on_train[i-1]
        # Update people on train after station i
        people_on_train[i] = people_on_train[i-1] + getting_on - getting_off
    
    # Last station (n) all get off, so people on train at station n is 0
    people_on_train[n] = 0
    
    # Return the number of people on the train when station x departs
    return people_on_train[x]
​
# Example usage:
n = 5  # 总车站数
a = 10  # 始发站上车人数
m = 5  # 最后一站下车人数（全部下车）
x = 3  # 要计算的第 x 站开出时的人数
​
result = calculate_people_on_train(n, a, m, x)
print(f"At station {x}, people on the train: {result}")
​
# 一个旅行家想驾驶汽车以最少的费用从一个城市到另一个城市（假设出发时油箱是空的）。给定两个城市之间的距离 D 1 、汽车油箱的容量 
# C（以升为单位）、每升汽油能行驶的距离 D 2、出发点每升汽油价格P和沿途油站数 N（N 可以为零），油站 i 离出发点的距离 
# Di每升汽油价格 Pii=1,2,…,N）。计算结果四舍五入至小数点后两位。如果无法到达目的地，则输出 No Solution。
def minimum_cost_to_destination(D1, C, D2, P, N, stations):
    current_position = 0
    current_fuel = 0
    total_cost = 0
    
    while current_position < D1:
        # Calculate maximum distance can be traveled with current fuel
        max_distance = current_position + D2 * C
        
        # Find the cheapest station within reach
        cheapest_station_index = -1
        cheapest_price = float('inf')
        
        for i in range(N):
            station_distance = stations[i][0]
            station_price = stations[i][1]
            
            if station_distance > current_position and station_distance <= max_distance:
                if station_price < cheapest_price:
                    cheapest_price = station_price
                    cheapest_station_index = i
        
        if cheapest_station_index == -1:
            # No reachable station found
            return "No Solution"
        
        # Move to the cheapest station
        cheapest_station_distance = stations[cheapest_station_index][0]
        cheapest_station_price = stations[cheapest_station_index][1]
        
        # Calculate distance traveled to the station
        distance_traveled = cheapest_station_distance - current_position
        
        # Calculate fuel needed to reach the station
        fuel_needed = distance_traveled / D2
        
        # Add fuel cost
        total_cost += (fuel_needed - current_fuel) * P
        
        # Update current position and current fuel
        current_position = cheapest_station_distance
        current_fuel = C - fuel_needed
    
    return round(total_cost, 2)
​
# Example usage:
D1 = 500  # 目的地距离
C = 50    # 汽车油箱容量
D2 = 10   # 每升汽油能行驶的距离
P = 2     # 每升汽油价格
N = 3     # 油站数量
stations = [(100, 1.5), (200, 1.2), (300, 1.8)]  # 油站列表，每个油站的距离和价格
​
result = minimum_cost_to_destination(D1, C, D2, P, N, stations)
print(result)  # 输出最少费用，四舍五入至小数点后两位
​
茴豆
关注
【pandas学习笔记(一)】pandas基本使用
12-21
【pandas学习笔记(一)】pandas基本使用 pandas是Python中广泛使用的数据分析库，它基于NumPy构建，提供了高效的数据结构，如Series（一维数组）和DataFrame（二维表格型数据结构）。pandas的主要功能是进行数据清洗...
Pandas学习笔记
11-06
### Pandas学习笔记 #### 一、简单操作 ##### 1. Series 对象 - **创建**：可以通过列表、NumPy 数组或字典来创建一个 `Series` 对象。 - 使用列表创建： ```python s = pd.Series([12, -4, 7, 9]) ``` - ...
Python Pandas相关笔记
weixin_44622268的博客
04-06 1421
@Ida Woods Pandas Pandas读取、导出csv #读取该目录下文件 df = pd.read_csv('file_name.csv') df = pd.read_csv(r"./file_name.csv") #查看所有列名 df.columns #依据列名为'columns1'的列进行去重，获取去重后结果 list_columns=df.columns1.drop_duplicates() #更新表格序列号Index df=df.reset_index(drop=True) #将df保
个人pandas学习笔记
chicali的博客
07-22 1191
Pandas 是基于 NumPy 的一个数据分析库，提供了快速、灵活和表达力强的数据结构，旨在使数据清洗和分析工作变得更加简单易行。
pandas入门笔记
LoveElaina的博客
07-22 251
Pandas是一个用于数据操作和分析的强大Python库。它提供了快速、灵活和易于理解的数据结构，极大地简化了“数据清洗”和“数据分析”过程。Pandas基于NumPy构建，支持多种数据输入/输出格式，使得数据处理更加方便。
Pandas 学习笔记
2302_79605743的博客
07-17 363
【代码】Pandas 学习笔记。
pandas入门学习笔记
YL010325的博客
07-22 777
pandas主要是Python语言的一个扩展程序库,提供了高效、灵活、易用的数据结构，专门用于数据操作和分析。Pandas的主要功能包括：数据清洗：处理缺失数据、重复数据、异常值等。数据选择和过滤：通过标签或位置选择数据子集。数据操作：合并、连接、重塑和透视数据。数据分组和聚合：按照某些标准分组数据，并进行聚合计算。时间序列分析：支持时间索引和时间序列数据的处理。数据输入和输出：读取和写入多种数据格式，如CSV文件、Excel表格、数据库等。
pandas 笔记 stack unstack
qq_40206371的博客
07-20 305
为了和stack以示区别，我们交换前面stack后的两个index。第一列index作为unstack后的index。
pandas学习笔记
weixin_62313535的博客
11-12 1272
pandas
pandas笔记
2402_86380452的博客
07-22 143
pandas学习笔记与总结
weixin_66224671的博客
08-29 1356
pandas读书笔记，pandas的常用操作
pandas 使用笔记study-pandas-master.zip
05-10
**Pandas：Python数据分析利器** Pandas是Python中一个强大的数据处理库，它为数据分析提供了高效、灵活且易于使用的工具。这个"study-pandas-master.zip"压缩包很可能包含了一个详细的学习资源，帮助用户深入理解...
Pandas学习笔记1-Pandas基础
01-17
Pandas含有使数据分析工作变得更快更简单的高级数据结构和操作工具。 Pandas基于NumPy构建，让以NumPy为中心的应用变得更加简单。 1. Pandas数据结构 2. 索引对象
（笔记）第三期书生·浦语大模型实战营（十一卷王场）–书生基础岛第5关---XTuner 微调个人小助手认知
最新发布
haidizym的博客
10-06 432
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1tz421B72y/课程文档：关卡作业：https://github.com/InternLM/Tutorial/blob/camp3/docs/L1/XTuner/task.md开发机平台：https://studio.intern-ai.org.cn/
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 938
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 558
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
强化学习笔记之【DDPG算法】
rvdgdsva的博客
10-06 842
强化学习第2篇.强化学习方向的学习者可以参考或者复刻
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 834
排序是将多个数据，依指定的顺序进行排列的过程。
Pandas学习笔记：Series与DataFrame详解
本学习笔记PDF详细介绍了Pandas的核心组件——Series和DataFrame，以及它们的基本用法和特性。 **1. Series（一维数组）** - Series是Pandas的基础数据结构，类似于一维数组，但带有索引。它的构造函数接收四个关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值