安装

1
pip3 install pandas

pandas快速入门

1 pandas擅长处理哪些数据

在处理表格数据时，例如存储在电子表格或数据库中的数据，pandas是适合您的工具。pandas将帮助您探索、清理和处理数据。在pandas中，数据表称为DataFrame。

要加载pandas包并开始使用它，请导入该包。社区一致使用的pandas别名是pd，因此将pandas加载为pd是所有pandas文档的标准做法：

1
import pandas as pd

2 创建DataFrame

下面是一个简单的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import pandas as pd
mydataset = {
  'sites': ["aaa", "bbb", "ccc"],
  'number': [1, 2, 3]
}
myvar = pd.DataFrame(mydataset)
print(myvar)
"""
输出：
  sites  number
0   aaa       1
1   bbb       2
2   ccc       3
"""

二维数组的手动创建使用DataFrame方法，使用字典+列表来创建时，字典的key将用作列标题，对应的value列表中的值将用作DataFrame的列。DataFrame是一种二维数据结构，可以在列中存储不同类型的数据（包括字符、整数、浮点值、分类数据等），非常类似于excel表格数据。

还可以使用字典创建：

1
2
3
4
5
6
7
8
9
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print(df)
"""
输出：
   a   b     c
0  1   2   NaN
1  5  10  20.0
"""

没有对应的部分数据为NaN。

使用loc属性返回指定行的数据，如果没有设置索引，第一行索引为 0，第二行索引为 1，以此类推：

1
2
3
4
5
6
7
8
print(df.loc[1]) # 输出第二行
"""
输出：
a     5.0
b    10.0
c    20.0
Name: 1, dtype: float64
"""

还可以返回多行数据：

1
2
3
4
5
6
7
print(df.loc[[0,1]]) # 返回第一行和第二行
"""
输出：
   a   b     c
0  1   2   NaN
1  5  10  20.0
"""

如果我们只关心某一列的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
mydataset = {
  'sites': ["aaa", "bbb", "ccc"],
  'number': [1, 2, 3]
}
myvar = pd.DataFrame(mydataset)
print(myvar["number"])
"""
输出：
0    1
1    2
2    3
Name: number, dtype: int64
"""

使用方括号即可选择单列，在选择pandas中DataFrame的单列/单行时，结果是Series类型，也就是pandas中的一维数组。

和返回多行类似，也可以返回多列：

1
2
3
4
5
6
7
8
9
10
11
12
13
mydataset = {
  'sites': ["aaa", "bbb", "ccc"],
  'number': [1, 2, 3]
}
myvar = pd.DataFrame(mydataset)
print(myvar[["sites","number"]]) # 返回sites和number列
"""
输出：
  sites  number
0   aaa       1
1   bbb       2
2   ccc       3
"""

3 创建Series

Series类似表格中的一个列（column），可以保存任何数据类型。

1
2
3
4
5
6
7
8
9
ages = pd.Series([22, 35, 58], name="Age")
print(ages)
"""
输出：
0    22
1    35
2    58
Name: Age, dtype: int64
"""

其中，左侧的0，1，2为索引，右侧对应的是数据。

一维数组的手动创建使用Series方法，它的参数为：

1
pandas.Series( data, index, dtype, name, copy)

参数说明：

  • data：一组数据(ndarray类型/python列表/字典)。
  • index：数据索引标签，如果不指定，默认从 0 开始。
  • dtype：数据类型，默认会自己判断。
  • name：设置名称。
  • copy：拷贝数据，默认为False。

通过索引可以获取数据，同样使用中括号即可：

1
2
3
4
5
6
ages = pd.Series([22, 35, 58], name="Age")
print(ages[1])
"""
输出：
35
"""

索引默认从0开始，也可以自己手动指定：

1
2
3
4
5
6
7
8
9
10
11
12
13
a = ["aaa", "bbb", "ccc"]

myvar = pd.Series(a, index = ["x", "y", "z"])
print(myvar)
print(myvar["y"])
"""
输出：
x    aaa
y    bbb
z    ccc
dtype: object
bbb
"""

一维数组的创建也可以通过字典创建：

1
2
3
4
5
6
7
8
9
10
11
dic={1:"aaa",2:"bbb",3:"ccc"}
myvar = pd.Series(dic)

print(myvar)
"""
输出：
1    aaa
2    bbb
3    ccc
dtype: object
"""

可见字典的key变成了索引值。如果我们只需要字典中的一部分数据，只需要指定需要数据的索引即可：

1
2
dic={1:"aaa",2:"bbb",3:"ccc"}
myvar = pd.Series(dic,index=[1,2]) # 只需要索引1，2的数据

4 基于一维和二维数组进行操作

使用max输出最大的元素：

1
2
3
4
5
6
7
data=[16,22,66,53]
ages = pd.Series(data, name="Age")
print(ages.max())
"""
输出：
66
"""

对于二维数组DataFrame同样有效：

1
2
3
4
5
6
7
8
9
10
11
12
data = {
  'sites': ["aaa", "bbb", "ccc"],
  'number': [1, 2, 3]
}
ages = pd.DataFrame(data)
print(ages.max(axis=0)) # 指定axis=0
"""
输出：
sites     ccc
number      3
dtype: object
"""

输出的是每一列的最大元素。同理还有min方法，不再赘述。

如上所述，可以使用DataFrame或Series执行操作。pandas提供了很多功能，每个功能都是可以应用于DataFrame或Series的方法。

5 导入和导出pandas对象

pandas可以很方便的处理.csv文件，原始数据文件（泰坦尼克乘客数据）可以在官方github下载。

要想分析泰坦尼克号乘客数据，以CSV文件的形式导入：

1
titanic = pd.read_csv("data/titanic.csv")

通过read_csv方法，将存储为.csv文件的数据读入pandas，返回的是DataFrame对象。除此之外，pandas还支持许多不同的文件格式或开箱即用的数据源（csv、excel、sql、json、parquet等），每个文件读取方法都带有前缀read_*。

这是一个非常大的文件，我们可以只显示其中一部分数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
titanic = pd.read_csv("titanic.csv")
print(titanic.head(5)) # 前5行
print(titanic.tail(5)) # 后5行
"""
输出：
   PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
0            1         0       3  ...   7.2500   NaN         S
1            2         1       1  ...  71.2833   C85         C
2            3         1       3  ...   7.9250   NaN         S
3            4         1       1  ...  53.1000  C123         S
4            5         0       3  ...   8.0500   NaN         S
[5 rows x 12 columns]
886          887         0       2  ...  13.00   NaN         S
887          888         1       1  ...  30.00   B42         S
888          889         0       3  ...  23.45   NaN         S
889          890         1       1  ...  30.00  C148         C
890          891         0       3  ...   7.75   NaN         Q
[5 rows x 12 columns]
"""

head读取文件的前5行，tail读取文件的后5行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
print(titanic.info())
"""
输出：
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB
None
"""

info方法返回表格的一些基本信息，比如行数，列数，类型，用于保存DataFrame大致内存使用量等信息。

下面介绍如何导出数据，比如将泰坦尼克号数据导出为电子表格。

1
titanic.to_excel("titanic.xlsx", sheet_name="passengers", index=False)

即可在当前路径导出titanic.xlsx表格文件。

6 选择二维数组的子集

在上述介绍中，通过loc可以子集，下面是它更加详细的用法。

如果想从泰坦尼克号乘客中选择35岁以上的人：

1
2
3
4
5
6
7
8
9
10
11
12
13
titanic = pd.read_csv("titanic.csv")
above_35=titanic[titanic["Age"]>35]
print(above_35.head(5))
"""
输出：
    PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
1             2         1       1  ...  71.2833   C85         C
6             7         0       1  ...  51.8625   E46         S
11           12         1       1  ...  26.5500  C103         S
13           14         0       3  ...  31.2750   NaN         S
15           16         1       2  ...  16.0000   NaN         S
[5 rows x 12 columns]
"""

可以打印括号内的条件检查看一看：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
print(titanic["Age"]>35)
"""
输出：
0      False
1       True
2      False
3      False
4      False
       ...  
886    False
887    False
888    False
889    False
890    False
Name: Age, Length: 891, dtype: bool
"""

使用逻辑运算符>/</>=等等得到布尔值，这样的布尔值可用于过滤，将其放在选择括号之间，输出结果只会选择True值所在的行。

如果对2、3舱的乘客感兴趣，可以使用isin方法，它会判断并返回一个字段下每一行数据的布尔值是否为2或3：

1
2
3
4
5
6
7
8
9
10
11
12
class_23 = titanic[titanic["Pclass"].isin([2, 3])]
print(class_23.head(5))
"""
输出：
   PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
0            1         0       3  ...   7.2500   NaN         S
2            3         1       3  ...   7.9250   NaN         S
4            5         0       3  ...   8.0500   NaN         S
5            6         0       3  ...   8.4583   NaN         Q
7            8         0       3  ...  21.0750   NaN         S
[5 rows x 12 columns]
"""

也可以通过逻辑运算符来实现，它们是等效的：

1
2
3
class_23 = titanic[(titanic["Pclass"] == 2) | (titanic["Pclass"] == 3)]
# 组合多个条件语句时，每个条件必须用括号括起来()
# 不要使用python的 and和or 而是使用 &和|代替

notna可以过滤空值：

1
2
3
4
5
6
7
8
9
10
11
12
age_no_na = titanic[titanic["Age"].notna()]
print(age_no_na.head(5))
"""
输出：
   PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked
0            1         0       3  ...   7.2500   NaN         S
1            2         1       1  ...  71.2833   C85         C
2            3         1       3  ...   7.9250   NaN         S
3            4         1       1  ...  53.1000  C123         S
4            5         0       3  ...   8.0500   NaN         S
[5 rows x 12 columns]
"""

从DataFrame中选择特定的行和列，比如对35岁以上乘客的姓名感兴趣：

1
2
3
4
5
6
7
8
9
10
11
adult_names = titanic.loc[titanic["Age"] > 35, "Name"]
print(adult_names.head(5))
"""
输出：
1     Cumings, Mrs. John Bradley (Florence Briggs Th...
6                               McCarthy, Mr. Timothy J
11                             Bonnell, Miss. Elizabeth
13                          Andersson, Mr. Anders Johan
15                     Hewlett, Mrs. (Mary D Kingcome) 
Name: Name, dtype: object
"""

在这种情况下，使用中括号[]需要用逗号分隔，前面的部分是loc方法选择的行，后面的部分是要选择的列（这里选择了"Name"列）。

如果对第10到25行和第3到5列感兴趣：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
print(titanic.iloc[9:25, 2:5])
"""
输出：
    Pclass                                               Name     Sex
9        2                Nasser, Mrs. Nicholas (Adele Achem)  female
10       3                    Sandstrom, Miss. Marguerite Rut  female
11       1                           Bonnell, Miss. Elizabeth  female
12       3                     Saundercock, Mr. William Henry    male
13       3                        Andersson, Mr. Anders Johan    male
14       3               Vestrom, Miss. Hulda Amanda Adolfina  female
15       2                   Hewlett, Mrs. (Mary D Kingcome)   female
16       3                               Rice, Master. Eugene    male
17       2                       Williams, Mr. Charles Eugene    male
18       3  Vander Planke, Mrs. Julius (Emelia Maria Vande...  female
19       3                            Masselmani, Mrs. Fatima  female
20       2                               Fynney, Mr. Joseph J    male
21       2                              Beesley, Mr. Lawrence    male
22       3                        McGowan, Miss. Anna "Annie"  female
23       1                       Sloper, Mr. William Thompson    male
24       3                      Palsson, Miss. Torborg Danira  female
"""

一次生成行和列的子集，仅使用中括号[]已经不够了，此时需要使用iloc方法配合中括号选择。