pandas、numpy模块详解

链接：https://pan.baidu.com/s/10KSLtxnCY3vY6jpmNddgpg
获取提取码可关注WX公众号zdb呀，笔记整理不易

第3章 数组的存储和处理：numpy模块 3.1 创建数组 3.1.1 创建数组：array()函数

一维数组情况：

import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array(['产品编号', '销售数量', '销售单价', '销售金额'])
print(a)
print(b)

[1 2 3 4]
['产品编号' '销售数量' '销售单价' '销售金额']

二维数组情况：

import numpy as np
c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print (c)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

参数见下表

array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

参数	说明
object	必选，为一个序列型对象，如列表、元组、集合等，还可以是一个已创建好的数组
dtype	可选，用于指定数组元素的数据类型
copy	可选，用于设置是否需要复制对象
order	可选，用于指定创建数组的样式
subok	可选，默认返回一个与基类的类型一致的数组
ndmin	可选，用于指定生成数组的最小维度

3.1.2 创建等差数组：arange()函数

索引从0开始，记左不记右

3参数情况：

import numpy as np
d = np.arange(1,20,4)   #第3个参数为步长  可选  默认为1   1~19，步长4   记左不记右
print(d)

[ 1  5  9 13 17]

2参数情况：

import numpy as np
d = np.arange(1,20)
print(d)

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

1参数情况：

import numpy as np
d = np.arange(20)
print(d)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

参数说明见表

arange(start, stop, step, dtype=None)

参数	说明
start	可选，表示起始值。省略时默认为0
stop	必选，表示结束值。生成的数组元素不包括该值
step	可选，表示步长。省略时默认为1。给出该参数则必须给出start参数
dtype	可选，表示数组元素类型。默认为None

3.1.3 创建随机数组：rand()、randn()、randint()函数

1. rand()函数：生成元素值在[0,1)区间的随机数

一维情况：

import numpy as np
e = np.random.rand(3)
print(e)

[0.8412559  0.63220568 0.7395547 ]

二维情况：

import numpy as np
e = np.random.rand(2, 3)
print(e)

[[0.03654404 0.33348249 0.30089453]
 [0.35291365 0.56683093 0.41812811]]

2. randn()函数：生成元素值在[0,1)区间的随机数，且符合标准正态分布

一维情况：

import numpy as np
e = np.random.randn(3)
print(e)

[ 0.36809175 -0.07224965 -0.33366574]

二维情况：

import numpy as np
e = np.random.randn(3, 3)
print(e)

[[ 1.14014499 -0.95577809 -0.94003745]
 [-2.61768236 -0.6565676   0.74041531]
 [-0.3138474   0.68276791  0.17315121]]

3. randint()函数：生成指定范围的随机数，记左不记右

一维情况：

import numpy as np
e = np.random.randint(1, 5, 10)   #随机数范围：[1,5)  10个数
print(e)

[4 1 2 4 1 3 2 4 1 2]

二维情况：第三个参数指定维度

import numpy as np
e = np.random.randint(1, 10, (4, 2))   #随机数范围：[1,10)
print(e)

[[4 4]
 [2 5]
 [3 3]
 [7 8]]

3.2 查看数组的属性 3.2.1 查看行列数 ：shape属性

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.shape)

(3, 2)

只查看行数、或者列数

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.shape[0])   #查看行数
print(arr.shape[1])   #查看列数

3
2

3.2.2 查看元素个数：size属性

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.size)

6

3.2.3 查看元素的数据类型：dtype属性

import numpy as np
arr = np.array([[1.3, 2, 3.6, 4], [5, 6, 7.8, 8]])
print(arr.dtype)

float64

3.2.4 转换元素的数据类型：astype()函数

import numpy as np
arr = np.array([[1.3, 2, 3.6, 4], [5, 6, 7.8, 8]])
arr1 = arr.astype(int)
print(arr1)
print(arr1.dtype)

[[1 2 3 4]
 [5 6 7 8]]
int32

3.2.5 查看数组维度：ndim属性

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.ndim)

2

3.3 选取数组元素 3.3.1 一维数组元素的选取

1. 选取单个元素

import numpy as np
arr = np.array([12, 2, 40, 64, 56, 6, 57, 18, 95, 17, 21, 12])
print(arr[0])
print(arr[5])
print(arr[-1])   #倒数第1个
print(arr[-4])

12
6
12
95

2. 选取连续的元素

import numpy as np
arr = np.array([12, 2, 40, 64, 56, 6, 57, 18, 95, 17, 21, 12])
print(arr[1:6])
print(arr[3:-2])
print(arr[:3])
print(arr[:-3])
print(arr[3:])
print(arr[-3:])

[ 2 40 64 56  6]
[64 56  6 57 18 95 17]
[12  2 40]
[12  2 40 64 56  6 57 18 95]
[64 56  6 57 18 95 17 21 12]
[17 21 12]

3. 选取不连续的元素

import numpy as np
arr = np.array([12, 2, 40, 64, 56, 6, 57, 18, 95, 17, 21, 12])
print(arr[1:5:2])  #[1,5) 步长为2 
print(arr[5:1:-2])  #第三个参数指定步长
print(arr[::3])
print(arr[3::])
print(arr[:3:])

[ 2 64]
[ 6 64]
[12 64 57 17]
[64 56  6 57 18 95 17 21 12]
[12  2 40]

3.3.2 二维数组的元素选取

逗号隔开两个索引

1. 选取单个元素

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(arr[1, 2])  #第1行第2列  索引从0开始

6

2. 选取单行或单列元素

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(arr[2])
print(arr[:, 1])

[7 8 9]
[ 2  5  8 11]

3. 选取某些行或某些列的元素

某些行

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(arr[1:3])
print(arr[:2])
print(arr[2:])

[[4 5 6]
 [7 8 9]]
[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]

某些列

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(arr[:, 1:3])
print(arr[:, :2])
print(arr[:, 2:])

[[ 2  3]
 [ 6  7]
 [10 11]
 [14 15]]
[[ 1  2]
 [ 5  6]
 [ 9 10]
 [13 14]]
[[ 3  4]
 [ 7  8]
 [11 12]
 [15 16]]

4. 同时选取行列元素

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(arr[0:2, 1:3])

[[2 3]
 [6 7]]

3.4 数组的重塑和转置 3.4.1 一维数组的重塑：reshape()函数

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
a = arr.reshape(2, 4)   #需要重塑前后元素个数相等才行
b = arr.reshape(4, 2)
print(a)
print(b)

[[1 2 3 4]
 [5 6 7 8]]
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

3.4.2 多维数组的重塑：reshape()函数

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
c = arr.reshape(4, 3)
d = arr.reshape(2, 6)
print(c)
print(d)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]

3.4.3 多维重塑为一维：flatten()、ravel()函数

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr.flatten())  #降为一维
print(arr.ravel())

[ 1  2  3  4  5  6  7  8  9 10 11 12]
[ 1  2  3  4  5  6  7  8  9 10 11 12]

3.4.4 数组的转置：T属性、transpose()函数

1. T属性

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
print(arr.T)

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]

2. transpose()函数

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = np.transpose(arr)
print(arr1)

[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]

3.5 数组的处理 3.5.1 添加数组元素：append()、insert()函数

1. append()函数

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr1 = np.append(arr, [[7, 8, 9]])
print(arr1)

[1 2 3 4 5 6 7 8 9]

可以看出append()函数在二维数组中添加元素，结果转为了一维数组。

那怎么保持二维数组呢？可以设置axis参数按行或者按列添加

axis=0：按行添加

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr1 = np.append(arr, [[7, 8, 9]], axis = 0)
print(arr1)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

axis=1：按列添加

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr1 = np.append(arr, [[7, 8],[9, 10]], axis = 1)
print(arr1)

[[ 1  2  3  7  8]
 [ 4  5  6  9 10]]

append()函数参数如下

append(arr, values, axis=None)

参数	说明
arr	必选，要添加元素的数组
values	必选，要添加的数组元素
axis	可选，默认为None。省略此参数时，默认当一维数组尾插元素。为0按行添加；为1按列添加

2. insert()函数

import numpy as np
arr = np.array([[1, 2], [3, 4], [5, 6]])
arr1 = np.insert(arr, 1, [7, 8])
print(arr1)

[1 7 8 2 3 4 5 6]

可以看出先把二维数组降成了一维数组，再在索引为1的位置添加元素。

那么怎么保持在二维添加元素呢？同样设置axis参数

import numpy as np
arr = np.array([[1, 2], [3, 4], [5, 6]])
arr1 = np.insert(arr, 1, [7, 8], axis = 0)
arr2 = np.insert(arr, 1, [7, 8, 9], axis = 1)
print(arr1)
print(arr2)

[[1 2]
 [7 8]
 [3 4]
 [5 6]]
[[1 7 2]
 [3 8 4]
 [5 9 6]]

insert()参数如下

insert(arr, obj, values, axis)

参数	说明
arr	必选，要插入元素的数组
obj	必选，数组的索引值，表示插入元素的位置
values	必选，要插入的元素
axis	可选，省略此参数时，默认当一维数组插入。为0按行；为1按列

3.5.2 删除数组元素：delete()函数

也分按行和按列删除

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr1 = np.delete(arr, 2)
arr2 = np.delete(arr, 2, axis = 0)
arr3 = np.delete(arr, 2, axis = 1)
print(arr1) 
print(arr2)
print(arr3)

[1 2 4 5 6 7 8 9]
[[1 2 3]
 [4 5 6]]
[[1 2]
 [4 5]
 [7 8]]

3.5.3 处理数组的缺失值：isnan()函数

标记缺失值：isnan()函数

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, np.nan, 8, 9])
print(arr)
print(np.isnan(arr))

[ 1.  2.  3.  4.  5.  6. nan  8.  9.]
[False False False False False False  True False False]

补充缺失值：

arr[np.isnan(arr)] = 0
print(arr)

[1. 2. 3. 4. 5. 6. 0. 8. 9.]

3.5.4 处理数组的重复值：unique()函数

import numpy as np
arr = np.array([8, 4, 2, 3, 5, 2, 5, 5, 6, 8, 8, 9])
arr1 = np.unique(arr)
arr1, arr2 = np.unique(arr, return_counts=True) # 两个返回值   arr1为去重后数组   arr2为每个元素出现的次数
print(arr1)
print(arr2)

[2 3 4 5 6 8 9]
[2 1 1 3 1 3 1]

3.5.5 拼接数组：concatenate()、hstack()、vstack()函数

1. concatenate()函数

同样axis参数可以指定拼接按行还是按列

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
arr3 = np.concatenate((arr1, arr2), axis=0)   #行方向上拼接
arr4 = np.concatenate((arr1, arr2), axis=1)   #列方向上拼接
print(arr3)
print(arr4)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

2. hstack()函数：以水平堆叠的方式拼接数组

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
arr3 = np.hstack((arr1, arr2))
print(arr3)

[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

3. vstack()函数：以垂直堆叠的方式拼接数组

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
arr3 = np.vstack((arr1, arr2))
print(arr3)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

3.5.6 拆分数组：split()、hsplit()、vsplit()函数

1. split()函数

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
arr1 = np.split(arr, 2)   #第2个参数指定拆成几个数组
arr2 = np.split(arr, 4)
print(arr1)
print(arr2)

[array([1, 2, 3, 4, 5, 6]), array([ 7,  8,  9, 10, 11, 12])]
[array([1, 2, 3]), array([4, 5, 6]), array([7, 8, 9]), array([10, 11, 12])]

第二个参数还可以是数组，指定拆分的位置

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
arr3 = np.split(arr, [2, 6])
arr4 = np.split(arr, [2, 3, 8, 10])
print(arr3)
print(arr4)

[array([1, 2]), array([3, 4, 5, 6]), array([ 7,  8,  9, 10, 11, 12])]
[array([1, 2]), array([3]), array([4, 5, 6, 7, 8]), array([ 9, 10]), array([11, 12])]

2. hsplit()函数和vsplit()函数

hsplit()函数：横向拆成几个数组

vsplit()函数：纵向拆成几个数组

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9 , 10, 11, 12],[13, 14, 15, 16]])
arr5 = np.hsplit(arr, 2)
arr6 = np.vsplit(arr, 2)
print(arr5)
print(arr6)

[array([[ 1,  2],
       [ 5,  6],
       [ 9, 10],
       [13, 14]]), array([[ 3,  4],
       [ 7,  8],
       [11, 12],
       [15, 16]])]
[array([[1, 2, 3, 4],
       [5, 6, 7, 8]]), array([[ 9, 10, 11, 12],
       [13, 14, 15, 16]])]

3.6 数组的运算 3.6.1 数组之间的四则运算

数组与数组之间的运算

import numpy as np
arr1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])         
arr2 = np.array([[9, 10, 11, 12], [13, 14, 15, 16]])
arr3 = arr1 + arr2     #对应位置的元素相加
arr4 = arr1 * arr2     #对应位置的元素相乘
print(arr3)
print(arr4)

[[10 12 14 16]
 [18 20 22 24]]
[[  9  20  33  48]
 [ 65  84 105 128]]

数组与数值的运算

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
arr5 = arr + 5       #每个位置的元素+5
arr6 = arr * 10      #每个位置的元素*10
print(arr5)
print(arr6)

[[ 6  7  8  9]
 [10 11 12 13]]
[[10 20 30 40]
 [50 60 70 80]]

3.6.2 数组元素的统计运算：sum()、mean()、max()函数

1. 求和：sum()函数

可以指定整个数组求和，还是按行或者按列

axis=0：每一列的元素求和

axis=1：每一行的元素求和

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = arr.sum()
arr2 = arr.sum(axis=0)  #每一列的元素求和
arr3 = arr.sum(axis=1)  #每一行的元素求和
print(arr1)
print(arr2)
print(arr3)

78
[15 18 21 24]
[10 26 42]

2. 求平均值：mean()函数

axis=0：每一列求均值

axis=1：每一行求均值

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = arr.mean()
arr2 = arr.mean(axis=0)  #每一列求均值
arr3 = arr.mean(axis=1)  #每一行求均值
print(arr1)
print(arr2)
print(arr3)

6.5
[5. 6. 7. 8.]
[ 2.5  6.5 10.5]

3. 求最值：max()函数

axis=0：每一列求最大值

axis=1：每一行求最大值

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = arr.max()
arr2 = arr.max(axis=0)   #每一列求最大值
arr3 = arr.max(axis=1)   #每一行求最大值
print(arr1)
print(arr2)
print(arr3)

12
[ 9 10 11 12]
[ 4  8 12]

第4章 pandas模块入门 4.1 数据结构

pandas有两个重要的数据结构对象：Series和Dataframe。

4.1.1 Series对象

Series是创建一个一维数组对象，会自动生成行标签。

import pandas as pd
s = pd.Series(['短裤', '毛衣', '连衣裙', '牛仔裤'])
print(s)

0     短裤
1     毛衣
2    连衣裙
3    牛仔裤
dtype: object

index参数可以指定行标签

import pandas as pd
s1 = pd.Series(['短裤', '毛衣', '连衣裙', '牛仔裤'], index = ['a001', 'a002', 'a003', 'a004'])
print(s1)

a001     短裤
a002     毛衣
a003    连衣裙
a004    牛仔裤
dtype: object

使用Series对象还可以基于字典创建数据

import pandas as pd
s2 = pd.Series({'a001':'短裤', 'a002':'毛衣', 'a003':'连衣裙', 'a004':'牛仔裤'})
print(s2)

a001     短裤
a002     毛衣
a003    连衣裙
a004    牛仔裤
dtype: object

4.1.2 Dataframe对象

会自动生成行列标签

import pandas as pd
df = pd.Dataframe([['短裤', 45], ['毛衣', 69], ['连衣裙', 119], ['牛仔裤', 99]])
print(df)

     0    1
0   短裤   45
1   毛衣   69
2  连衣裙  119
3  牛仔裤   99

可以columns参数指定列标签；index参数指定行标签

import pandas as pd
df1 = pd.Dataframe([['短裤', 45], ['毛衣', 69], ['连衣裙', 119], ['牛仔裤', 99]], 
                   columns=['产品', '单价'], index=['a001', 'a002', 'a003', 'a004'])
print(df1)

       产品   单价
a001   短裤   45
a002   毛衣   69
a003  连衣裙  119
a004  牛仔裤   99

也可以用字典形式生成数据

import pandas as pd
df3 = pd.Dataframe({'产品':['短裤', '毛衣', '连衣裙', '牛仔裤'],'单价':[45, 69, 119, 99]})
print(df3)

    产品   单价
0   短裤   45
1   毛衣   69
2  连衣裙  119
3  牛仔裤   99

在用字典生成数据的基础上，同时指定行标签

import pandas as pd
df3 = pd.Dataframe({'产品':['短裤', '毛衣', '连衣裙', '牛仔裤'],'单价':[45, 69, 119, 99]}, index = ['a001', 'a002', 'a003', 'a004'])
print(df3)

       产品   单价
a001   短裤   45
a002   毛衣   69
a003  连衣裙  119
a004  牛仔裤   99

4.2 读取数据 4.2.1 读取Excel数据：read_excel()函数 1. 读取特定工作簿：sheet_name参数

例如对下表的数据进行读取

4月是第四个表，我们应把sheet_name参数指定为3；因为索引是从0开始的。

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

可以看出read_excel()函数自动创建了一个Dataframe对象，同时自动把第一行数据当做列标签。

2. 指定列标签：header参数

header参数可以指定列标签

可以看出不给出header参数时，该参数默认为0。

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, header=0)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

header=1时结果如下：

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, header=1)
print(data)

   d001  投影仪  5台  2000
0  d002  马克笔  5盒   300
1  d003  打印机  1台   298
2  d004  点钞机  1台   349
3  d005  复印纸  2箱   100
4  d006  条码纸  6卷    34

header=None时结果如下：

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3, header = None)
print(data)

      0    1   2     3
0  订单编号   产品  数量    金额
1  d001  投影仪  5台  2000
2  d002  马克笔  5盒   300
3  d003  打印机  1台   298
4  d004  点钞机  1台   349
5  d005  复印纸  2箱   100
6  d006  条码纸  6卷    34

3. 指定行标签：index_col参数

该参数默认为None

index_col=0时，第0列为列标签

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data)

       产品  数量    金额
订单编号               
d001  投影仪  5台  2000
d002  马克笔  5盒   300
d003  打印机  1台   298
d004  点钞机  1台   349
d005  复印纸  2箱   100
d006  条码纸  6卷    34

index_col=0时

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=1)
print(data)

     订单编号  数量    金额
产品                 
投影仪  d001  5台  2000
马克笔  d002  5盒   300
打印机  d003  1台   298
点钞机  d004  1台   349
复印纸  d005  2箱   100
条码纸  d006  6卷    34

4. 读取指定列：usecols参数

usecols=[2]：指定第二列

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, usecols=[2])
print(data)

   数量
0  5台
1  5盒
2  1台
3  1台
4  2箱
5  6卷

指定多列

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, usecols=[1, 3])
print(data)

    产品    金额
0  投影仪  2000
1  马克笔   300
2  打印机   298
3  点钞机   349
4  复印纸   100
5  条码纸    34

4.2.2 读取csv文件数据：read_csv()函数

数据如下：

import pandas as pd
data = pd.read_csv('订单表.csv')
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

nrows参数可以指定显示的行数

nrows=3时

import pandas as pd
data = pd.read_csv('订单表.csv', nrows=3)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298

4.3 查看数据的行数和列数 4.3.1 查看数据的前几行：head()函数

head()函数中参数为空默认前5行

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.head())

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100

指定head(3)时如下

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.head(3))

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298

4.3.2 查看行数和列数：shape属性

numpy模块也是shape

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data)
print(data.shape)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34
(6, 4)

4.3.3 查看数据的类型 1. info()函数

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3)
print(data.info())

RangeIndex: 6 entries, 0 to 5
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   订单编号    6 non-null      object
 1   产品      6 non-null      object
 2   数量      6 non-null      object
 3   金额      6 non-null      int64 
dtypes: int64(1), object(3)
memory usage: 320.0+ bytes
None

2. dtype参数

查看特定列的书库类型

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3)
print(data['金额'].dtype)

int64

3. astype()函数

特定列数据类型转换

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3)
data['金额'] = data['金额'].astype('float64')
print(data)
print(data['金额'].dtype)

   订单编号   产品  数量      金额
0  d001  投影仪  5台  2000.0
1  d002  马克笔  5盒   300.0
2  d003  打印机  1台   298.0
3  d004  点钞机  1台   349.0
4  d005  复印纸  2箱   100.0
5  d006  条码纸  6卷    34.0
float64

4.4 选择数据 4.4.1 选择行数据：loc()、iloc()函数

先查看一下所有数据

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)  #index_col指定行标签
print(data)

       产品  数量    金额
订单编号               
d001  投影仪  5台  2000
d002  马克笔  5盒   300
d003  打印机  1台   298
d004  点钞机  1台   349
d005  复印纸  2箱   100
d006  条码纸  6卷    34

1. 挑选单行数据

loc()函数加行标签指定行

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.loc['d001'])

产品     投影仪
数量      5台
金额    2000
Name: d001, dtype: object

iloc()函数加索引指定行号

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.iloc[2])

产品    打印机
数量     1台
金额    298
Name: d003, dtype: object

2. 挑选多行数据

与单行相比，结果显示的格式不一样了

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.loc[['d002', 'd004']])

       产品  数量   金额
订单编号              
d002  马克笔  5盒  300
d004  点钞机  1台  349

iloc()挑选：

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.iloc[[1, 5]])

       产品  数量   金额
订单编号              
d002  马克笔  5盒  300
d006  条码纸  6卷   34
       产品  数量   金额

或者给出区间

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.iloc[1:5])

       产品  数量   金额
订单编号              
d002  马克笔  5盒  300
d003  打印机  1台  298
d004  点钞机  1台  349
d005  复印纸  2箱  100

3. 挑选满足条件的行

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
a = data['金额'] < 300   #挑选金额>300的行
print(data[a])

       产品  数量   金额
订单编号              
d003  打印机  1台  298
d005  复印纸  2箱  100
d006  条码纸  6卷   34

4.4.2 选择列数据：iloc()函数 1. 挑选单列数据

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data['产品'])

0    投影仪
1    马克笔
2    打印机
3    点钞机
4    复印纸
5    条码纸
Name: 产品, dtype: object

2. 挑选多列数据

挑选数据要么标签，要么索引挑选

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data[['产品', '金额']])

    产品    金额
0  投影仪  2000
1  马克笔   300
2  打印机   298
3  点钞机   349
4  复印纸   100
5  条码纸    34

或者

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.iloc[:, [1,3]])

    产品    金额
0  投影仪  2000
1  马克笔   300
2  打印机   298
3  点钞机   349
4  复印纸   100
5  条码纸    34

或者写成区间

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.iloc[:, 1:3])

    产品  数量
0  投影仪  5台
1  马克笔  5盒
2  打印机  1台
3  点钞机  1台
4  复印纸  2箱
5  条码纸  6卷

4.4.3 同时选择行列数据

标签挑选

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
data1 = data.loc[['d001', 'd005'], ['产品', '金额']]
print(data1)

       产品    金额
订单编号           
d001  投影仪  2000
d005  复印纸   100

或者索引挑选

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
data2 = data.iloc[[2, 4], [0, 2]]
print(data2)

       产品   金额
订单编号          
d003  打印机  298
d005  复印纸  100

4.5 修改行、列标签：columns、index参数；set_index()函数

先查看一下数据

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

set_index()设置行标签

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.set_index('订单编号'))

       产品  数量    金额
订单编号               
d001  投影仪  5台  2000
d002  马克笔  5盒   300
d003  打印机  1台   298
d004  点钞机  1台   349
d005  复印纸  2箱   100
d006  条码纸  6卷    34

或者用字典一对一修改

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
data = data.rename(columns={'订单编号':'编号', '产品':'产品名称', '数量':'订单数量', '金额':'订单金额'}, 
                   index = {0:'A', 1:'B', 2:'C', 3:'D', 4:'E', 5:'F'})
print(data) 

     编号 产品名称 订单数量  订单金额
A  d001  投影仪   5台  2000
B  d002  马克笔   5盒   300
C  d003  打印机   1台   298
D  d004  点钞机   1台   349
E  d005  复印纸   2箱   100
F  d006  条码纸   6卷    34

columns、index参数分别修改列、行标签

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
data.columns = ['编号', '产品名称', '订单数量', '订单金额']
data.index = ['A', 'B', 'C', 'D', 'E', 'F']
print(data)

     编号 产品名称 订单数量  订单金额
A  d001  投影仪   5台  2000
B  d002  马克笔   5盒   300
C  d003  打印机   1台   298
D  d004  点钞机   1台   349
E  d005  复印纸   2箱   100
F  d006  条码纸   6卷    34

第五章：pandas模块进阶 5.1 数据的查找和替换 5.1.1 查找数据：isin()函数

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

isin()函数查看表中是否有该值

data1 = data.isin(['a005','钱包'])
print(data1)

      编号     产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  False  False     False     False  False  False  False  False
1  False   True     False     False  False  False  False  False
2  False  False     False     False  False  False  False  False
3  False  False     False     False  False  False  False  False
4   True   True     False     False  False  False  False  False
5  False  False     False     False  False  False  False  False
6  False  False     False     False  False  False  False  False

查看特定列是否有该值

data2 = data['产品'].isin(['手提包'])
print(data2)

0    False
1    False
2    False
3     True
4    False
5    False
6    False
Name: 产品, dtype: bool

5.1.2 替换数据：replace()函数

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace('背包', '挎包')    #并没有替换
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

可以看出上述代码并没有替换，那怎么替换呢？

1. 一对一替换

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace('背包', '挎包', inplace = True)
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   挎包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   挎包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

2. 多对一替换

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace(['背包', '手提包'], '挎包', inplace = True)
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   挎包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   挎包        16        65     23    368   1495   1127
3  a004   挎包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

3. 多对多替换

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace({'背包':'挎包', 16:39, 65:88}, inplace = True)
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   挎包        39        88     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   挎包        39        88     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

5.2 数据的处理 5.2.1 插入数据：insert()函数

末尾插入一列

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data['品牌'] = ['AM', 'DE', 'SR', 'AM', 'TY', 'DE', 'UD']
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)  品牌
0  a001   背包        16        65     60    960   3900   2940  AM
1  a002   钱包        90       187     50   4500   9350   4850  DE
2  a003   背包        16        65     23    368   1495   1127  SR
3  a004  手提包        36       147     26    936   3822   2886  AM
4  a005   钱包        90       187     78   7020  14586   7566  TY
5  a006  单肩包        58       124     63   3654   7812   4158  DE
6  a007  单肩包        58       124     58   3364   7192   3828  UD

指定插入到哪列

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.insert(2, '品牌', ['AM', 'DE', 'SR', 'AM', 'TY', 'DE', 'UD'])
print(data)

     编号   产品  品牌  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包  AM        16        65     60    960   3900   2940
1  a002   钱包  DE        90       187     50   4500   9350   4850
2  a003   背包  SR        16        65     23    368   1495   1127
3  a004  手提包  AM        36       147     26    936   3822   2886
4  a005   钱包  TY        90       187     78   7020  14586   7566
5  a006  单肩包  DE        58       124     63   3654   7812   4158
6  a007  单肩包  UD        58       124     58   3364   7192   3828

5.2.2 删除元素：drop()函数

axis参数可以指定删除行还是删除列

1. 删除列

指定标签删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.drop(['成本价(元/个)', '成本(元)'], axis = 1)
print(a)

     编号   产品  销售价(元/个)  数量(个)  收入(元)  利润(元)
0  a001   背包        65     60   3900   2940
1  a002   钱包       187     50   9350   4850
2  a003   背包        65     23   1495   1127
3  a004  手提包       147     26   3822   2886
4  a005   钱包       187     78  14586   7566
5  a006  单肩包       124     63   7812   4158
6  a007  单肩包       124     58   7192   3828

指定索引删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
b = data.drop(data.columns[[2, 5]], axis = 1)
print(b)

     编号   产品  销售价(元/个)  数量(个)  收入(元)  利润(元)
0  a001   背包        65     60   3900   2940
1  a002   钱包       187     50   9350   4850
2  a003   背包        65     23   1495   1127
3  a004  手提包       147     26   3822   2886
4  a005   钱包       187     78  14586   7566
5  a006  单肩包       124     63   7812   4158
6  a007  单肩包       124     58   7192   3828

方法三

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
c = data.drop(columns = ['成本价(元/个)', '成本(元)'])
print(c)

     编号   产品  销售价(元/个)  数量(个)  收入(元)  利润(元)
0  a001   背包        65     60   3900   2940
1  a002   钱包       187     50   9350   4850
2  a003   背包        65     23   1495   1127
3  a004  手提包       147     26   3822   2886
4  a005   钱包       187     78  14586   7566
5  a006  单肩包       124     63   7812   4158
6  a007  单肩包       124     58   7192   3828

2. 删除行

指定行标签删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx', index_col = 0)
a = data.drop(['a001', 'a004'], axis = 0)
print(a)

       产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
编号                                                       
a002   钱包        90       187     50   4500   9350   4850
a003   背包        16        65     23    368   1495   1127
a005   钱包        90       187     78   7020  14586   7566
a006  单肩包        58       124     63   3654   7812   4158
a007  单肩包        58       124     58   3364   7192   3828

指定索引删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx', index_col = 0)
b = data.drop(data.index[[0, 4]], axis = 0)
print(b)

       产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
编号                                                       
a002   钱包        90       187     50   4500   9350   4850
a003   背包        16        65     23    368   1495   1127
a004  手提包        36       147     26    936   3822   2886
a006  单肩包        58       124     63   3654   7812   4158
a007  单肩包        58       124     58   3364   7192   3828

方法三：

import pandas as pd
data = pd.read_excel('产品统计表.xlsx', index_col = 0)
c = data.drop(index = ['a001', 'a004'])
print(c)

       产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
编号                                                       
a002   钱包        90       187     50   4500   9350   4850
a003   背包        16        65     23    368   1495   1127
a005   钱包        90       187     78   7020  14586   7566
a006  单肩包        58       124     63   3654   7812   4158
a007  单肩包        58       124     58   3364   7192   3828

5.2.3 处理缺失值 1. 查看缺失值：isnull()函数

先查看所有数据

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包       NaN        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58     NaN   7192   3828

info()函数查看数据类型，还可以查看是否有缺失值

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
data.info()

RangeIndex: 7 entries, 0 to 6
Data columns (total 8 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   编号        7 non-null      object 
 1   产品        7 non-null      object 
 2   成本价(元/个)  6 non-null      float64
 3   销售价(元/个)  7 non-null      int64  
 4   数量(个)     7 non-null      int64  
 5   成本(元)     6 non-null      float64
 6   收入(元)     7 non-null      int64  
 7   利润(元)     7 non-null      int64  
dtypes: float64(2), int64(4), object(2)
memory usage: 576.0+ bytes

isnull()函数查看是否有缺失值

在numpy模块中用isnan()函数

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
a = data.isnull()
print(a)

      编号     产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  False  False     False     False  False  False  False  False
1  False  False     False     False  False  False  False  False
2  False  False      True     False  False  False  False  False
3  False  False     False     False  False  False  False  False
4  False  False     False     False  False  False  False  False
5  False  False     False     False  False  False  False  False
6  False  False     False     False  False   True  False  False

2. 删除缺失值：dropna()函数

删除有缺失值的行

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
b = data.dropna()
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158

删除整行都为缺失值的行：需要指定how参数

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
c = data.dropna(how = 'all')
print(c)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包       NaN        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58     NaN   7192   3828

3. 缺失值的填充：fillna()函数

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
d = data.fillna(0)   # 缺失值全部填充为0
print(d)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包       0.0        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58     0.0   7192   3828

不同列的缺失值设置不同的填充值

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
e = data.fillna({'成本价(元/个)':16, '成本(元)':3364})
print(e)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包      16.0        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58  3364.0   7192   3828

5.2.4 处理重复值

import pandas as pd
data = pd.read_excel('产品统计表2.xlsx')
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a004  手提包        36       147     26    936   3822   2886   # 重复
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158

1. 删除重复行：drop_duplicates()函数

a = data.drop_duplicates()
print(a)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158

2. 删除某一列的重复值：subset参数

默认保留第一个重复值所在的行，删除其他重复值所在的行

b = data.drop_duplicates(subset = '产品')
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
3  a004  手提包        36       147     26    936   3822   2886
6  a006  单肩包        58       124     63   3654   7812   4158

保留第一个重复值所在的行

c = data.drop_duplicates(subset = '产品', keep = 'first')
print(c)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
3  a004  手提包        36       147     26    936   3822   2886
6  a006  单肩包        58       124     63   3654   7812   4158

保留最后一个重复值所在的行

d = data.drop_duplicates(subset = '产品', keep = 'last')
print(d)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
2  a003   背包        16        65     23    368   1495   1127
4  a004  手提包        36       147     26    936   3822   2886
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158

是重复的就删除

e = data.drop_duplicates(subset = '产品', keep = False)
print(e)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
6  a006  单肩包        58       124     63   3654   7812   4158

3. 获取唯一值：unique()函数

f = data['产品'].unique()
print(f)

['背包' '钱包' '手提包' '单肩包']

5.2.5 排序数据 1. sort_values()函数排序数据

import pandas as pd
data = pd.read_excel('产品统计表2.xlsx')
a = data.sort_values(by = '数量(个)', ascending = True) #第一个参数指定列  第二个参数指定升序
print(a)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a004  手提包        36       147     26    936   3822   2886
1  a002   钱包        90       187     50   4500   9350   4850
0  a001   背包        16        65     60    960   3900   2940
6  a006  单肩包        58       124     63   3654   7812   4158
5  a005   钱包        90       187     78   7020  14586   7566

降序如下

b = data.sort_values(by = '数量(个)', ascending = False)
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
3  a004  手提包        36       147     26    936   3822   2886
4  a004  手提包        36       147     26    936   3822   2886
2  a003   背包        16        65     23    368   1495   1127

2. rank()函数获取数据的排名

c = data['利润(元)'].rank(method = 'average', ascending = False)  #指定利润降序排序  有重复值则返回重复值的平均排名
print(c)

0    4.0
1    2.0
2    7.0
3    5.5
4    5.5
5    1.0
6    3.0
Name: 利润(元), dtype: float64

参数指定first时，表示在数据有重复值时，越先出现的数据排名越靠前

d = data['利润(元)'].rank(method = 'first', ascending = False)
print(d)

0    4.0
1    2.0
2    7.0
3    5.0
4    6.0
5    1.0
6    3.0
Name: 利润(元), dtype: float64

5.2.6 筛选数据

获取产品为单肩包的行数据

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data[data['产品'] == '单肩包']   #获取产品为单肩包的行数据
print(a)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

获取数量>60的行数据

b = data[data['数量(个)'] > 60]  # 获取数量>60的行数据
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158

获取产品为单肩包 且 数量>60 的行数据

c = data[(data['产品'] == '单肩包') & (data['数量(个)'] > 60)]
print(c)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
5  a006  单肩包        58       124     63   3654   7812   4158

获取产品为单肩包 或 数量>60 的行数据

d = data[(data['产品'] == '单肩包') | (data['数量(个)'] > 60)]
print(d)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

5.3 数据表的处理 5.3.1 转置数据表的行列：T属性

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.T
print(a)

             0     1     2     3      4     5     6
编号        a001  a002  a003  a004   a005  a006  a007
产品          背包    钱包    背包   手提包     钱包   单肩包   单肩包
成本价(元/个)    16    90    16    36     90    58    58
销售价(元/个)    65   187    65   147    187   124   124
数量(个)       60    50    23    26     78    63    58
成本(元)      960  4500   368   936   7020  3654  3364
收入(元)     3900  9350  1495  3822  14586  7812  7192
利润(元)     2940  4850  1127  2886   7566  4158  3828

5.3.2 将数据表转换成树形结构：stack()函数

import pandas as pd
data = pd.read_excel('产品统计表3.xlsx')
print(data)

     编号   产品  销售价(元/个)  数量(个)  收入(元)
0  a001   背包        65     60   3900
1  a002   钱包       187     50   9350
2  a003  单肩包       124     58   7192

stack()函数转换成树形结构

a = data.stack()
print(a)

0  编号          a001
   产品            背包
   销售价(元/个)      65
   数量(个)         60
   收入(元)       3900
1  编号          a002
   产品            钱包
   销售价(元/个)     187
   数量(个)         50
   收入(元)       9350
2  编号          a003
   产品           单肩包
   销售价(元/个)     124
   数量(个)         58
   收入(元)       7192
dtype: object

5.3.3 数据表的拼接

import pandas as pd
data1 = pd.read_excel('产品表.xlsx', sheet_name = 0)  #第0张工作簿
data2 = pd.read_excel('产品表.xlsx',sheet_name = 1)   #第1张工作簿
print(data1)
print(data2)

   员工编号 员工姓名 员工性别
0  a001   张三    男
1  a002   李四    女
2  a003   王五    男
3  a004   赵六    男
   员工编号 员工姓名    销售业绩
0  a001   张三  360000
1  a002   李四  458000
2  a003   王五  369000
3  a004   赵六  450000
4  a005   钱七  500000

1. merge()函数

a = pd.merge(data1, data2)  #行取交集  列取并集
print(a)

   员工编号 员工姓名 员工性别    销售业绩
0  a001   张三    男  360000
1  a002   李四    女  458000
2  a003   王五    男  369000
3  a004   赵六    男  450000

how参数指定外连接

b = pd.merge(data1, data2, how = 'outer')    #行取并集  列取并集
print(b)

   员工编号 员工姓名 员工性别    销售业绩
0  a001   张三    男  360000
1  a002   李四    女  458000
2  a003   王五    男  369000
3  a004   赵六    男  450000
4  a005   钱七  NaN  500000

on参数指定按哪一列合并

c = pd.merge(data1, data2, on = '员工姓名')
print(c)

  员工编号_x 员工姓名 员工性别 员工编号_y    销售业绩
0   a001   张三    男   a001  360000
1   a002   李四    女   a002  458000
2   a003   王五    男   a003  369000
3   a004   赵六    男   a004  450000

2. concat()函数

concat()函数采用全连接的方式，没有的数设置为缺失值

d = pd.concat([data1, data2])
print(d)

   员工编号 员工姓名 员工性别      销售业绩
0  a001   张三    男       NaN
1  a002   李四    女       NaN
2  a003   王五    男       NaN
3  a004   赵六    男       NaN
0  a001   张三  NaN  360000.0
1  a002   李四  NaN  458000.0
2  a003   王五  NaN  369000.0
3  a004   赵六  NaN  450000.0
4  a005   钱七  NaN  500000.0

重置行标签

e = pd.concat([data1, data2], ignore_index = True)  #重置行标签
print(e)

   员工编号 员工姓名 员工性别      销售业绩
0  a001   张三    男       NaN
1  a002   李四    女       NaN
2  a003   王五    男       NaN
3  a004   赵六    男       NaN
4  a001   张三  NaN  360000.0
5  a002   李四  NaN  458000.0
6  a003   王五  NaN  369000.0
7  a004   赵六  NaN  450000.0
8  a005   钱七  NaN  500000.0

3. append()函数

效果与concat()一样

f = data1.append(data2)
print(f)

   员工编号 员工姓名 员工性别      销售业绩
0  a001   张三    男       NaN
1  a002   李四    女       NaN
2  a003   王五    男       NaN
3  a004   赵六    男       NaN
0  a001   张三  NaN  360000.0
1  a002   李四  NaN  458000.0
2  a003   王五  NaN  369000.0
3  a004   赵六  NaN  450000.0
4  a005   钱七  NaN  500000.0

末尾添加行元素

g = data1.append({'员工编号':'a005', '员工姓名':'孙七', '员工性别':'男'}, ignore_index = True)
print(g)

   员工编号 员工姓名 员工性别
0  a001   张三    男
1  a002   李四    女
2  a003   王五    男
3  a004   赵六    男
4  a005   孙七    男

5.4 数据的运算 5.4.1 数据的统计运算：sum()、mean()、max()

1. 求和：sum()

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.sum()
print(a)

编号          a001a002a003a004a005a006a007
产品                     背包钱包背包手提包钱包单肩包单肩包
成本价(元/个)                             364
销售价(元/个)                             899
数量(个)                                358
成本(元)                              20802
收入(元)                              48157
利润(元)                              27355
dtype: object

指定列求和

b = data['利润(元)'].sum()
print(b)

27355

2. 求平均值：mean()

c = data.mean()
print(c)

成本价(元/个)      52.000000
销售价(元/个)     128.428571
数量(个)         51.142857
成本(元)       2971.714286
收入(元)       6879.571429
利润(元)       3907.857143
dtype: float64

指定列求均值

d = data['利润(元)'].mean()
print(d)

3907.8571428571427

3. 求最值：max()

e = data.max()
print(e)

编号           a007
产品             钱包
成本价(元/个)       90
销售价(元/个)      187
数量(个)          78
成本(元)        7020
收入(元)       14586
利润(元)        7566
dtype: object

指定列求最值

f = data['利润(元)'].max()
print(f)

7566

5.4.2 获取数值分布情况：describe()

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.describe()
print(a)

        成本价(元/个)    销售价(元/个)      数量(个)        成本(元)         收入(元)        利润(元)
count   7.000000    7.000000   7.000000     7.000000      7.000000     7.000000
mean   52.000000  128.428571  51.142857  2971.714286   6879.571429  3907.857143
std    31.112698   50.483849  20.053500  2391.447659   4352.763331  2002.194498
min    16.000000   65.000000  23.000000   368.000000   1495.000000  1127.000000
25%    26.000000   94.500000  38.000000   948.000000   3861.000000  2913.000000
50%    58.000000  124.000000  58.000000  3364.000000   7192.000000  3828.000000
75%    74.000000  167.000000  61.500000  4077.000000   8581.000000  4504.000000
max    90.000000  187.000000  78.000000  7020.000000  14586.000000  7566.000000

获取单列的

b = data['利润(元)'].describe()
print(b)

count       7.000000
mean     3907.857143
std      2002.194498
min      1127.000000
25%      2913.000000
50%      3828.000000
75%      4504.000000
max      7566.000000
Name: 利润(元), dtype: float64

5.4.3 计算相关系数：corr()

import pandas as pd
data = pd.read_excel('相关性分析.xlsx')
print(data)

   代理商编号  年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
0  A-001      20.5         15.6      2.00      0.80
1  A-003      24.5         16.7      2.54      0.94
2  B-002      31.8         20.4      2.96      0.88
3  B-006      34.9         22.6      3.02      0.79
4  B-008      39.4         25.7      3.14      0.84
5  C-003      44.5         28.8      4.00      0.80
6  C-004      49.6         32.1      6.84      0.85
7  C-007      54.8         35.9      5.60      0.91
8  D-006      58.5         38.7      6.45      0.90

corr()函数获取相关系数

a = data.corr()
print(a)

             年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
年销售额（万元）     1.000000     0.996275  0.914428  0.218317
年广告费投入额（万元）  0.996275     1.000000  0.918404  0.223187
成本费用（万元）     0.914428     0.918404  1.000000  0.284286
管理费用（万元）     0.218317     0.223187  0.284286  1.000000

获取指定列与其他列的相关系数

b = data.corr()['年销售额（万元）']
print(b)

年销售额（万元）       1.000000
年广告费投入额（万元）    0.996275
成本费用（万元）       0.914428
管理费用（万元）       0.218317
Name: 年销售额（万元）, dtype: float64

5.4.4 分组汇总数据：groupby()

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.groupby('产品')    #根据产品列分组
print(a)

groupby()函数返回的是一个DataframeBy对象，该对象包含分组后的数据，但是不能直观地显示出来。

b = data.groupby('产品').sum()
print(b)

     成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
产品                                                 
单肩包       116       248    121   7018  15004   7986
手提包        36       147     26    936   3822   2886
背包         32       130     83   1328   5395   4067
钱包        180       374    128  11520  23936  12416

分组后获取指定列的汇总情况

c = data.groupby('产品')['利润(元)'].sum()
print(c)

产品
单肩包     7986
手提包     2886
背包      4067
钱包     12416
Name: 利润(元), dtype: int64

获取多列的汇总情况

d = data.groupby('产品')['数量(个)', '利润(元)'].sum()
print(d)

     数量(个)  利润(元)
产品               
单肩包    121   7986
手提包     26   2886
背包      83   4067
钱包     128  12416

5.4.5 创建数据透视表：pivot_table()

• values参数用于指定要计算的列
• index参数用于指定一个列作为数据透视表的行标签
• aggfunc参数用于指定参数values的计算类型

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = pd.pivot_table(data, values = '利润(元)', index = '产品', aggfunc = 'sum')  #data.groupby('产品')['利润(元)'].sum()  同样功能
print(a)

     利润(元)
产品        
单肩包   7986
手提包   2886
背包    4067
钱包   12416

获取多列的情况

b = pd.pivot_table(data, values = ['利润(元)', '成本(元)'], index = '产品', aggfunc = 'sum')
print(b)

     利润(元)  成本(元)
产品               
单肩包   7986   7018
手提包   2886    936
背包    4067   1328
钱包   12416  11520

ta = pd.read_excel(‘相关性分析.xlsx’)
print(data)

```python
   代理商编号  年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
0  A-001      20.5         15.6      2.00      0.80
1  A-003      24.5         16.7      2.54      0.94
2  B-002      31.8         20.4      2.96      0.88
3  B-006      34.9         22.6      3.02      0.79
4  B-008      39.4         25.7      3.14      0.84
5  C-003      44.5         28.8      4.00      0.80
6  C-004      49.6         32.1      6.84      0.85
7  C-007      54.8         35.9      5.60      0.91
8  D-006      58.5         38.7      6.45      0.90

corr()函数获取相关系数

a = data.corr()
print(a)

             年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
年销售额（万元）     1.000000     0.996275  0.914428  0.218317
年广告费投入额（万元）  0.996275     1.000000  0.918404  0.223187
成本费用（万元）     0.914428     0.918404  1.000000  0.284286
管理费用（万元）     0.218317     0.223187  0.284286  1.000000

获取指定列与其他列的相关系数

b = data.corr()['年销售额（万元）']
print(b)

年销售额（万元）       1.000000
年广告费投入额（万元）    0.996275
成本费用（万元）       0.914428
管理费用（万元）       0.218317
Name: 年销售额（万元）, dtype: float64

5.4.4 分组汇总数据：groupby()

[外链图片转存中…(img-tAL70SvI-1639558108736)]

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.groupby('产品')    #根据产品列分组
print(a)

groupby()函数返回的是一个DataframeBy对象，该对象包含分组后的数据，但是不能直观地显示出来。

b = data.groupby('产品').sum()
print(b)

     成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
产品                                                 
单肩包       116       248    121   7018  15004   7986
手提包        36       147     26    936   3822   2886
背包         32       130     83   1328   5395   4067
钱包        180       374    128  11520  23936  12416

分组后获取指定列的汇总情况

c = data.groupby('产品')['利润(元)'].sum()
print(c)

产品
单肩包     7986
手提包     2886
背包      4067
钱包     12416
Name: 利润(元), dtype: int64

获取多列的汇总情况

d = data.groupby('产品')['数量(个)', '利润(元)'].sum()
print(d)

     数量(个)  利润(元)
产品               
单肩包    121   7986
手提包     26   2886
背包      83   4067
钱包     128  12416

5.4.5 创建数据透视表：pivot_table()

• values参数用于指定要计算的列
• index参数用于指定一个列作为数据透视表的行标签
• aggfunc参数用于指定参数values的计算类型

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = pd.pivot_table(data, values = '利润(元)', index = '产品', aggfunc = 'sum')  #data.groupby('产品')['利润(元)'].sum()  同样功能
print(a)

     利润(元)
产品        
单肩包   7986
手提包   2886
背包    4067
钱包   12416

获取多列的情况

b = pd.pivot_table(data, values = ['利润(元)', '成本(元)'], index = '产品', aggfunc = 'sum')
print(b)

     利润(元)  成本(元)
产品               
单肩包   7986   7018
手提包   2886    936
背包    4067   1328
钱包   12416  11520