pandas是数据分析师最常使用的库，因为pandas中的数据类型就是数据表，可以将pandas视为简化版的excel，pandas承接了Excel的数据处理、数据分析的功能。在这部分介绍中，也是介绍pandas库的两方面内容，一是pandas中的数据类型，二是对于数据类型的一些操作函数。这部分的知识框架如下：

pandas中的数据类型有两个：Series和DataFrame。Series对应excel中的一行或一列数据；DataFrame对应Excel中的数据表。因此可认为Series是一维的，只包含索引和数值，DataFrame是二维的，包含行索引、列索引和值。Series与DataFrame之间的关系，可以类比一维数组和二维数组的关系或Excel中一行/一列数据与整个数据表的关系一样，即Series是构成DataFrame的元素。

1 Series

1.1 定义Series

Series的定义在python中有两种常用的方法，一种是通过在numpy中讲解的array数组，另一种是通过python的基本数据类型dict字典进行创建。

a_a_1 = np.array([1,2,3,4,5])
a_d_1 = {"a":1,"b":2,"c":3,"d":4,"e":5}
a_s_1 = pd.Series(a_a_1)
a_s_2 = pd.Series(a_d_1)
print(a_a_1)
print()
print(a_s_1)
print()
print(a_d_1)
print()
print(a_s_2)

输出结果如下

[1 2 3 4 5]

0    1
1    2
2    3
3    4
4    5
dtype: int32

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

a    1
b    2
c    3
d    4
e    5
dtype: int64

1.2 索引 ★★★

Series是兼具了字典和数组特性的数据类型，在这里比较下不同：Series中会自动生成索引值，而在数组中并不存在，虽然可以使用索引对数组进行切片等操作；与字典的不同在于，Series中会将“键”置为索引，后续的函数会发现Series与dict非常像，dict如同是把Series放在一行的结果。

仔细看上面创建Series运行的结果，会发现a_s_1和a_s_2中的索引并不相同，在a_s_1中是默认的索引值，从0开始，按照步长1逐步递增。而在a_s_2中，却是直接将字典的键置为索引值。也就是说在Series中是可以重新设置索引的，没必要按照默认的索引值。在Series中有两种方法修改索引值，一是在创建Series时直接定义索引值，二是创建Series后再修改索引值。

a_a_1 = np.array([1,2,3,4,5])
a_s_1 = pd.Series(a_a_1)
a_s_2 = pd.Series(a_a_1,index=["a","b","c","d","e"])
print("输出a_s_1：\n",a_s_1)
print("输出a_s_2：\n",a_s_2)
a_s_1.index=["a","b","c","d","e"]
print("修改索引后输出a_s_1：\n",a_s_1)

输出结果如下

输出a_s_1：
0    1
1    2
2    3
3    4
4    5
dtype: int32
输出a_s_2：
a    1
b    2
c    3
d    4
e    5
dtype: int32
修改索引后输出a_s_1：
a    1
b    2
c    3
d    4
e    5
dtype: int32

上述代码中a_s_2是在创建Series时直接指定相应的索引值；而a_s_1在第一次时，使用了默认索引值，也就是从0开始，逐步递增，后使用index函数重新定义索引值实现对原Series的修改。

由于Series与dict非常像，所以在Series中也有与dict相似的输出索引和值的函数。

print(a_s_1.index)
print(a_s_1.values)

输出结果如下

Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
[1 2 3 4 5]

1.3 基于索引的增删改查 ★★★

1.3.1 查询Series中的元素

了解Series的索引后，来介绍下如何基于索引获取Series中对应的元素。在这里主要明确两个事情即可：一是可以通过设定的索引值获取对应的元素值；二是不论是否有设定的索引值，都可以使用默认的索引值获取对应的元素。举个例子说明，在a_s_1的索引值是['a', 'b', 'c', 'd', 'e']，使用这些索引自然可以获取到对应的元素值，这很好理解；但是除了这些索引以外，还可以使用[0,1,2,3,4]获取相应的元素值。可以这么理解，[0,1,2,3,4]这套索引值是都会有的，如果存在新设定的索引值，则这套索引值会隐藏。

print(a_s_1["a"])
print(a_s_1[0])

可以发现两者的输出结果是一致的

1
1

此类索引可以仿照之前介绍的start:end:step输出对应的元素值。（如果设定的索引值是有顺序的，如abcde等，则也是可以的，但是不建议这么用，因为每个人对数字的敏感度都是远高于字母一类的）

print(a_s_1["a":"e":2])
print(a_s_1[0:4:2])

输出结果如下

a    1
c    3
e    5
dtype: int32
a    1
c    3
dtype: int32

需要注意的是，在这里的输出结果并不一致，如果使用的是字母的话，则是前后都包括的，但是数字是前闭后开的，并不包括最后一个元素。

1.3.2 添加/修改/删除元素

除使用索引查看元素值外，还可以新增、修改和删除。

Series中并不能直接添加元素，但是可以使用append实现Series的拼接。需要注意的是，使用append并不会修改原Series，所以可以将append计算后的Series赋值给新的变量。

a_s_1.append(a_s_2)
print("a_s_1:\n",a_s_1)
a_s_1 = a_s_1.append(a_s_2)
print("a_s_1修改后:\n",a_s_1)

输出结果如下

a_s_1:
a    1
b    2
c    3
d    4
e    5
dtype: int32
a_s_1修改后:
a    1
b    2
c    3
d    4
e    5
a    1
b    2
c    3
d    4
e    5
dtype: int32

仔细看上面的输出结果可以发现Series与dict的另外一个不同，那就是在Series中索引（对应字典的键）是可重复的，而在dict中要求键是不可重复的。

修改元素值比较简单，只需要使用索引进行重新赋值即可。

print("a_s_2修改前:\n",a_s_2)
a_s_2[0] = 100
a_s_2["e"] = 500
print("a_s_2修改后:\n",a_s_2)

输出结果如下：

a_s_2修改前:
a    1
b    2
c    3
d    4
e    5
dtype: int32
a_s_2修改后:
a    100
b      2
c      3
d      4
e    500
dtype: int32

删除元素的方法使用函数drop即可，drop与append函数一样，并不修改原Series，所以如果想保留操作，一种方法是将drop函数运行后的结果赋值给新的变量，一个是在drop函数中指定inplace指定为True。在drop函数中，inplace参数是一个默认参数，其默认值是False，也就是不替代原Series，如果想替代，则将该参数置为True即可。

a_s_2.drop("a")
print("a_s_2:\n",a_s_2) #输出结果显示并未变更原Series a_s_2的值
a_s_3 = a_s_2.drop("a")
print("a_s_3:\n",a_s_3) #将运算后的结果赋值新变量，可以发现新变量中的值已发生变量
a_s_2.drop("a",inplace = True)
print("a_s_2:\n",a_s_2) #使用inplace后，可以发现变更了原变量的值

输出结果如下

a_s_2:
a    100
b      2
c      3
d      4
e    500
dtype: int32
a_s_3:
b      2
c      3
d      4
e    500
dtype: int32
a_s_2:
b      2
c      3
d      4
e    500
dtype: int32

1.4 Series的运算 ★★

Series的运算包括两个方面，一个是对自身元素的元素，二是与其他Series的计算。

1.4.1 基于自身元素的计算

数字的运算

a_s_5 = pd.Series([1,2,3,4,5],index=['a', 'b', 'c', 'd', 'e'])
print(a_s_5)
print(a_s_5.sum())
print(sum(a_s_5))

输出结果如下

a    1
b    2
c    3
d    4
e    5
dtype: int64
15
15

可以直接使用sum、max、min、np.min、count等对Series中的元素进行计算，也可以将Series作为参数放入相应的函数中进行计算。

除统计运算外，还可以对Series的元素进行相应的元素计算，如数字的加减乘除幂等；字符的截取合并等。需要注意的是，此类运算并不会修改原变量的值，需要将计算结果重新赋值到新变量才可以。

a_s_6 = a_s_5 * 100
print(a_s_5)
print(a_s_6)

输出结果如下

a    1
b    2
c    3
d    4
e    5
dtype: int64
a    100
b    200
c    300
d    400
e    500
dtype: int64

字符串运算

字符串的运算就比较多，主要是使用str.下的操作函数，包括：字符串的大小写转换、拼接、拆分、截取和替换。

a_s_7 = pd.Series(["abc","abd","abdcf"],index=[10,20,30])
print(a_s_7)
print(a_s_7.str.upper())

输出结果如下

10      abc
20      abd
30    abdcf
dtype: object
10      ABC
20      ABD
30    ABDCF
dtype: object

上面提到的使用str.upper进行大写转换；相似的可以使用lower进行小写转换；使用title对字符串中每一个单词的首字母进行大写；使用capitalize对字符串的首字母进行大写（如果字符串中有多个单词，则只将首单词的首字母大写）；使用swapcase对首末字母进行大写。

将series中的字符串合并为一个字符串，可以使用str.cat函数，可以使用参数sep指定相应的分隔符。

a_s_8 = pd.Series(["abc","abd","abdcf"])
print(a_s_8)
print(a_s_8.str.cat(sep="-"))

输出结果如下

0      abc
1      abd
2    abdcf
dtype: object
abc-abd-abdcf

有拼接，自然也就可以拆分，使用str.split进行相应的拆分，函数的输入只有一个参数，即分隔符是什么。

a_s_9 = pd.Series(["ab-cd","ab-em","abcd-e"])
print(a_s_9)
print(a_s_9.str.split("-"))

输出结果如下

0     ab-cd
1     ab-em
2    abcd-e
dtype: object
0     [ab, cd]
1     [ab, em]
2    [abcd, e]
dtype: object

截取也是比较简单的操作，使用slice对字符串进行切片操作，slice函数的输入参数和索引的参数是类似，即开始索引值、结束索引值和步长。在这里都是从0开始，探索到索引位置到3（不包括），按照步长1或2进行。

a_s_10 = pd.Series(["ABCD","ABCE","ABCF","ABCG"])
print(a_s_10)
print(a_s_10.str.slice(0,3,1))
print(a_s_10.str.slice(0,3,2))

输出结果如下

0    ABCD
1    ABCE
2    ABCF
3    ABCG
dtype: object
0    ABC
1    ABC
2    ABC
3    ABC
dtype: object
0    AC
1    AC
2    AC
3    AC
dtype: object

字符串常用的另一函数就是替换，在Series中使用str.replace进行。

a_s_10 = pd.Series(["ABCD","ABCE","ABCF","ABCG"])
print(a_s_10)
print(a_s_10.replace("ABCD","ASDC"))

在这里使用replace函数，将ABCD替换为ASDC。需要注意的是，只有在完全匹配的情况下才可以替换，否则需要借助正则表达式进行替换。输出结果如下

0    ABCD
1    ABCE
2    ABCF
3    ABCG
dtype: object
0    ASDC
1    ABCE
2    ABCF
3    ABCG
dtype: object

1.4.2 Series之间的计算

Series之间的计算类似数组之间的计算，是相应元素的计算。

b_s_1 = pd.Series([1,2,3,4,5])
b_s_2 = pd.Series([10,20,30,40,50])
print(b_s_1 + b_s_2)

输出结果如下

0    11
1    22
2    33
3    44
4    55
dtype: int64

字符串的计算也是相应元素之间的计算，在这里演示字符串之间的拼接，正如在字符串中的介绍一样，字符串可以使用+实现拼接。

b_s_3 = pd.Series(["a","b","c","d"])
b_s_4 = pd.Series(["a","b","c","d"])
b_s_3 + "-" + b_s_4

输出结果如下

0    a-a
1    b-b
2    c-c
3    d-d
dtype: object

在这里需要强调的是，Series的运算是会按照索引自动对齐的。在上面的例子中，并没有设定索引值，而是使用了默认的索引值的。如何添加上索引，计算结果会发生如何变化？

b_s_3 = pd.Series(["a","b","c","d"],index=["i1","i2","i3","i4"])
b_s_4 = pd.Series(["a","b","c","d"],index=["i4","i3","i2","i1"])
print(b_s_3)
print(b_s_4)
b_s_3 + "-" + b_s_4

输出结果如下

i1    a
i2    b
i3    c
i4    d
dtype: object
i4    a
i3    b
i2    c
i1    d
dtype: object
i1    a-d
i2    b-c
i3    c-b
i4    d-a
dtype: object

和使用默认索引的区别在于，在有索引的情况下，会将两个Series中的值按照索引进行对齐，然后再进行相应的运算。在这个例子中，其索引值都是i1~i4，所以会首先进行对齐，再进行计算，所以在最终的计算结果中，是a-d等进行对齐。

如果索引值不完全一致，会出现什么样的计算结果？

b_s_3 = pd.Series(["a","b","c","d"],index=["i1","i2","i6","i7"])
b_s_4 = pd.Series(["a","b","c","d"],index=["i4","i3","i2","i1"])
print(b_s_3)
print(b_s_4)
b_s_3 + "-" + b_s_4

输出结果如下

i1    a
i2    b
i6    c
i7    d
dtype: object
i4    a
i3    b
i2    c
i1    d
dtype: object
i1    a-d
i2    b-c
i3    NaN
i4    NaN
i6    NaN
i7    NaN
dtype: object

会发现在计算中，Series会自动取交集，对于索引值匹配不到的，直接置为空值。在上述例子中，i1和i2的索引值所有对应，所以拼接成功，i3~i7无共同的索引值，所以其结果全为空值。

2 DataFrame

2.1 定义DataFrame

DataFrame相当于Excel中的表格，其定义方法常用的有以下三种：

使用二维数组定义DataFrame
定义DataFrame的语句也很简单，使用DataFrame即可，DataFrame需要三个参数：数据、索引和列名。其中索引和列名可以省略，系统会自动从0开始，按照步长1进行自增。

a_d = pd.DataFrame(data=[[1,2,3],[4,5,6]])
print(a_d)

输出结果如下，一个二行三列的数组生成一个两行三列的DataFrame。

   0  1  2
0  1  2  3
1  4  5  6

在这里可以重命名下索引(使用参数index)和列名(使用参数columns)。

a_d = pd.DataFrame(data=[[1,2,3],[4,5,6]],index=["a","b"],columns=["d","e","f"])
print(a_d)

输出结果如下，索引变成a和b；列名变成d、e、f。

   d  e  f
a  1  2  3
b  4  5  6

使用字典定义DataFrame

变量data除可使用二维数组定义外，还可以使用字典进行定义。

a_d = pd.DataFrame(data = {"Chinese":[69,75,86],"Math":[96,67,16],"English":[49,76,59]})
print(a_d)

输出结果如下

     Chinese  Math  English
0       69    96       49
1       75    67       76
2       86    16       59

可以发现DataFrame函数将字典中的键值对直接作为一列进行读入。当然在这类也可以设置索引。

a_d = pd.DataFrame(data = {"Chinese":[69,75,86],"Math":[96,67,16],"English":[49,76,59]},index=["张三","李四","王五"])
print(a_d)

输出结果如下

         Chinese  Math  English
张三       69    96       49
李四       75    67       76
王五       86    16       59

使用Series定义DataFrame
Series的创建中使用的是数组和字典，因此也可以使用Series定义DataFrame，在定义DataFrame前需要先定义Series。

s_1 = pd.Series(np.array([1,2,3,4,5]))
s_2 = pd.Series(np.array([10,20,30,40,50]))
s_3 = pd.Series(np.array([100,200,300,400,500]))

d_a = pd.DataFrame(data = [s_1,s_2,s_3],index=['a','b','c'])
print(d_a)

输出结果如下

     0    1    2    3    4
a    1    2    3    4    5
b   10   20   30   40   50
c  100  200  300  400  500

在使用字典定义DataFrame时，字典的键会自动作为DataFrame的列名；在使用Series定义DataFrame时，DataFrame的列名会沿用Series的列名，因为在使用Series定义DataFrame时不可使用参数columns，但可以在定义DataFrame后进行修改。

d_a.columns = ['A','B','C','D','E']
print(d_a)

输出结果如下

     A    B    C    D    E
a    1    2    3    4    5
b   10   20   30   40   50
c  100  200  300  400  500

2.2 查看DataFrame特征

新建完成DataFrame后，则可以查看相应的数据信息，主要包括两个维度，一个是查看元素的特征，一个是查看DataFrame的特征。

在python中使用index输出DataFrame的索引值；使用columns输出列名；使用values输出DataFrame中的元素值；使用dtypes输出各列的数据类型。

a_d = pd.DataFrame(data = {"Chinese":[69,75,86],"Math":[96,67,1