pandas基本用法

NJU_AI_NB

已于 2024-02-20 14:02:16 修改

阅读量1k

点赞数 9

分类专栏： pandas 文章标签： pandas

于 2024-02-14 11:00:52 首次发布

本文链接：https://blog.csdn.net/aa12367/article/details/136111853

版权

pandas 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文详细介绍了Pandas库中的Series和DataFrame数据结构，包括它们的创建、索引、数据访问、切片、过滤、数学运算以及DataFrame的创建方式、数据选择和操作、缺失值处理等内容。

摘要由CSDN通过智能技术生成

Pandas是Python中用于数据处理和分析的重要库，它提供了高性能、易于使用的数据结构和数据操作工具。

# 导入pandas库
import pandas as pd

一.pd.Series是Pandas库中的一种数据结构，它类似于一维数组或列表，但具有额外的功能和灵活性。Series可以存储任何数据类型（整数、浮点数、字符串等），并且每个数据点都与一个索引相关联，索引可以是整数、字符串或其他类型。

# 创建一个Pandas Series对象
pd.Series([1,2,31,12,34])

0     1
1     2
2    31
3    12
4    34
dtype: int64

# 创建一个Pandas Series对象并赋值给变量t
t=pd.Series([1, 2, 31, 12, 34])

# 打印变量类型
type(t)

pandas.core.series.Series

# 打印Series对象t
t

0     1
1     2
2    31
3    12
4    34
dtype: int64

1.自定义索引：可以在创建Series时指定自定义索引

# 创建一个Pandas Series对象并指定索引
t2 = pd.Series([1,23,2,2,1],index=list('abcde'))
# 打印Series对象t2
t2

a     1
b    23
c     2
d     2
e     1
dtype: int64

# 创建一个字典
temp_dict ={'name':'xiaohong','age':'30','tel':'10086'}

# 使用字典创建Pandas Series对象
t3=pd.Series(temp_dict)

# 打印Series对象t3
t3

name    xiaohong
age           30
tel        10086
dtype: object

# 打印Series对象t3的数据类型
t3.dtype

dtype('O')

# 打印Series对象t2的数据类型
t2.dtype

dtype('int64')

# 打印Series对象t2
t2

a     1
b    23
c     2
d     2
e     1
dtype: int64

# 将Series对象t2的数据类型转换为float
t2.astype(float)

a     1.0
b    23.0
c     2.0
d     2.0
e     1.0
dtype: float64

# 打印Series对象t3
t3

name    xiaohong
age           30
tel        10086
dtype: object

2.使用标签索引：与Python列表类似，Series也支持使用标签索引来访问数据

# 使用标签索引访问Series对象t3的元素'age'
t3['age']

'30'

# 使用标签索引访问Series对象t3的元素'tel'
t3['tel']

'10086'

3.访问数据：可以通过整数索引访问Series中的数据

# 使用整数索引访问Series对象t3的元素，这种方式在未来的版本中会被弃用，建议使用iloc[]
t3[1]

C:\Users\86132\AppData\Local\Temp\ipykernel_26968\2027420829.py:1: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  t3[1]





'30'

# 使用整数索引访问Series对象t3的元素，这种方式在未来的版本中会被弃用，建议使用iloc[]
t3[2]

C:\Users\86132\AppData\Local\Temp\ipykernel_26968\739707692.py:1: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  t3[2]





'10086'

# 使用整数索引访问Series对象t3的元素，这种方式在未来的版本中会被弃用，建议使用iloc[]
t3[0]

C:\Users\86132\AppData\Local\Temp\ipykernel_26968\2017440695.py:1: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  t3[0]





'xiaohong'

二.Series操作：可以对Series进行各种操作，如切片、过滤、数学运算等

1.切片

# 使用切片访问Series对象t3的前两个元素
t3[:2]

name    xiaohong
age           30
dtype: object

# 使用整数索引列表访问Series对象t3的元素，这种方式在未来的版本中会被弃用，建议使用iloc[]
t3[[1,2]]

C:\Users\86132\AppData\Local\Temp\ipykernel_6328\3760560860.py:1: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`
  t3[[1,2]]





age       30
tel    10086
dtype: object

# 打印Series对象t3
t3

name    xiaohong
age           30
tel        10086
dtype: object

# 使用标签索引访问Series对象t3的元素，选择'name'和'tel'
t3[['name','tel']]

name    xiaohong
tel        10086
dtype: object

# 打印Series对象t
t

0     1
1     2
2    31
3    12
4    34
dtype: int64

2.根据条件过滤数据

# 使用条件筛选，选择Series对象t中大于10的元素
t[t>10]

2    31
3    12
4    34
dtype: int64

# 打印Series对象t3
t3

name    xiaohong
age           30
tel        10086
dtype: object

# 获取Series对象t3的索引
t3.index

Index(['name', 'age', 'tel'], dtype='object')

# 遍历Series对象t3的索引并打印
for i in t3.index:
    print(i)

name
age
tel

# 打印Series对象t3索引的数据类型
type(t3.index)

pandas.core.indexes.base.Index

# 获取Series对象t3索引的长度
len(t3.index)

# 将Series对象t3索引转换为列表并打印
list(t3.index)

['name', 'age', 'tel']

# 将Series对象t3索引转换为列表并打印前两个值
list(t3.index)[:2]

['name', 'age']

# 打印Series对象t3
t3

name    xiaohong
age           30
tel        10086
dtype: object

# 获取Series对象t3的值数组
t3.values

array(['xiaohong', '30', '10086'], dtype=object)

# 打印Series对象t3的值数组的数据类型
type(t3.values)

numpy.ndarray

# 打印Series对象t
t

0     1
1     2
2    31
3    12
4    34
dtype: int64

三.DataFrame是Pandas中最重要的数据结构，类似于电子表格或数据库表。

1.可以通过各种方式创建DataFrame，比如从Python字典、NumPy数组

# 导入numpy库
import numpy as np

# 创建一个3x4的DataFrame对象
pd.DataFrame(np.arange(12).reshape(3,4))

	0	1	2	3
0	0	1	2	3
1	4	5	6	7
2	8	9	10	11

# 创建一个带有行索引和列索引的DataFrame对象
t1=pd.DataFrame(np.arange(12).reshape(3, 4),index=list('abc'),columns=list('WXYZ'))

# 打印DataFrame对象t1
t1

	W	X	Y	Z
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11

# 创建一个字典
d1={'name':['xiaoming','xiaohong'],'age':[20,25],'tel':['10000','10086']}

# 使用字典创建DataFrame对象
pd.DataFrame(d1)

	name	age	tel
0	xiaoming	20	10000
1	xiaohong	25	10086

# 将字典d1创建为DataFrame对象并赋值给变量t1
t1=pd.DataFrame(d1)

# 打印变量t1的类型
type(t1)

pandas.core.frame.DataFrame

# 创建一个字典列表d2，包含三个字典元素，每个字典表示一个人的信息
d2 = [
    {"name": "xiaohong", "age": 32, "tel": 10010},
    {"name": "xiaogang",  "tel": 10000},
    {"name": "xiaowang", "age": 22}
]

# 打印字典列表d2
d2

[{'name': 'xiaohong', 'age': 32, 'tel': 10010},
 {'name': 'xiaogang', 'tel': 10000},
 {'name': 'xiaowang', 'age': 22}]

# 使用字典列表d2创建DataFrame对象t2
t2=pd.DataFrame(d2)

# 打印DataFrame对象t2
t2

	name	age	tel
0	xiaohong	32.0	10010.0
1	xiaogang	NaN	10000.0
2	xiaowang	22.0	NaN

# 获取DataFrame对象t2的行索引
t2.index

RangeIndex(start=0, stop=3, step=1)

# 获取DataFrame对象t2的列索引
t2.columns

Index(['name', 'age', 'tel'], dtype='object')

# 获取DataFrame对象t2的值数组
t2.values

array([['xiaohong', 32.0, 10010.0],
       ['xiaogang', nan, 10000.0],
       ['xiaowang', 22.0, nan]], dtype=object)

# 获取DataFrame对象t2的形状（行数，列数）
t2.shape

(3, 3)

# 获取DataFrame对象t2的数据类型
t2.dtypes

name     object
age     float64
tel     float64
dtype: object

# 获取DataFrame对象t2的维度
t2.ndim

# 导入NumPy库
import numpy as np

# 使用NumPy创建一个3行4列的DataFrame对象t3，索引为'a', 'b', 'c'，列标签为'W', 'X', 'Y', 'Z'
t3=pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'),columns=list('WXYZ'))

# 打印DataFrame对象t3
t3

	W	X	Y	Z
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11

2.数据选择和操作：可以通过列名或行索引选择数据，并进行各种操作，如切片、过滤、排序等。

# 使用.loc按行标签和列标签选择元素
t3.loc['a','Z']

# 查看所选元素的数据类型
type(t3.loc['a','Z'])

numpy.int32

# 使用.loc按行标签选择整行
t3.loc['a']

W    0
X    1
Y    2
Z    3
Name: a, dtype: int32

# 使用.loc按行标签选择整行
t3.loc["a",:]

W    0
X    1
Y    2
Z    3
Name: a, dtype: int32

# 使用.loc按列标签选择整列
t3.loc[:, "Y"]

a     2
b     6
c    10
Name: Y, dtype: int32

# 使用.loc按行标签选择指定的多行
t3.loc[["a","c"]]

	W	X	Y	Z
a	0	1	2	3
c	8	9	10	11

# 使用.loc按行标签选择指定的多行和列标签选择指定的多列
t3.loc[["a", "c"],:]

	W	X	Y	Z
a	0	1	2	3
c	8	9	10	11

# 使用.loc按列标签选择指定的多列和行标签选择所有行
t3.loc[:,["Y","Z"]]

	Y	Z
a	2	3
b	6	7
c	10	11

# 再次打印DataFrame对象t3
t3

	W	X	Y	Z
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11

# 使用.loc按行标签选择指定的多行和列标签选择指定的多列
t3.loc[["a", "c"], ["Y", "Z"]]

	Y	Z
a	2	3
c	10	11

# 再次打印DataFrame对象t3
t3

	W	X	Y	Z
a	0	1	2	3
b	4	5	6	7
c	8	9	10	11

# 使用.iloc按位置选择指定的行
t3.iloc[1]

W    4
X    5
Y    6
Z    7
Name: b, dtype: int32

# 使用.iloc按位置选择指定的列
t3.iloc[:,2]

a     2
b     6
c    10
Name: Y, dtype: int32

# 使用.iloc按位置选择指定的多列
t3.iloc[:, [2,1]]

	Y	X
a	2	1
b	6	5
c	10	9

# 使用.iloc按位置选择指定的多行和多列
t3.iloc[[0,2], [2, 1]]

	Y	X
a	2	1
c	10	9

# 使用.iloc按位置选择指定的行和列的切片
t3.iloc[1:,:2]

	W	X
b	4	5
c	8	9

# 使用.iloc按位置修改部分元素为30
t3.iloc[1:, :2]=30
# 再次打印DataFrame对象t3
t3

	W	X	Y	Z
a	0	1	2	3
b	30	30	6	7
c	30	30	10	11

# 使用.iloc按位置修改部分元素为NaN
t3.iloc[1:, :2] = np.nan
# 再次打印DataFrame对象t3
t3

	W	X	Y	Z
a	0.0	1.0	2	3
b	NaN	NaN	6	7
c	NaN	NaN	10	11

# 检查DataFrame对象t3中的NaN值
pd.isnull(t3)

	W	X	Y	Z
a	False	False	False	False
b	True	True	False	False
c	True	True	False	False

# 检查DataFrame对象t3中的非NaN值
pd.notnull(t3)

	W	X	Y	Z
a	True	True	True	True
b	False	False	True	True
c	False	False	True	True

# 选择DataFrame对象t3中某列非NaN值所在的行
t3[pd.notnull(t3['W'])]

	W	X	Y	Z
a	0.0	1.0	2	3

# 检查DataFrame对象t3中某列非NaN值的布尔掩码
pd.notnull(t3["W"])

a     True
b    False
c    False
Name: W, dtype: bool

3.缺失值处理：Pandas提供了一些方法来处理缺失值，如dropna()删除缺失值、fillna()填充缺失值等。

# 删除DataFrame对象t3中的包含NaN值的行
t3.dropna(axis=0)

	W	X	Y	Z
a	0.0	1.0	2	3

# 删除DataFrame对象t3中全部为NaN值的行
t3.dropna(axis=0, how="all")

	W	X	Y	Z
a	0.0	1.0	2	3
b	NaN	NaN	6	7
c	NaN	NaN	10	11

# 删除DataFrame对象t3中含有NaN值的行
t3.dropna(axis=0,how='any')

	W	X	Y	Z
a	0.0	1.0	2	3

# 在原地删除DataFrame对象t3中含有NaN值的行
t3.dropna(axis=0, how="any",inplace=True)
# 再次打印DataFrame对象t3
t3

	W	X	Y	Z
a	0.0	1.0	2	3

# 展示 Series t2 的内容
t2

a     1
b    23
c     2
d     2
e     1
dtype: int64

# 使用 0 填充缺失值
t2.fillna(0)

	name	age	tel
0	xiaohong	32.0	10010.0
1	xiaogang	0.0	10000.0
2	xiaowang	22.0	0.0

# 使用 100 填充缺失值
t2.fillna(100)

	name	age	tel
0	xiaohong	32.0	10010.0
1	xiaogang	100.0	10000.0
2	xiaowang	22.0	100.0

# 计算数值列的平均值
t2.mean(numeric_only=True)

age       27.0
tel    10005.0
dtype: float64

# 使用数值列的平均值填充缺失值
t2.fillna(t2.mean(numeric_only=True))

	name	age	tel
0	xiaohong	32.0	10010.0
1	xiaogang	27.0	10000.0
2	xiaowang	22.0	10005.0

# 使用年龄列的平均值填充缺失值
t2["age"].fillna(t2["age"].mean())

0    32.0
1    27.0
2    22.0
Name: age, dtype: float64

# 将填充后的结果应用到原数据中
t2["age"] = t2["age"].fillna(t2["age"].mean())
# 展示填充后的数据
t2

	name	age	tel
0	xiaohong	32.0	10010.0
1	xiaogang	27.0	10000.0
2	xiaowang	22.0	NaN

# 给第二行的年龄列赋值为NaN
t2['age'][1]=np.nan

C:\Users\86132\AppData\Local\Temp\ipykernel_416\1725511734.py:1: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  t2['age'][1]=np.nan

# 展示修改后的数据
t2

	name	age	tel
0	xiaohong	32.0	10010.0
1	xiaogang	NaN	10000.0
2	xiaowang	22.0	NaN

# 计算年龄列的平均值
t2['age'].mean()

27.0

NJU_AI_NB

关注

9
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录