python三大库之—pandas（一）
一、概述
- Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来
- Pandas 是 Python 语言的一个扩展程序库，用于数据分析
- Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）
- Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据
- Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征
- Pandas 广泛应用在学术、金融、统计学等各个数据分析领域
- Pandas 的出现使得 Python 做数据分析的能力得到了大幅度提升，它主要实现了数据分析的五个重要环节：加载数据、整理数据、操作数据、构建数据模型、分析数据
二，安装
pip install pandas
使用清华园镜像
pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/
三，内置数据结构
Pandas 在 ndarray 数组（NumPy 中的数组）的基础上构建出了两种不同的数据结构，分别是 Series（一维数据结构）、DataFrame（二维数据结构）：
- Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等
- DataFrame 是一种表格型数据结构，它既有行标签，又有列标签
| 数据结构 | 维度 | 说明 |
|---|---|---|
| Series | 1 | 该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述数据值。Series 是一维数据结构，因此其维数不可以改变 |
| DataFrame | 2 | DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在创建该结构时，可以指定相应的索引值 |
从图中可见，
- 整个表是一个DataFrame，
- 一行或者一列为一个Series，
- 如果没有行标签的话，使用默认行标签0，1，2，3
- 列的Series的标签是DataFrame的行标签，行的Series标签是DataFrame的列标签
图中0，1，2为默行标签，小明，小王，小李为列标签
四，Series
Pandas Series 类似表格中等一个列（column），类似于一维数组，可以保存任何数据类型 Series 由索引（index）和列组成，函数：
| 函数名 | 参数 |
|---|---|
| pandas.Series(data,index,dtype) | data：一组数据（ndarray 类型） index：索引标签 dtype：数据类型 copy：表示对 data 进行拷贝，默认为 False |
#创建Series对象
def one():
series_one = pd.Series([1,2,3],index=['a','b','c'],dtype='int64')
print(series_one)
one()
a 1
b 2
c 3
dtype: int64
- a，b，c是行索引
- 1，2，3是数据
- dtype是数据类型
4.1创建 Series 对象的方式
4.1.1创建 Series 空对象
#创建Series空对象
def two():
series_two = pd.Series()
print(series_two)
two()
Series([], dtype: object)
4.1.2ndarray(多维数组) 创建 Series 对象
#列表创建
s= pd.Series(np.array([1,2,3,4]),dtype='float64')
print(s)
0 1.0
1 2.0
2 3.0
3 4.0
dtype: float64
4.1.3 字典创建 Series 对象
#字典创建，字典中的key是索引，value是值
dic = {'a':1,'b':2,'c':3,'d':4}
s= pd.Series(dic)
print(s)
a 1
b 2
c 3
d 4
dtype: int64
4.2访问 Series 数据
#访问Sieries元素
s=pd.Series([1,2,3,4,5,6])
print(s[3])
print (s[2:5])
s=pd.Series([1,2,3,4,5,6],index=['a','b','c','d','e','f'])
print(s)
print(s['f'])
print(s['a':'d'])
4
2 3
3 4
4 5
dtype: int64
a 1
b 2
c 3
d 4
e 5
f 6
dtype: int64
6
a 1
b 2
c 3
d 4
dtype: int64
4.3 Series遍历
- 使用index()方法遍历
#使用index()方法遍历
s= pd.Series([1,2,3,4],index=['a','b','c','d'])
#index获取标签
for i in s.index:
print(i,s[i])
a 1
b 2
c 3
d 4
- 使用items()方法
#使用items()方法
s= pd.Series([1,2,3,4],index=['a','b','c','d'])
for i,j in s.items():
print(i,j)
a 1
b 2
c 3
d 4
- 使用values()方法
#使用values()方法
s=pd.Series([1,2,3,4],index=['a','b','c','d'])
for i in s.values:
print(i)
1
2
3
4
4.4 Series 常用方法
isnull() 和 notnull() 用于检测 Series、DataFrame 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少
- isnull()：如果为值不存在或者缺失，则返回 True
- notnull()：如果值不存在或者缺失，则返回 False
def eight():
result = pd.Series(['a','b','c','d','e','f',None])
print("isnull()如果为值不存在或者缺失，则返回 True：")
print(result.isnull())
print("notnull()如果值不存在或者缺失，则返回 False：")
print(result.notnull())
#过滤掉缺失值
print(result[result.notnull()])
eight()
isnull()如果为值不存在或者缺失，则返回 True：
0 False
1 False
2 False
3 False
4 False
5 False
6 True
dtype: bool
notnull()如果值不存在或者缺失，则返回 False：
0 True
1 True
2 True
3 True
4 True
5 True
6 False
dtype: bool
0 a
1 b
2 c
3 d
4 e
5 f
dtype: object
五，DataFrame
-
DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。
-
DataFrame 的每一行或列数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列或行标签
-
同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应当然你也可以用“显式索引”的方式来设置行标签
-
DataFrame 构造方法：
| 函数名 | 参数 |
|---|---|
| pd.DataFrame( data, index, columns, dtype, copy) | data：一组数据 index：行标签 columns：列标签 dtype：数据类型 copy：默认为 False，表示复制数据 data |
5.1 创建 DataFrame 对象
创建 DataFrame 对象的方式：
- 列表
- 字典
- Series
- Numpy ndarrays
- 另一个 DataFrame
5.1.1 创建 DataFrame 空对象
#dataframe
s=pd.DataFrame({})
print(s)
Empty DataFrame
Columns: []
Index: []
5.1.2 列表嵌套字典创建 DataFrame 对象
#列表嵌套字典创建dataframe
#如果字典中有不同的键值对，则创建并集
s=pd.DataFrame([{'name':'a','age':1},{'name':'b','age':2},{'name':'c','age':3}])
print(s)
name age
0 a 1
1 b 2
2 c 3
5.1.3 字典嵌套列表创建 DataFrame 对象
#字典嵌套列表创建dataframe
s=pd.DataFrame({'name':['a','b','c','d'],'age':[1,2,3,4]})
print(s)
name age
0 a 1
1 b 2
2 c 3
3 d 4
5.1.4 Series 创建 DataFrame 对象
#series嵌套dataframe
def nine():
s={
'name':pd.Series([1,2,3,4,5,6],index=['a','b','c','d','e','f']),
'age':pd.Series([1,2,3,4],index=['a','b','c','d'])
}
a=pd.DataFrame(s)
print(a)
nine()
name age
a 1 1.0
b 2 2.0
c 3 3.0
d 4 4.0
e 5 NaN
f 6 NaN
5.2 列索引操作
5.2.1选取数据
dic = {'name':['a','b','c','d'],'age':[1,2,3,4],'money':[1,2,3,4]}
df = pd.DataFrame(dic)
print(df['money'])
#取多列返回DataFrame
print(df[['name', 'age']])
#不能直接对列做切片操作,可以通过loc或iloc实现
#print(df['one':'three'])
0 1
1 2
2 3
3 4
Name: money, dtype: int64
name age
0 a 1
1 b 2
2 c 3
3 d 4
5.2.2 添加数据
- 添加一列空列
# 添加一个空列
data = {'name' : pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'age': pd.Series(data=[1, 2,3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df['zzz'] = None
print(df)
name age zzz
a 1.0 1 None
b 2.0 2 None
c 3.0 3 None
d NaN 4 None
- 添加新列，直接赋值添加
# 添加一个空列
data = {'name' : pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'age': pd.Series(data=[1, 2,3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
# df['zzz'] = None
# print(df)
df['zzz'] = [10,20,30,40]
print(df),
name age zzz
a 1.0 1 10
b 2.0 2 20
c 3.0 3 30
d NaN 4 40
- 通过assign方法添加新列
# 通过assign()方法添加列
data = {'name' : pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),
'age': pd.Series(data=[1, 2,3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(data)
df1 = df.assign(new_column=pd.Series([1, 2, 3, 4], index=df.index)).assign(new_column1=pd.Series([1, 2, 3, 4], index=df.index))
print(df1)
name age new_column new_column1
a 1.0 1 1 1
b 2.0 2 2 2
c 3.0 3 3 3
d NaN 4 4 4
-
在指定的位置插入新列
使用insert方法在指定位置插入新列，参数： -
loc: 插入位置的列索引。
-
column: 新列的名称。
-
value: 要插入的 Series。
#insert()方法,在指定位置插入一列
data = {
"A":[ 1,2,3,4],
"B":[ 1,2,3,4],
"C":[ 1,2,3,4],
"D":[ 1,2,3,4],
}
df = pd.DataFrame(data)
print(df)
df.insert(0,'new_column',pd.Series([1,2,3,4],index=df.index))
print(df)
new_column A B C D
0 1 1 1 1 1
1 2 2 2 2 2
2 3 3 3 3 3
3 4 4 4 4 4
5.2.3修改数据
- 修改列的值
#修改数据
data = {
"A":[ 1,2,3,4],
"B":[ 1,2,3,4],
"C":[ 1,2,3,4],
"D":[ 1,2,3,4],
}
df = pd.DataFrame(data)
# 修改指定行指定列的值
df['B']=[10,20,30,40]
print(df)
df['B']=df['A']+20#广播
print(df)
A B C D
0 1 10 1 1
1 2 20 2 2
2 3 30 3 3
3 4 40 4 4
A B C D
0 1 21 1 1
1 2 22 2 2
2 3 23 3 3
3 4 24 4 4
- 修改列名
#修改数据
data = {
"A":[ 1,2,3,4],
"B":[ 1,2,3,4],
"C":[ 1,2,3,4],
"D":[ 1,2,3,4],
}
df = pd.DataFrame(data)
# 修改指定行指定列的值
# df['B']=[10,20,30,40]
# print(df)
# df['B']=df['A']+20#广播
# print(df)
#修改列名
#1.columns属性
df.columns = ['a','b','c','d']
print(df)
a b c d
0 1 1 1 1
1 2 2 2 2
2 3 3 3 3
3 4 4 4 4
- 使用 rename 方法修改列名
data = {
"A":[ 1,2,3,4],
"B":[ 1,2,3,4],
"C":[ 1,2,3,4],
"D":[ 1,2,3,4],
}
df = pd.DataFrame(data)
#2.rename()方法
df.rename(columns={'a':'E','b':'F','c':'G','d':'H'},inplace=True)
print(df)
A B C D
0 1 1 1 1
1 2 2 2 2
2 3 3 3 3
3 4 4 4 4
- 修改列的数据类型
#修改数据类型，astype()
data = {
"A":[ 1,2,3,4],
"B":[ 1,2,3,4],
}
df = pd.DataFrame(data)
df['A']=df['A'].astype('float64')
df['B']=df['B'].astype('float64')
print(df)
print(df.dtypes)
A B
0 1.0 1.0
1 2.0 2.0
2 3.0 3.0
3 4.0 4.0
A float64
B float64
dtype: object
5.2.4删除数据
通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame
参数：
- labels：
- 类型：单个标签或列表。
- 描述：要删除的行或列的标签。如果 axis=0，则 labels 表示行标签；如果 axis=1，则 labels 表示列标签。
- axis：
- 类型：整数或字符串，默认为 0。
- 描述：指定删除的方向。axis=0 或 axis=‘index’ 表示删除行，axis=1 或 axis=‘columns’ 表示删除列。
- index：
- 类型：单个标签或列表，默认为 None。
- 描述：要删除的行的标签。如果指定，则忽略 labels 参数。
- columns：
- 类型：单个标签或列表，默认为 None。
- 描述：要删除的列的标签。如果指定，则忽略 labels 参数。
- level：
- 类型：整数或级别名称，默认为 None。
- 描述：用于多级索引（MultiIndex），指定要删除的级别。
- inplace：
- 类型：布尔值，默认为 False。
- 描述：如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。
- errors：
- 类型：字符串，默认为 ‘raise’。
- 描述：指定如何处理不存在的标签。‘raise’ 表示抛出错误，‘ignore’ 表示忽略错误。
drop()
labels：
axis:轴方向
index:行
columns:列
inplace:是否修改原数据
data= {
"A":[ 1,2,3,4],
"B":[ 6,7,8,9],
}
data = pd.DataFrame(data)
print(data)
#使用drop删除行和列
df1 = data.drop(['A'],axis=1)
print(df1)
df2= data.drop(columns=['A'])
print(df2)
A B
0 1 6
1 2 7
2 3 8
3 4 9
B
0 6
1 7
2 8
3 9
B
0 6
1 7
2 8
3 9
5.3行索引操作
5.3.1 loc 选取数据
df.loc[] 只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）
loc方法返回的数据类型：
1.如果选择单行或单列，返回的数据类型为Series
2.选择多行或多列，返回的数据类型为DataFrame
3.选择单个元素(某行某列对应的值)，返回的数据类型为该元素的原始数据类型（如整数、浮点数等）。
DataFrame.loc[row_indexer, column_indexer]
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
#基于标签获取数据
# 使用 loc 选择数据
print(df.loc['a']) # 选择行标签为 'a' 的行
print(df.loc['a':'c']) # 选择行标签从 'a' 到 'c' 的行
print(df.loc['a', 'B']) # 选择行标签为 'a'，列标签为 'B' 的元素
print(df.loc[['a', 'c'], ['A', 'C']]) # 选择行标签为 'a' 和 'c'，列标签为 'A' 和 'C' 的数据
A 1
B 5
C 9
Name: a, dtype: int64
A B C
a 1 5 9
b 2 6 10
c 3 7 11
5
A C
a 1 9
c 3 11
5.3.2 iloc 选取数据
iloc 方法用于基于位置（integer-location based）的索引，即通过行和列的整数位置来选择数据。
# iloc基于索引获取数据
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])
print(df)
print(df.iloc[0])## 选择第 0 行的数据
print(df.iloc[0:2]) # 选择第 0 到 1 行的数据
print(df.iloc[0, 1])# 选择第 0 行，第 1 列的元素
print(df.iloc[[0, 2], [0, 2]]) # 选择第 0 和 2 行，第 0 和 2 列的数据
A B C
a 1 5 9
b 2 6 10
c 3 7 11
d 4 8 12
A 1
B 5
C 9
Name: a, dtype: int64
A B C
a 1 5 9
b 2 6 10
5
A C
a 1 9
c 3 11
5.3.3 切片多行选取
通过切片的方式进行多行数据的选取
#切片多行选取
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print(df[0:3])
A B C
0 1 5 9
1 2 6 10
2 3 7 11
5.3.4添加数据行
loc方法添加新行
#
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data,index=['a','b','c','d'])
df.loc['e']=[13,14,15]
print(df)
A B C
a 1 5 9
b 2 6 10
c 3 7 11
d 4 8 12
e 13 14 15
concat拼接
pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)
参数：
objs: 要连接的 DataFrame 或 Series 对象的列表或字典。
axis: 指定连接的轴，0 或 ‘index’ 表示按行连接，1 或 ‘columns’ 表示按列连接。
join: 指定连接方式，‘outer’ 表示并集（默认），‘inner’ 表示交集。
ignore_index: 如果为 True，则忽略原始索引并生成新的索引。
keys: 用于在连接结果中创建层次化索引。
levels: 指定层次化索引的级别。
names: 指定层次化索引的名称。
verify_integrity: 如果为 True，则在连接时检查是否有重复索引。
sort: 如果为 True，则在连接时对列进行排序。
copy: 如果为 True，则复制数据。
#concat()：连接多个 DataFrame
data1 = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
data2 = {
'A': [13, 14, 15, 16],
'B': [17, 18, 19, 20],
'C': [21, 22, 23, 24]
}
result = pd.concat([pd.DataFrame(data1), pd.DataFrame(data2)], )
print(result)
#按列拼接
result = pd.concat([pd.DataFrame(data1), pd.DataFrame(data2)], axis=1, )
print(result)
A B C
0 1 5 9
1 2 6 10
2 3 7 11
3 4 8 12
0 13 17 21
1 14 18 22
2 15 19 23
3 16 20 24
A B C A B C
0 1 5 9 13 17 21
1 2 6 10 14 18 22
2 3 7 11 15 19 23
3 4 8 12 16 20 24
使用 ignore_index
df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
})
df2 = pd.DataFrame({
'A': [7, 8, 9],
'B': [10, 11, 12]
})
# 按行连接 df1 和 df2，并忽略原始索引
result = pd.concat([df1, df2], axis=0, ignore_index=True)
print(result)
A B
0 1 4
1 2 5
2 3 6
3 7 10
4 8 11
5 9 12
使用 join=‘inner’，按行合并
# 使用join='inner',按行合并
df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': [4, 5, 6]
})
df2 = pd.DataFrame({
'A': [7, 8, 9],
'B': [10, 11, 12]
})
# 按行连接 df1 和df2，并忽略原始索引
result = pd.concat([df1, df2], axis=0, join='inner')
print(result)
#按行连接 df1 和 df2，并忽略原始索引
result = pd.concat([df1, df2], axis=1, join='outer')
print(result)
A B
0 1 4
1 2 5
2 3 6
0 7 10
1 8 11
2 9 12
A B A B
0 1 4 7 10
1 2 5 8 11
2 3 6 9 12
5.3.5 删除数据行
您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。使用的是 drop 函数
#删除数据行
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print(df)
df.drop(0,inplace=True)
print(df)
A B C
0 1 5 9
1 2 6 10
2 3 7 11
3 4 8 12
A B C
1 2 6 10
2 3 7 11
3 4 8 12
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
