xyZGHio

樱花同载酒，终似少年游

0%

浅谈Pandas之DataFrame

发表于 阅读数： 评论数：
本文字数： 23k 阅读时长 ≈ 47 分钟

这里介绍Pandas中的核心数据结构——DataFrame

abstract.png

楔子

DataFrame作为Pandas中的核心数据结构，其本质是一个二维的表格。其具有列索引、行索引。前者即为列名，用于标识每列的数据，默认从0开始；后者则用于标识每行数据，默认从0开始

创建

通过字典创建DataFrame

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas as pd


# key为列名，value为列数据
dict = {
    "name": ["Bob","Aaron","Tina"],
    "age": [35,18,69],
    "male": [True, True, False],
}
df = pd.DataFrame(dict)
print(f"dict 类型: {type(dict)}\n")
print(f"dict: {dict}\n")
print(f"df 类型: {type(df)}\n")
print(f"df:\n{df}\n")

输出：

1
2
3
4
5
6
7
8
9
10
11
dict 类型: <class 'dict'>

dict: {'name': ['Bob', 'Aaron', 'Tina'], 'age': [35, 18, 69], 'male': [True, True, False]}

df 类型: <class 'pandas.core.frame.DataFrame'>

df:
    name  age   male
0    Bob   35   True
1  Aaron   18   True
2   Tina   69  False

通过列表创建DataFrame

1
2
3
4
5
6
7
8
9
10
11
12
13
import pandas as pd


list = [
    ["Bob", 35, True],
    ["Aaron", 18, True],
    ["Tina", 69, False],
]
df = pd.DataFrame(list, columns=["name","age","male"])
print(f"list 类型: {type(list)}\n")
print(f"list: {list}\n")
print(f"df 类型: {type(df)}\n")
print(f"df:\n{df}\n")

输出：

1
2
3
4
5
6
7
8
9
10
11
list 类型: <class 'list'>

list: [['Bob', 35, True], ['Aaron', 18, True], ['Tina', 69, False]]

df 类型: <class 'pandas.core.frame.DataFrame'>

df:
    name  age   male
0    Bob   35   True
1  Aaron   18   True
2   Tina   69  False

通过字典的列表创建DataFrme

1
2
3
4
5
6
7
8
9
10
import pandas as pd


list = [
    {'name': 'Bob', 'age': 35, 'male': True},
    {'name': 'Aaron', 'age': 18, 'male': True},
    {'name': 'Tina', 'age': 69, 'male': False},
]
df = pd.DataFrame(list)
print(f"df:\n{df}")

输出：

1
2
3
4
5
df:
    name  age   male
0    Bob   35   True
1  Aaron   18   True
2   Tina   69  False

通过NumPy数组创建DataFrame

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas as pd
import numpy as np


array = np.array([
    ["Bob", 35, True],
    ["Aaron", 18, True],
    ["Tina", 69, False],
])
df = pd.DataFrame(array, columns=["name","age","male"])
print(f"array 类型: {type(array)}\n")
print(f"array:\n{array}\n")
print(f"df 类型: {type(df)}\n")
print(f"df:\n{df}\n")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
array 类型: <class 'numpy.ndarray'>

array:
[['Bob' '35' 'True']
 ['Aaron' '18' 'True']
 ['Tina' '69' 'False']]

df 类型: <class 'pandas.core.frame.DataFrame'>

df:
    name age   male
0    Bob  35   True
1  Aaron  18   True
2   Tina  69  False

通过Series创建DataFrame

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas as pd

s1 = pd.Series( ["Bob","Aaron","Tina"] )
s2 = pd.Series( [35,18,69] )
s3 = pd.Series( [True,True,False] )
df = pd.DataFrame({'name': s1, 'age': s2, 'male': s3})

print(f"s1 类型: {type(s1)}\n")

print(f"s1:\n{s1}\n")
print(f"s2:\n{s2}\n")
print(f"s3:\n{s3}\n")

print(f"df 类型: {type(df)}\n")
print(f"df:\n{df}\n")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
s1 类型: <class 'pandas.core.sEries.series'>

s1:
0      Bob
1    Aaron
2     Tina
dtype: object

s2:
0    35
1    18
2    69
dtype: int64

s3:
0     True
1     True
2    False
dtype: bool

df 类型: <class 'pandas.core.frame.DataFrame'>

df:
    name  age   male
0    Bob   35   True
1  Aaron   18   True
2   Tina   69  False

基本信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
    ["Watermelon", 3.3, 5, False],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])

print(f"\n形状: {df.shape}\n") 
print(f"\n各列的数据类型:\n{df.dtypes}\n")
print(f"\n列名: {df.columns}\n") 
print(f"\n行索引: {df.index}\n") 

# 获取数据部分（NumPy数组格式）
data = df.values
print(f"\n数据内容的类型: {type(data)}, 数据内容: {data}\n") 

print("#"*10, " 基本信息 ", "#"*20)
print(df.info())
print("#"*42,"\n")

print("#"*10, " 统计信息 ", "#"*20)
print(df.describe())
print("#"*42,"\n")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
形状: (4, 4)


各列的数据类型:
种类     object
价格    float64
数量      int64
进口       bool
dtype: object


列名: Index(['种类', '价格', '数量', '进口'], dtype='object')


行索引: RangeIndex(start=0, stop=4, step=1)


数据内容的类型: <class 'numpy.ndarray'>, 数据内容: [['Apple' 2.2 100 True]
 ['Banana' 4.4 200 False]
 ['Orange' nan 0 True]
 ['Watermelon' 3.3 5 False]]

##########  基本信息  ####################
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   种类      4 non-null      object 
 1   价格      3 non-null      float64
 2   数量      4 non-null      int64  
 3   进口      4 non-null      bool   
dtypes: bool(1), float64(1), int64(1), object(1)
memory usage: 228.0+ bytes
None
########################################## 

##########  统计信息  ####################
         价格          数量
count  3.00    4.000000
mean   3.30   76.250000
std    1.10   94.461191
min    2.20    0.000000
25%    2.75    3.750000
50%    3.30   52.500000
75%    3.85  125.000000
max    4.40  200.000000
##########################################

修改索引名称

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import pandas as pd


# DataFrame的列索引(列名)、行索引 默认均为从0开始的数字索引
list = [
    ["Apple", 5.9, True],
    ["Banana", 7.3, False],
    ["Orange", 29, True],
]
df = pd.DataFrame(list)
print(f"\n#1 df : \n{df}")

# 设置列名
df.columns = ["Kind","Price", "进口"]
# 设置行索引
df.index = ["KK11", "K2", "K3"]
print(f"\n#2 df : \n{df}\n")

# 修改单个列名/行索引, inplace设为True：在原始DataFrame上进行修改，而不是返回一个新的DataFrame
df.rename(columns={'进口': 'Import'}, inplace=True)
df.rename(index={'KK11': 'K1'}, inplace=True)
print(f"\n#3 df : \n{df}\n")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#1 df : 
        0     1      2
0   Apple   5.9   True
1  Banana   7.3  False
2  Orange  29.0   True

#2 df : 
        Kind  Price     进口
KK11   Apple    5.9   True
K2    Banana    7.3  False
K3    Orange   29.0   True


#3 df : 
      Kind  Price  Import
K1   Apple    5.9    True
K2  Banana    7.3   False
K3  Orange   29.0    True

查看/修改类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import pandas as pd


list = [
    ["Apple", 5.9, True],
    ["Banana", 7.3, False],
    ["Orange", 29, True],
]
column_names = ["Kind","Price", "Import"]
df = pd.DataFrame(list, columns=column_names)
# 查看指定列的数据类型
for column_name in column_names:
    print(f"{column_name}列的数据类型: { df[column_name].dtype}")

# 将 Price 列的数据类型从 float64 修改为 float32
df['Price'] = df["Price"].astype('float32')

# 查看DataFrame中各列的数据类型
print(f"\n各列的数据类型:\n{df.dtypes}")

输出：

1
2
3
4
5
6
7
8
9
kind列的数据类型: object
Price列的数据类型: float64
Import列的数据类型: bool

各列的数据类型:
Kind       object
Price     float32
Import       bool
dtype: object

查询/索引

查询头尾

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
    ["Watermelon", 3.3, 5, False],
    ["Lemon", 13.3, 798, False],
    ["Cherry", 53, 1294, True],
    ["Guava", 29.4, 45, True],
    ["Pear", 1.1, 493, False],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])

# 查看前n行数据。n默认为5
df1 = df.head(3)
print(f"df1 类型: {type(df1)}, 数据: \n{df1}")

# 查看后n行数据。n默认为5
df2 = df.tail(3)
print(f"\nf2 类型: {type(df2)}, 数据: \n{df2}")

输出：

1
2
3
4
5
6
7
8
9
10
11
df1 类型: <class 'pandas.core.FramE.dataframe'>, 数据: 
       种类   价格   数量     进口
0   Apple  2.2  100   True
1  Banana  4.4  200  False
2  Orange  NaN    0   True

f2 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
       种类    价格    数量     进口
5  Cherry  53.0  1294   True
6   Guava  29.4    45   True
7    Pear   1.1   493  False

索引 []

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
    ["Cherry", 3.3, 5, False],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"], index=["f1","f2","f3","f4"])
print(f"df:\n{df}")

# 使用 df[列名/列名列表] 方式, 可以方便地从DataFrame中选择指定列
s1 = df["种类"]
print(f"\ns1 类型: {type(s1)}, 数据: \n{s1}")

df2 = df[ ['种类','数量'] ]
print(f"\ndf2 类型: {type(df2)}, 数据: \n{df2}")

# 使用 布尔索引Series/列表 筛选出True对应的行
# 筛选: 进口水果 且 数量大于0
row_condition = (df['进口']==True) & (df["数量"]>0)
df3 = df[ row_condition ]
print(f"\nrow_condition 类型: {type(row_condition)}, 数据: \n{row_condition}")
print(f"\ndf3 类型: {type(df3)}, 数据: \n{df3}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
df:
        种类   价格   数量     进口
f1   Apple  2.2  100   True
f2  Banana  4.4  200  False
f3  Orange  NaN    0   True
f4  Cherry  3.3    5  False

s1 类型: <class 'pandas.core.series.Series'>, 数据: 
f1     Apple
f2    Banana
f3    Orange
f4    Cherry
Name: 种类, dtype: object

df2 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   数量
f1   Apple  100
f2  Banana  200
f3  Orange    0
f4  Cherry    5

row_condition 类型: <class 'pandas.core.series.Series'>, 数据: 
f1     True
f2    False
f3    False
f4    False
dtype: bool

df3 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
       种类   价格   数量    进口
f1  Apple  2.2  100  True

标签索引 loc[]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
    ["Cherry", 3.3, 5, False],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"], index=["f1","f2","f3","f4"])
print(f"df:\n{df}")

# 基于标签(行索引、列名)索引
# 可通过 df.loc[行标签, 列标签] 实现。其中，行标签是必选的；列标签则是可选的

# 使用 单个行标签 选择 单行, 返回Series
s1 = df.loc["f3"]
print(f"\ns1 类型: {type(s1)}, 数据: \n{s1}")

# 使用 行标签列表 选择 多行, 返回DataFrame
df1 = df.loc[["f4","f1"]]
print(f"\ndf1 类型: {type(df1)}, 数据: \n{df1}")

# 选择指定单元格, 返回值
v1 = df.loc['f1', '价格']
print(f"\nv1 类型: {type(v1)}, 数据: {v1}")

# 切片。选择从开始标签(包含)到结束标签(包含)。如果使用:表示全部选择 
df2 = df.loc[ ["f3","f1"], "种类":"数量" ]
print(f"\ndf2 类型: {type(df2)}, 数据: \n{df2}")

df3 = df.loc[ :, "种类":"数量" ]
print(f"\ndf3 类型: {type(df3)}, 数据: \n{df3}")

# 布尔索引: 使用 布尔Series/布尔列表 选择对应位置为True的元素, 其返回的是一个Series
row_mask = df["数量"] > 50
col_mask = [True, True, True, False]
df4 = df.loc[ row_mask, col_mask ]
print(f"\ndf4 类型: {type(df4)}, 数据: \n{df4}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
df:
        种类   价格   数量     进口
f1   Apple  2.2  100   True
f2  Banana  4.4  200  False
f3  Orange  NaN    0   True
f4  Cherry  3.3    5  False

s1 类型: <class 'pandas.core.series.Series'>, 数据: 
种类    Orange
价格       NaN
数量         0
进口      True
Name: f3, dtype: object

df1 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   价格   数量     进口
f4  Cherry  3.3    5  False
f1   Apple  2.2  100   True

v1 类型: <class 'numpy.float64'>, 数据: 2.2

df2 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   价格   数量
f3  Orange  NaN    0
f1   Apple  2.2  100

df3 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   价格   数量
f1   Apple  2.2  100
f2  Banana  4.4  200
f3  Orange  NaN    0
f4  Cherry  3.3    5

df4 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   价格   数量
f1   Apple  2.2  100
f2  Banana  4.4  200

物理位置索引 iloc[]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
    ["Cherry", 3.3, 5, False],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"], index=["f1","f2","f3","f4"])
print(f"df:\n{df}")

#基于物理位置(行位置、列位置)索引, 从0开始计数
# 可通过 df.iloc[行位置, 列位置] 实现。其中，行位置是必选的；列位置则是可选的

# 使用 单个行位置 选择 单行, 返回Series
s1 = df.iloc[0]
print(f"\ns1 类型: {type(s1)}, 数据: \n{s1}")

# 使用 行位置列表 选择 多行, 返回DataFrame
df1 = df.iloc[ [1,3] ]
print(f"\ndf1 类型: {type(df1)}, 数据: \n{df1}")

# 选择指定单元格, 返回值
v1 = df.iloc[1,2]
print(f"\nv1 类型: {type(v1)}, 数据: {v1}")

# 切片: 选择从开始位置(包含)到结束位置(不包含)。如果使用:表示全部选择 
df2 = df.iloc[0:2]
print(f"\ndf2 类型: {type(df2)}, 数据: \n{df2}")

df3 = df.iloc[:, 0:2]
print(f"\ndf3 类型: {type(df3)}, 数据: \n{df3}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
df:
        种类   价格   数量     进口
f1   Apple  2.2  100   True
f2  Banana  4.4  200  False
f3  Orange  NaN    0   True
f4  Cherry  3.3    5  False

s1 类型: <class 'pandas.core.series.Series'>, 数据: 
种类    Apple
价格      2.2
数量      100
进口     True
Name: f1, dtype: object

df1 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   价格   数量     进口
f2  Banana  4.4  200  False
f4  Cherry  3.3    5  False

v1 类型: <class 'numpy.int64'>, 数据: 200

df2 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   价格   数量     进口
f1   Apple  2.2  100   True
f2  Banana  4.4  200  False

df3 类型: <class 'pandas.core.frame.DataFrame'>, 数据: 
        种类   价格
f1   Apple  2.2
f2  Banana  4.4
f3  Orange  NaN
f4  Cherry  3.3

索引单元格 at[] / iat[]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
    ["Cherry", 3.3, 5, False],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"], index=["f1","f2","f3","f4"])
print(f"df:\n{df}")

# 基于标签(行索引、列名)索引 特定单元格。 可通过 df.at[行标签, 列标签] 实现
v1 = df.at["f2","种类"]
print(f"\nv1 类型: {type(v1)}, 数据: {v1}")

# 基于位置(行位置、列位置)索引 特定单元格。 可通过 df.iat[行位置, 列位置] 实现
v2 = df.iat[3,2]
print(f"\nv2 类型: {type(v2)}, 数据: {v2}")

输出：

1
2
3
4
5
6
7
8
9
10
df:
        种类   价格   数量     进口
f1   Apple  2.2  100   True
f2  Banana  4.4  200  False
f3  Orange  NaN    0   True
f4  Cherry  3.3    5  False

v1 类型: <class 'str'>, 数据: Banana

v2 类型: <class 'numpy.int64'>, 数据: 5

列管理

添加列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pandas as pd
import numpy as np

list = [
    ["Apple", 2.2],
    ["Banana", 4.4],
    ["Orange", np.nan],
]
df = pd.DataFrame(list, columns=["种类","价格"])
print(f"\n#1 df:\n{df}")

# 在指定列(从0开始计数)插入列
goods_codes = ["G001", "G003", "G002"]
df.insert(1, '商品编码', goods_codes)

# 追加列：所有行 该列的值均为同一个
df['进口'] = True

# 追加列：使用列表为每一行设定不同的值
df['数量'] = [17, 34, 0]
print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
#1 df:
       种类   价格
0   Apple  2.2
1  Banana  4.4
2  Orange  NaN

#2 df:
       种类  商品编码   价格    进口  数量
0   Apple  G001  2.2  True  17
1  Banana  G003  4.4  True  34
2  Orange  G002  NaN  True   0

删除列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas as pd
import numpy as np

list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])
print(f"\n#1 df:\n{df}")

# 删除指定列。inplace为True：在原DataFrame中进行修改
df.drop(columns=['价格', '进口'], inplace=True)
print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
#1 df:
       种类   价格   数量     进口
0   Apple  2.2  100   True
1  Banana  4.4  200  False
2  Orange  NaN    0   True

#2 df:
       种类   数量
0   Apple  100
1  Banana  200
2  Orange    0

修改列

直接赋值/计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])
print(f"\n#1 df:\n{df}")

df["进口"] = True
df["价格"] = [np.nan, np.nan, 12.8]
df['数量'] = df["数量"] + 8
print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
#1 df:
       种类   价格   数量     进口
0   Apple  2.2  100   True
1  Banana  4.4  200  False
2  Orange  NaN    0   True

#2 df:
       种类    价格   数量    进口
0   Apple   NaN  108  True
1  Banana   NaN  208  True
2  Orange  12.8    8  True

替换：map()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])
print(f"\n#1 df:\n{df}")

dict = {
    "Orange":"橘子",
    "Apple":"苹果",
    "Watermelon":"西瓜",
}

# map()函数: 根据字典的映射关系进行替换。对于字典中不存在的Key，则会替换为NaN
df["种类"] = df["种类"].map( dict )
print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
#1 df:
       种类   价格   数量     进口
0   Apple  2.2  100   True
1  Banana  4.4  200  False
2  Orange  NaN    0   True

#2 df:
    种类   价格   数量     进口
0   苹果  2.2  100   True
1  NaN  4.4  200  False
2   橘子  NaN    0   True

替换：replace()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])
print(f"\n#1 df:\n{df}")

# 替换一个值为另一个
df["价格"] = df["价格"].replace(np.nan, -1)

# 替换多个值为同一个值
df["数量"] = df["数量"].replace([100,0], 999)

# 使用字典进行替换，对于字典中不存在的Key，则会保留原值
dict = {
    "Orange":"橘子",
    "Apple":"苹果",
    "Watermelon":"西瓜",
}
df["种类"] = df["种类"].replace(dict)

print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
#1 df:
       种类   价格   数量     进口
0   Apple  2.2  100   True
1  Banana  4.4  200  False
2  Orange  NaN    0   True

#2 df:
       种类   价格   数量     进口
0      苹果  2.2  999   True
1  Banana  4.4  200  False
2      橘子 -1.0  999   True

apply()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas as pd
import numpy as np


# apply()函数: 使用自定义函数对该列的每个值进行修改
list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", np.nan, 0, True],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])
print(f"\n#1 df:\n{df}")

df["价格"] = df["价格"].apply( lambda x : 38 if pd.isnull(x) else x*10 )
print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
#1 df:
       种类   价格   数量     进口
0   Apple  2.2  100   True
1  Banana  4.4  200  False
2  Orange  NaN    0   True

#2 df:
       种类    价格   数量     进口
0   Apple  22.0  100   True
1  Banana  44.0  200  False
2  Orange  38.0    0   True

条件修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd


list = [
    ["Apple", 2.2, 10, True],
    ["Banana", 4.4, 20, False],
    ["Orange", 3.3, 30, True],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"])
print(f"\n#1 df:\n{df}")

# 对 进口水果涨价 100 倍
row_condition = df['进口'] == True
# 通过 loc()函数 进行条件筛选，然后对筛选出的结果进行赋值
df.loc[ row_condition, '价格' ] = df.loc[ row_condition, '价格' ] * 100
print(f"\nrow_condition 类型: {type(row_condition)}, 数据:\n{row_condition}")
print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#1 df:
       种类   价格  数量     进口
0   Apple  2.2  10   True
1  Banana  4.4  20  False
2  Orange  3.3  30   True

row_condition 类型: <class 'pandas.core.series.Series'>, 数据:
0     True
1    False
2     True
Name: 进口, dtype: bool

#2 df:
       种类     价格  数量     进口
0   Apple  220.0  10   True
1  Banana    4.4  20  False
2  Orange  330.0  30   True

行管理

添加行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2],
    ["Banana", 4.4],
    ["Orange", np.nan],
]
df = pd.DataFrame(list, columns=["种类","价格"])
print(f"\n#1 df:\n{df}")

# 通过loc函数对一个不存在的行索引赋值来添加单行 
df.loc[9] =  ["Lemon", 13.3]
print(f"\n#2 df:\n{df}")

# 通过拼接两个DataFrame实现添加多行
new_df = pd.DataFrame([
    {'种类': 'Watermelon', '价格': 45},
    {'种类': 'Cherry', '价格': 32}
])
# ignore_index=True: 重新生成一个从0开始的行索引
df = pd.concat([df, new_df], ignore_index=True)
print(f"\n#3 new_df:\n{new_df}")
print(f"\n#4 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#1 df:
       种类   价格
0   Apple  2.2
1  Banana  4.4
2  Orange  NaN

#2 df:
       种类    价格
0   Apple   2.2
1  Banana   4.4
2  Orange   NaN
9   Lemon  13.3

#3 new_df:
           种类  价格
0  Watermelon  45
1      Cherry  32

#4 df:
           种类    价格
0       Apple   2.2
1      Banana   4.4
2      Orange   NaN
3       Lemon  13.3
4  Watermelon  45.0
5      Cherry  32.0

删除行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import pandas as pd
import numpy as np


list = [
    ["Apple", 2.2],
    ["Banana", 4.4],
    ["Orange", np.nan],
    ["Cherry", 402],
    ["Lemon", 79],
    ["Watermelon", 332],
]
df = pd.DataFrame(list, columns=["种类","价格"])
print(f"\n#1 df:\n{df}")

# 删除指定行索引的行。inplace为True：在原DataFrame中进行修改
df.drop(index=[0,2], inplace=True)
print(f"\n#2 df:\n{df}")

# 可以使用 布尔索引Series/列表 筛选出想要的行，从而达到删除某些不想要的行的目的
# 删除价格<=300的水果 -->> 筛选出价格大于300的水果
row_condition = df['价格']>300
df = df[row_condition]
print(f"\nrow_condition 类型: {type(row_condition)}, 数据: \n{row_condition}")
print(f"\n#3 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#1 df:
           种类     价格
0       Apple    2.2
1      Banana    4.4
2      Orange    NaN
3      Cherry  402.0
4       Lemon   79.0
5  Watermelon  332.0

#2 df:
           种类     价格
1      Banana    4.4
3      Cherry  402.0
4       Lemon   79.0
5  Watermelon  332.0

row_condition 类型: <class 'pandas.core.series.Series'>, 数据: 
1    False
3     True
4    False
5     True
Name: 价格, dtype: bool

#3 df:
           种类     价格
3      Cherry  402.0
5  Watermelon  332.0

修改行

直接修改/赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import pandas as pd


list = [
    ["Apple", 2.2, 100, True],
    ["Banana", 4.4, 200, False],
    ["Orange", 78, 32, True],
    ["Cherry", 127, 44, False],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","进口"], index=["c1","c2","c3","c4"])
print(f"\n#1 df:\n{df}")

# 修改指定单元格
df.loc["c1", "价格"] = 1.95

# 使用索引修改单行
df.loc["c2"] = ['香蕉', 99.99, 999, True]

# 使用切片修改多行
df.loc["c3":"c4"]  = [
    ['橘子', 33.33, 333, False],
    ['车厘子', 44.44, 444, True]
]

print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
#1 df:
        种类     价格   数量     进口
c1   Apple    2.2  100   True
c2  Banana    4.4  200  False
c3  Orange   78.0   32   True
c4  Cherry  127.0   44  False

#2 df:
       种类     价格   数量     进口
c1  Apple   1.95  100   True
c2     香蕉  99.99  999   True
c3     橘子  33.33  333  False
c4    车厘子  44.44  444   True

apply()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import pandas as pd

list = [
    ["Apple", 2.2, 100, "A"],
    ["Banana", 4.4, 200, "C"],
    ["Orange", 7.7, 32, "B"],
    ["Cherry", 9.9, 44, "A"],
]
df = pd.DataFrame(list, columns=["种类","价格", "数量","等级"], index=["c1","c2","c3","c4"])
print(f"\n#1 df:\n{df}\n")


def modify_by_level(row):
    """
    根据水果的等级调整商品信息
    """
    print(f"\nrow 类型:{type(row)}, 数据: {row}")
    level = row['等级']
    if level=="A":
        row['价格'] = row['价格'] * 100
        row['种类'] = row['种类'].upper()
    elif level == "B":
        row['价格'] = row['价格'] + 20
        row['数量'] = row['数量'] - 10
    elif level == "C":
        row['价格'] = row['价格'] + 5
        row['数量'] = row['数量'] - 50

    return row

# axis=1: 对每一行数据使用modify_by_level函数进行处理
df = df.apply(modify_by_level, axis=1)
print(f"\n#2 df:\n{df}")

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#1 df:
        种类   价格   数量 等级
c1   Apple  2.2  100  A
c2  Banana  4.4  200  C
c3  Orange  7.7   32  B
c4  Cherry  9.9   44  A


row 类型:<class 'pandas.core.series.Series'>, 数据: 种类    Apple
价格      2.2
数量      100
等级        A
Name: c1, dtype: object

row 类型:<class 'pandas.core.series.Series'>, 数据: 种类    Banana
价格       4.4
数量       200
等级         C
Name: c2, dtype: object

row 类型:<class 'pandas.core.series.Series'>, 数据: 种类    Orange
价格       7.7
数量        32
等级         B
Name: c3, dtype: object

row 类型:<class 'pandas.core.series.Series'>, 数据: 种类    Cherry
价格       9.9
数量        44
等级         A
Name: c4, dtype: object

#2 df:
        种类     价格   数量 等级
c1   APPLE  220.0  100  A
c2  Banana    9.4  150  C
c3  Orange   27.7   22  B
c4  CHERRY  990.0   44  A
推荐文章
请我喝杯咖啡捏～

欢迎关注我的微信公众号：青灯抽丝