Python学习笔记（9-1）：数据分析——数据运算
Python学习笔记（9-1）：数据分析——数据运算
- 一、算术运算
-
- 1、基础一元及二元运算
-
- （1）一元算术运算
- （2）二元算术运算
- （3）二元逻辑运算
- （4）二元比较运算
- 2、三角函数
- 3、指对数工具
-
- （1）指数部分
- （2）对数部分
- 4、精度调整工具
- 5、向量元素和、差分、乘积运算
-
- （1）求向量和、累积和
- （2）求向量积、累积向量积
- （3）求差分
- 二、排序与查找
-
- 1、排序
-
- （1）列表排序
-
- ① .sort()
- ② sorted()
- （2）numpy数组排序
-
- ① np.sort()
- ② np.msort()
- ③ np.argsort()
- （3）Series和DataFrame排序
-
- ① .sort_values()
- ② .sort_index()
- 2、查找
-
- （1）查找最大值、最小值
- （2）查找满足特定条件的元素：np.where()
- （3）查找不重复的元素 ：np.unique()
- 结语
文章导读
- 课程难度：★★☆☆☆
- 重要度：★★★☆☆
- 预计学习时间：1小时
- 简介：本节主要讲解了python数据分析中数据运算的部分，包括：（1）基于基础一、二元的各种运算、三角函数的创建与运算、指对数的各种运算、调整精度的方法以及求向量和、差分及乘积等运算；（2）列表、numpy数组、Series和Dataframe数据的排序与查找问题。
- 重点涉及的函数和内容：np.round()、.sort()、sorted()、.argsort()、.sort_values()、.sort_index()、np.where()。
关于数学运算集中在numpy和scipy，而数据分析应用则主要集中在pandas。因此，我们在数据分析方面以DataFrame为素材讲解，在数学运算方面主要以numpy 数组为素材讲解，但有一些内置库的相似方法我们也会涉及。
我们首先将如下函数库引入：
import numpy as np
import pandas as pd
import scipy
一、算术运算
我们一般用numpy实现数学运算领域的各种功能，因此在这里主要围绕numpy进行讲解。当然，有许多函数名称、调用方法和返回结果相同的函数，也存在于内置方法库和pandas中，我们这里也会进行一一地讲解。
首先提一下我们常使用的一些科学常数。这里包括自然对数的底数e、欧拉常数γ(调和级数和自然对数差值的极限)、以及π。其余的np.nan、np.inf等在之前讲解过：
np.e
np.euler_gamma
np.pi
我们首先建立部分将在后续经常用于展示运算效果的数据：
x = np.array([100.45, 100.02, 100.0, 99.97, 100.05])
x1 = np.array([104.15, 98.72, 100.0, 102.25, 99.65])
y = np.array([1.639, 0.578, 1.031, 1.031, 0.59])
z = np.array([-4.5, -3, 2.5, 0.76, -0.5])
w = np.array([np.inf, np.nan, float('nan'), 1e10, 500])
x_int = np.array([13, 25, 24, 16, 33])
y_int = np.array([7, 5, 15, 20, 22])
x_bit = np.array([0b0101, 0b0110, 0b0101, 0b1010, 0b1101])
y_mv = np.array([1, 1, 1, 1, 1])
y_bit = np.array([0b0011, 0b1010, 0b0101, 0b1101, 0b0111])
x_bool = np.array([True, False, True, True, False])
y_bool = np.array([False, False, True, False, True])
x_array = np.array([[1, 2],[3, 4],[5, 6]]) # 3 * 2矩阵
y_array = np.array([[1, 2, 3, 4],[5, 6, 7, 8]]) # 2 * 4矩阵
1、基础一元及二元运算
我们首先介绍我们最为基础的一些运算，包括我们的加减乘除等等。这些运算可以分成几类，例如分成一元或二元运算、分成算数计算、逻辑计算，算数计算其中还有位运算等等。
常用的算术运算符包括：
+，-，*，/，** # 加、减、乘、除、乘方
//，% # 整数除法、整数除法的余数
&，|，~，^ # 与、或、非、亦或运算
<<，>> # 位运算
@ # 矩阵乘法
常用的比较运算符包括：
<，<= # 小于、小于等于
>，>= # 大于、大于等于
==，!= # 等于、不等于
（1）一元算术运算
一元运算符首先包括+、-和~，分别表示正、负和按位取反：
+ x # np.positive(x)
- x # np.negative(x)
~x # np.invert(x_bit)
~x_bool # np.invert(x_bool)
执行上述代码，各自的运算结果如下：
[100.45 100.02 100. 99.97 100.05]
[-100.45 -100.02 -100. -99.97 -100.05]
[ -6 -7 -6 -11 -14]
[False True False False True]
其余一元运算函数包括：
np.modf(x) # 原值的整数和小数部分，形式为以两个ndarray数组组成的元组
np.fabs(x) # 原值的绝对值，另有np.absolute(x)
np.reciprocal(x) # 原值的倒数
np.sqrt(x) # 原值的平方根 square root，等同于x ** (1/2)
np.cbrt(x) # 原值的立方根 cube root，等同于x ** (1/3)
np.square(x) # 原值的平方，等同于x ** (2)
（2）二元算术运算
可以通过运算符完成的包括+、-、*、/、//、%和**，这些运算符实现的运算含义和前面所描述的一致：
x + y # np.add(x, y)
x - y # np.subtract(x, y)
x * y # np.multiply(x, y)
x / y # np.divide(x, y), 另有np.true_divide(x, y)
x // y # np.floor_divide(x, y)
x % y # np.mod(x, y), 另有np.fmod(x, y)、np.remainder(x, y)
x ** y # np.power(x, y), 另有np.float_power(x, y)
x_array @ y_array # np.dot(x_array, y_array)
各自的运算结果如下：
[102.089 100.598 101.031 101.001 100.64 ]
[98.811 99.442 98.969 98.939 99.46 ]
[164.63755 57.81156 103.1 103.06907 59.0295 ]
[ 61.28737035 173.0449827 96.99321048 96.96411251 169.57627119]
[ 61. 173. 96. 96. 169.]
[0.471 0.026 1.024 0.994 0.34 ]
[1910.71517777 14.32353453 115.34532578 115.30964964 15.14007703]
[[11 14 17 20]
[23 30 37 44]
[35 46 57 68]]
其余二元算数函数包括：
np.divmod(x, y) # 同时返回相除的整数部分和余数，形式为以两个
# ndarray数组组成的元组，等于floor_divide和mod的合并
np.gcd(x_int, y_int) # 最大公约数，greatset common divisor
np.lcm(x_int, y_int) # 最小公倍数，lowest common multiple
np.maximum(x, x1) # 两个数组中对应元素的较大值，另有np.fmax(x, x1)
np.minimum(x, x1) # 两个数组中对应元素的较小值，另有np.fmin(x, x1)
各自的运算结果如下：
array([ 61., 173., 96., 96., 169.]), array([0.471, 0.026, 1.024, 0.994, 0.34 ]))
[ 1 5 3 4 11]
[ 91 25 120 80 66]
[104.15 100.02 100. 102.25 100.05]
[100.45 98.72 100. 99.97 99.65]
（3）二元逻辑运算
首先是**布尔运算中的逻辑运算符&、|、~、^ ：在这里插入代码片
x_bool & y_bool # np.logical_and(x_bool, y_bool)
x_bool | y_bool # np.logical_or(x_bool, y_bool)
~x_bool # np.logical_not(x_bool)
x_bool ^ y_bool # np.logical_xor(x_bool, y_bool)
各自的运算结果如下：
[False False True False False]
[ True False True True True]
[False True False False True]
[ True False False True True]
接下来是二进制位的逻辑运算符&、|、~、^，这些符号同样适用于二进制位。为便于展示，这里用二进制形式展示各二进制值：
[format(intvalue, '#b') for intvalue in (x_bit & y_bit)] # np.bitwise_and(x_bit, y_bit)
# 位运算的与运算
[format(intvalue, '#b') for intvalue in (x_bit | y_bit)] # np.bitwise_or(x_bit, y_bit)
# 位运算的或运算
[format(intvalue, '#b') for intvalue in (~x_bit)] # np.invert(x_bit)
# 位运算的非运算
# 原码为补码取反后加1
[format(intvalue, '#b') for intvalue in (x_bit ^ y_bit)] # np.bitwise_xor(x_bit, y_bit)
# 位运算的异或运算
各自的运算结果如下：
['0b1', '0b10', '0b101', '0b1000', '0b101']
['0b111', '0b1110', '0b101', '0b1111', '0b1111']
['-0b110', '-0b111', '-0b110', '-0b1011', '-0b1110']
['0b110', '0b1100', '0b0', '0b111', '0b1010']
二进制位的位运算符 <<、>>，为便于展示，这里用二进制形式展示各二进制值：
[format(intvalue, '#b') for intvalue in (x_bit)]
[format(intvalue, '#b') for intvalue in (x_bit << y_mv)] # np.left_shift(x_bit, y_mv)
# 将x向左移y位。
[format(intvalue, '#b') for intvalue in (x_bit >> y_mv)] # np.right_shift(x_bit, y_mv)
# 将x向右移y位
各自的运算结果如下：
['0b101', '0b110', '0b101', '0b1010', '0b1101']
['0b1010', '0b1100', '0b1010', '0b10100', '0b11010']
['0b10', '0b11', '0b10', '0b101', '0b110']
除了上述逻辑运算外，其他逻辑运算函数包括：
np.all(x_bool) # 是否所有的元素都为True
np.any(x_bool) # 是否至少有一个元素为True
np.isnan(w) # 原值是否为缺失值
np.isinf(w) # 原值是否为无穷大
# 另有np.isposinf(w)和np.isneginf(w)，判断正/负无穷大
np.isfinite(w) # 原值是否不为空值或异常值
各自的运算结果如下：
False
True
[False True True False False]
[ True False False False False]
[False False False True True]
（4）二元比较运算
比较运算符主要包括<、<=、>、>=、==、!=，各自符号的含义和本节最初所提到的各类二元比较符号的含义相同：
x > x1 # np.greater(x, x1)
x >= x1 # np.greater_equal(x, x1)
x < x1 # np.less(x, x1)
x <= x1 # np.less_equal(x, x1)
x == x1 # np.equal(x, x1)
x != x1 # np.not_equal(x, x1)
各自的运算结果如下：
[False True False False True]
[False True True False True]
[ True False False True False]
[ True False True True False]
[False False True False False]
[ True True False True True]
对于赋值和算术运算结合在一起的运算符+=、*=等，除了 @ 之外的所有的二元算术运算符都适用：
x_tmp1 = x.copy()
x_tmp2 = x.copy()
x_tmp3 = x_bool.copy()
x_tmp4 = x_bool.copy()
x_tmp1 *= 2
x_tmp2 *= y
x_tmp3 ^= True
x_tmp4 ^= y_bool
x_tmp1
x_tmp2
x_tmp3
x_tmp4
通过上述运算后，各自的结果如下：
[200.9 200.04 200. 199.94 200.1 ]
[164.63755 57.81156 103.1 103.06907 59.0295 ]
[False True False False True]
[ True False False True True]
关于算术运算和赋值运算结合的操作，有一件事需要提醒一下，这就是运算结果的数据类型由整个运算过程的所有对象决定。
2、三角函数
三角函数的运算都是基于弧度的，角度的话需要运用函数库另外转换。在此，仍然建立我们的一些参数序列：
x_deg = np.array([0, 30, 45, 60, 90])
x_rad = np.array([0, np.pi/6, np.pi/4, np.pi/3, np.pi/2])
x_arcvalue1 = np.array([0, 0.5, np.sqrt(2)/2, np.sqrt(3)/2, 1])
x_arcvalue2 = np.array([0, np.sqrt(3)/3, 1, np.sqrt(3), 1e8])
x_side = np.array([2.5, 4.3, 1.0, 5.4, 3.3])
y_side = np.array([5.4, 1.8, 2.6, 3.3, 4.2])
我们以弧度的数组举例：
np.sin(x_rad)
np.cos(x_rad)
np.tan(x_rad)
输出结果如下：
array([0. , 0.5 , 0.70710678, 0.8660254 , 1. ])
array([1.00000000e+00, 8.66025404e-01, 7.07106781e-01, 5.00000000e-01,
6.12323400e-17])
array([0.00000000e+00, 5.77350269e-01, 1.00000000e+00, 1.73205081e+00,
1.63312394e+16])
反三角函数返回的值也是弧度，便于展示结果，在此将反三角函数的结果转成角度：
(np.arcsin(x_arcvalue1) / np.pi) * 180
(np.arccos(x_arcvalue1) / np.pi) * 180
(np.arctan(x_arcvalue2) / np.pi) * 180 # 这里可以看到这里的arctan的精度不高，
# 在1e8的情况下已经算成90度
输出结果如下：
array([ 0., 30., 45., 60., 90.])
array([90., 60., 45., 30., 0.])
array([ 0. , 30. , 45. , 60. , 89.99999943])
配套的，弧度和角度的互转如下：
np.deg2rad(x_deg) # 角度转弧度，等同的函数还有np.radians(x_deg)
np.rad2deg(x_rad) # 弧度转角度，等同的函数还有np.degrees(x_rad)
各自的运算结果如下：
array([0. , 0.52359878, 0.78539816, 1.04719755, 1.57079633])
array([ 0., 30., 45., 60., 90.])
3、指对数工具
我们此前提到的的 ** 符号能支持我们的指数运算，但之前所提到的函数并没有支持取对数的运算。在此，我们逐一介绍一些以e、2、10位底数的指数和对数运算。我们先定义一些数据：
x = np.array([100.45, 100.02, 100.0, 99.97, 100.05])
y = np.array([1.639, 0.578, 1.031, 1.031, 0.59])
y1 = np.array([0.876, 1.452, 1.822, 0.932, 0.433])
x_int = np.array([13, 25, 24, 16, 33])
y_int = np.array([7, 5, 15, 20, 22])
（1）指数部分
np.exp(y_int) # 计算一个自然对数为底的指数值，等同于np.e ** y
np.expm1(y_int) # exp minus 1, 即计算一个自然对数为底的指数值减1
np.exp2(y_int) # 计算一个2为底的指数值
运算结果如下：
[ 2.71828183 7.3890561 20.08553692 54.59815003 148.4131591 ]
[ 1.71828183 6.3890561 19.08553692 53.59815003 147.4131591 ]
[ 2. 4. 8. 16. 32.]
（2）对数部分
np.log(x_int) # 以自然对数为底的对数
np.log1p(x_int) # log 1 plus, 以自然对数为底的对数值加1
np.log2(x_int) # 以2为底的对数
np.log10(x_int) # 以10为底的对数
各自的运算结果如下：
[2.56494936 3.21887582 3.17805383 2.77258872 3.49650756]
[2.63905733 3.25809654 3.21887582 2.83321334 3.52636052]
[3.70043972 4.64385619 4.5849625 4. 5.04439412]
[1.11394335 1.39794001 1.38021124 1.20411998 1.51851394]
指对数结合的一些其他函数：
np.logaddexp(y, y1) # 对于x1，x2, 计算log(exp(x1) + exp(x2)).
np.logaddexp(y, y1) # 对于x1，x2, 计算log2(exp2(x1) + exp2(x2)).
np.ldexp(x_int, y_int) # 返回 x * (2 ** y)
np.frexp(x_int) # 将原值分解为尾数和以2为底的指数
# 尾数 * ( 2 ** 指数) = 原值
各自的运算结果如下：
[2.02171871 1.8007389 2.19589957 1.67587181 1.20772515]
[2.02171871 1.8007389 2.19589957 1.67587181 1.20772515]
[1.664000e+03 8.000000e+02 7.864320e+05 1.677721e+07 1.384120e+08]
(array([0.8125 , 0.78125 , 0.75, 0.5, 0.515625]), array([4, 5, 5, 5, 6], dtype=int32))
4、精度调整工具
精度调整的工具可能比我们想象的要多许多，我们这里做一个归纳。我们指出所需要的数据：
y = np.array([1.639, 0.578, 1.031, 1.031, 0.59])
z = np.array([-4.5, -3, 2.5, 0.76, -0.5])
z1 = np.array([-4.5, -3.5, -2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5, 4.5])
在精度调整中，最重要的就是**np.round()函数**，四舍五入保存至个位，有一个等同的函数np.around()。这个函数可以补充一个数字指定保存到几位小数，默认是0也即整数，若为负数，则精度的小数点向左移动（即为-1时保存到10位、为-2时保存到百位）：
np.round(y) # 等同的函数有np.around(y)
np.round(y, 1)
np.round(y, -1)
输出结果如下：
[2. 1. 1. 1. 1.]
[1.6 0.6 1. 1. 0.6]
[0. 0. 0. 0. 0.]
精度调整有一个需要注意的重要问题在于尾数是5（例如0.5）时候的情况，需要专门拿出来提示。它并不是我们默认的满5进1，而是在尾数为5时，前一位是奇数则进一，如果是偶数则舍去。而且，此时四舍五入计算所得的0是有符号的：
np.round(z1)
输出结果如下：
array([-4., -4., -2., -2., -0., 0., 2., 2., 4., 4.])
还有一些取原值的整数部分、小数部分等等的函数，归纳如下：
np.sign(z) # 符号（正为1，负为-1，0为0）
np.rint(z) # 最接近的整数
np.floor(z) # 不大于原值的最大整数
np.ceil(z) # 不小于原值的最小整数
np.trunc(z) # 截断小数部分，只留下整数部分
np.modf(z) # 同时保留原值的整数和小数部分
# 形式为以两个ndarray数组组成的元组
各自的运算结果如下：
[-1. -1. 1. 1. -1.]
[-4. -3. 2. 1. -0.]
[-5. -3. 2. 0. -1.]
[-4. -3. 3. 1. -0.]
[-4. -3. 2. 0. -0.]
(array([-0.5 , -0. , 0.5 , 0.76, -0.5 ]), array([-4., -3., 2., 0., -0.]))
5、向量元素和、差分、乘积运算
这一块包含了向量内部元素的和、乘积与差分，同时也补充了二维和三维向量的叉积的计算方式。本节所需要的数据如下：
x = np.array([100.45, 100.02, 100.0, 99.97, 100.05])
y = np.array([1.639, 0.578, 1.031, 1.031, 0.59])
y_cross1 = np.array([1.639, 0.578, 1.031])
y_cross2 = np.array([0.578, 1.031, 1.031])
x_nan = np.array([100.45, 100.02, np.nan, 99.97, 100.05])
y_nan = np.array([1.639, np.nan, 1.031, np.nan, 0.59])
x_array = np.array([[1, 2],[3, 4],[5, 6]]) # 3 * 2矩阵
y_array = np.array([[1, 2, 3, 4],[5, 6, 7, 8]]) # 2 * 4矩阵
（1）求向量和、累积和
之前的函数，在处理nan值时由于nan的性质，返回结果会变成nan值，对于求和和乘积，有能够忽略nan值参与计算的方法，即在各种函数名之后加一个nan，例如这里的求和函数np.sum()，忽略nan值的同等方法为np.nansum()。之后讲到的统计函数也有能够忽略nan值的统计函数，形式和这里的很类似:
np.sum(x) # 求向量各元素的和
np.sum(x_nan) # 当向量中元素存在nan值时，会返回nan值
np.nansum(x_nan) # 求向量各非nan值元素的和，忽略nan值
np.cumsum(x) # 求向量各元素的累积和，返回一个向量，
# 各元素的值是原向量内该位置元素及之前元素的和
np.cumsum(x_nan) # 但请注意这个函数并不忽略inf值，可以自行尝试一下
np.nancumsum(x_nan) # 求向量各非nan值元素的累积和，当遇到nan值将其看做0
各自的运算结果如下：
500.49
nan
400.49
[100.45 200.47 300.47 400.44 500.49]
[100.45 200.47 nan nan nan]
[100.45 200.47 200.47 300.44 400.49]
（2）求向量积、累积向量积
计算方式与刚刚的np.sum()和np.cumsum()相似。同样，也有忽略nan值的对应方法：
np.prod(y) # 求向量各元素的积
np.prod(y_nan)
np.nanprod(y_nan) # 求向量各非nan值元素的积
np.cumprod(y) # 求向量各元素的累积乘积，返回一个向量，
# 各元素的值是原向量内该位置元素及之前元素的积
np.cumprod(y_nan) # 同上，不忽略inf值
np.nancumprod(y_nan) # 求向量各非nan值元素的累积乘积，当遇到nan值将其看做1
各自的运算结果如下：
0.5941226838005798
nan
0.9969873099999998
[1.639 0.947342 0.9767096 1.0069876 0.59412268]
[1.639 nan nan nan nan]
[1.639 1.639 1.689809 1.689809 0.99698731]
（3）求差分
① np.diff()
np.diff()函数主求差分，默认求一阶差分，即前一个值减去后一个值。可传一个补充参数描述求第n阶差分，这时就是一阶差分的迭代调用。调用方法及运算结果如下：
np.diff(x)
np.diff(y, 2) # 等同于np.diff(np.diff(y))
输出结果如下：
[-0.43 -0.02 -0.03 0.08]
[ 1.514 -0.453 -0.441]
② np.ediff1d()
np.ediff1d()只求一阶差分，但是允许补充to_end和to_begin参数，作为返回序列的头和尾，头部和尾部的值并不参与到原始的求差分运算中。调用方法及运算结果如下：
np.ediff1d(y, 10, [15, 20]) # 位置上第二个参数是to_end，第三个参数是to_begin
输出结果如下：
array([ 15. , 20. , -1.061, 0.453, 0. , -0.441, 10. ])
③ np.gradient()
np.gradient()函数求梯度，允许接收n维数组调用方法及运算结果如下：
np.gradient(y)
np.gradient(y_array)
输出结果如下：
[-1.061 -0.304 0.2265 -0.2205 -0.441 ]
[array([[4., 4., 4., 4.], [4., 4., 4., 4.]]), array([[1., 1., 1., 1.], [1., 1., 1., 1.]])]
④ np.cross()
np.cross()，求向量叉积（ 一般对应相乘求的是内积，叉积是a * b * sin（θ），求的是向量a和b构成平面的法向量。在空间向量中，三维叉积的运算结果是a=[a1，a2，a3]，b=[b1，b2，b3]，则a×b=[a2b3-a3b2, a3b1-a1b3, a1b2-a2b1]），接收的数组必须是二维或是三维的（对于高维数组，最后一维的维度是2或3）。调用方法及运算结果如下：
np.cross(y_cross1, y_cross2)
输出结果如下：
[-0.467043, -1.093891, 1.355725]
二、排序与查找
1、排序
这里准备一些需要的数据：
x = np.array([100.45, 100.02, 100.0, 99.97, 100.05])
y = np.array([1.639, 0.578, 1.031, 1.031, 0.59])
x_nan = np.array([100.45, 100.02, np.nan, 99.97, 100.05])
y_nan = np.array([1.639, np.nan, 1.031, np.nan, 0.59])
xy_ary = np.array([x, y]) # 一个2 * 5的数组
xy_ary_nan = np.array([x_nan, y_nan])
（1）列表排序
列表的排序使用函数.sort()和sorted()，原排序结果是从小到大，比较规则按照各种元素（如数值、字符串、列表等）之间既有的比较规则.
① .sort()
.sort()函数是一个列表的成员函数。它可以接两个参数，key和reverse。这个函数没有返回值，是在原列表上进行的修改。常用的参数如下：
key：它是一个函数的名字，表示对列表中的元素，用一个函数处理后的值做排序。
reverse：它是表示是否需要再做一次反序，将结果从大到小输出。
具体示例如下：
先讲解**reverse参数**：
a = [1, -3, 5, 6, -9]
a.sort()
print(a)
a = [1, -3, 5, 6, -9]
a.sort(reverse = True)
print(a)
输出结果如下：
[-9, -3, 1, 5, 6]
[6, 5, 1, -3, -9]
再来讲解**key参数**。它可以用我们的一个函数名，也可以是一个匿名函数的定义。在此我们单独定义一个求平方的函数作为传递给key的参数：
def a2(a):
return a ** 2
a = [1, -3, 5, 6, -9]
a.sort(key = a2, reverse = True) # 对a的平方值进行排序，同时将结果反序输出
# 传入key参数后，不是对原始值，
# 而是对列表元素在函数处理后的结果进行排序
print(a)
输出结果如下：
[-9, 6, 5, -3, 1]
② sorted()
与.sort()不同，sorted()是一个内置的方法，它能接收的参数、具体的用法都是一样的，但是它有返回值，而且不会改变原列表。我们参考刚刚的例子，重新使用这两个参数以展示其效果，因为用法是相似的，所以不再重复讲解：
a = ['one', 'two', 'three', 'four']
print(sorted(a)) # 将a升序排序
print(sorted(a, reverse = True)) # 将a降序排序
print(sorted(a, key = len)) # 将a根据字符串长度进行升序排序
print(a) # 验证这种修改并未影响原值
输出结果如下：
['four', 'one', 'three', 'two']
['two', 'three', 'one', 'four']
['one', 'two', 'four', 'three']
['one', 'two', 'three', 'four']
总之，.sort()是列表的成员函数，用待排序的列表加点 . 访问，而sorted()是内置方法，直接接一个待排序列表参数。sort会改变原列表的值，没有返回值，而sorted不会改变原值，返回值是排序完毕的列表。这些细节需要多多注意。
（2）numpy数组排序
① np.sort()
对值做排序最基础的排序工具是np.sort()。一般可以用得上的是axis参数，指示按照哪个维度排序，默认是最后一个维度，如果为None则将数组压成一维进行排序。
这个函数结果产生的排序结果是升序的，没有参数可以指示让输出结果降序排列。当然在前面的课程里，怎么将数组反序我们已经学过了（访问[::-1]）。同时，排序的结果里面缺失值会被放在最后面，我们举如下例子观察效果：
np.sort(xy_ary) # 对最末一个维度进行排序
np.sort(xy_ary, axis = 0) # 对axis为0的轴进行排序
np.sort(xy_ary, axis = None)[::-1] # 将所有数据压成一维，排序后进行反序
np.sort(xy_ary_nan) # 对带有nan值的数组进行排序
各自的运算结果如下：
[[ 99.97 100. 100.02 100.05 100.45 ]
[ 0.578 0.59 1.031 1.031 1.639]]
[[ 1.639 0.578 1.031 1.031 0.59 ]
[100.45 100.02 100. 99.97 100.05 ]]
[100.45 100.05 100.02 100. 99.97 1.639 1.031 1.031 0.59 0.578]
[[ 99.97 100.02 100.05 100.45 nan]
[ 0.59 1.031 1.639 nan nan]]
np.sort()有两个近似的函数，一个是numpy数组的.sort()方法，这是numpy数组的成员函数。这个函数会直接改变原值，无返回值。axis参数近似np.sort，但不能传递None。
xy_ary_tmp = np.array([x, y]) # 重建一个为了防止xy_ary被修改
xy_ary_tmp.sort()
xy_ary_tmp
y_ary_tmp = np.array([x, y]) # 重建一个为了防止xy_ary被修改
xy_ary_tmp.sort(axis = 0)
xy_ary_tmp
输出结果如下：
[[ 99.97 100. 100.02 100.05 100.45 ]
[ 0.578 0.59 1.031 1.031 1.639]]
[[ 1.639 0.578 1.031 1.031 0.59 ]
[100.45 100.02 100. 99.97 100.05 ]]
② np.msort()
其方法为对第一维数据进行排序，处理结果类似于np.sort(xy_ary, axis = 0)
np.msort(xy_ary)
输出结果如下：
array([[ 1.639, 0.578, 1.031, 1.031, 0.59 ],
[ 100.45 , 100.02 , 100. , 99.97 , 100.05 ]])
③ np.argsort()
这个函数返回的是一个下标列表，下标列表的顺序是被自小到大重排的各个元素的下标。用原数组访问这个返回结果会得到原数组排序的结果，这就是它与数组排序的结果的关系。
与np.sort()函数相同，缺失值的下标会被放在最后面；同时，axis参数同样适用。
np.argsort(xy_ary)
np.argsort(xy_ary_nan)
np.argsort(xy_ary, axis = 0)
np.argsort(xy_ary, axis = None)
ind = np.argsort(x)
x[ind] # 用原数组访问返回结果，得到排序后的数组
各自的运算结果如下：
[[3 2 1 4 0]
[1 4 2 3 0]]
[[3 1 4 0 2]
[4 2 0 1 3]]
[[1 1 1 1 1]
[0 0 0 0 0]]
[6 9 7 8 5 3 2 1 4 0]
array([ 99.97, 100. , 100.02, 100.05, 100.45])
（3）Series和DataFrame排序
sort_values()和.sort_index()都是Series和DataFrame的成员函数，我们围绕DataFrame进行讲解。
① .sort_values()
该函数是对值进行排序，我们会主要使用如下参数：
by：指示排序的面向对象列表，它是第一个参数、必须给出。可以传一个字符串或一个列/行索引值的列表，函数按给出排序列表的先后顺序排序。
axis：指示排序是按行还是按列排序（默认是0即对列样本排序）。
ascending：指示排序是升序或是降序（默认为True即升序），可以传递一个与排序列表等长的布尔列表。
na_position：指示排序列表中如果是空值放在最前还是最后，可选'first', 'last'，默认为最后（'last'）。
各种参数的调用方式举例如下。因为输出的文本量较大，为图简洁，在此不展示程序执行的最终结果：
frame_nan.sort_values(['210X1']) # 基本的按单列排序
frame_nan.sort_values(['210X1'], na_position = 'first') # 将空值置于最前面
frame_nan.sort_values([0], axis = 1) # 对行样本进行排序 # 传入行索引
frame_ori.sort_values(['TOOL', 'Value']) # 对多列进行排序
# 先排TOOL，再排Value
frame_ori.sort_values(['TOOL', 'Value'], ascending = False) # 以降序排列
② .sort_index()
与.sort_values()对应的是.sort_index()函数，它是对行或列的索引排序，因此它的参数没有by。但其他的参数axis、ascending、na_position都是意义一样的。我们将原来的列表按照打乱顺序，举两个简单的例子如下。同上，在此不展示程序执行的最终结果。
frame_indexsorted = frame_ori.sort_values(['TOOL', 'Value'])# 打乱原DataFrame索引
frame_indexsorted.sort_index() # 按行重排索引
frame_indexsorted.sort_index(axis = 1) # 按列重排索引
frame_indexsorted.sort_index(ascending = False) # 将索引降序排列
至此，我们对我们的排序做一个总结：
列表做排序时，可以自由地定义排序的规则（函数），但一次只能对列表中的各个元素排序，即不能按选择按列排等等。
numpy的数组支持不同的维度排，也可以找到排序顺序对应的元素下标，但是它无法定义排序方式，而且排序只能从小到大排。
pandas dataframe支持按照行或者列的值或者索引排序，排序结果的展示也比较美观，但是它也无法定义排序方法，而且只能排二维的数据。
各种排序方法都有其优缺点，所幸的是我们这些数据结构之间的互转方便，我们能在我们需要的时候进行灵活的运用。
2、查找
这里所说的查找主要有两重意思，主要是面向下标的查找。一是找到最大值、最小值等等，它的值或是所在的下标，二是筛选出满足特定要求的值的元素下标。
我们仍旧建立本节中相应的元素如下：
x = np.array([100.45, 100.02, 100.0, 99.97, 100.05])
y = np.array([1.639, 0.578, 1.031, 1.031, 0.59])
x_nan = np.array([100.45, 100.02, np.nan, 99.97, 100.05])
y_nan = np.array([1.639, np.nan, 1.031, np.nan, 0.59])
x_0 = np.array([100.45, 100.02, 0, 99.97, 100.05])
y_0 = np.array([1.639, 0, 1.031, 0, 0.59])
xy_ary = np.array([x, y])
xy_ary_nan = np.array([x_nan, y_nan])
xy_ary_0 = np.array([x_0, y_0])
（1）查找最大值、最小值
首先是查找最大值、最小值以及所在的下标，我们用np.argmax()和np.argmin()函数。类似于np.nansum()、np.nanprod()函数，这里也有np.nanargmax()和np.nanargmin()函数可以调用。
求最大值及其下标的函数整理如下：
np.max(xy_ary) # 计算整个数组最大值
np.max(xy_ary, axis = 1) # 以轴1分别计算最大值
np.argmax(xy_ary) # 数组转为1维后，最大值的下标
np.argmax(xy_ary, axis = 1) # 以轴1分别计算最大值的下标
np.nanmax(xy_ary_nan, axis = 1) # 以轴1分别计算最大值，忽略缺失值
np.nanargmax(xy_ary_nan, axis = 1) # 以轴1分别计算最大值下标，忽略缺失值
输出结果如下：
100.45
[100.45 1.639]
0
[0 0]
[100.45 1.639]
[0 0]
与求最大值相对应，配套的求最小值及最小值下标的函数整理如下，其调用方式及参数与最大值时是相同的：
np.min(xy_ary) # 计算整个数组最小值
np.min(xy_ary, axis = 1) # 以轴1分别计算最小值
np.argmin(xy_ary) # 数组转为1维后，最小值的下标
np.argmin(xy_ary, axis = 1) # 以轴1分别计算最小值的下标
np.nanmin(xy_ary_nan, axis = 1) # 以轴1分别计算最小值，忽略缺失值
np.nanargmin(xy_ary_nan, axis = 1) # 以轴1分别计算最小值下标，忽略缺失值
输出结果如下：
0.578
[99.97 0.578]
6
[3 1]
[99.97 0.59]
[3 4]
（2）查找满足特定条件的元素：np.where()
它接收的是一个表达式。我们曾经也学过基于布尔值的元素访问，下面用两个例子来比较np.where()函数和基于布尔数组的访问效果：
ind_100p = np.where(xy_ary > 100) # 找出所有为0的元素
xy_ary[ind_100p] # 访问满足条件的所有元素
xy_ary[xy_ary > 100] # 基于布尔值筛选的表达式
# 基于布尔值的访问
输出结果如下：
[ 100.45 100.02 100.05]
[ 100.45 100.02 100.05]
上面返回的结果相同。但相比基于布尔数组的访问，应用np.where()函数的一个好处是能够返回到数组的下标，因此可以根据一些具体的需求进行其他处理。
这里补充两个有两个判断元素不为0的函数，以及一个对不为0的函数的计数函数，它可以看成np.where()和np.sum()函数的一个综合运用：
np.nonzero(xy_ary_0) # 即np.where(xy_ary_0 != 0)
np.flatnonzero(xy_ary_0) # 即np.where(xy_ary_0.flatten() != 0)
np.count_nonzero(xy_ary_0, axis = 1) # 即np.sum(xy_ary_0 != 0, axis = 1)
各自的运算结果如下：
(array([0, 0, 0, 0, 1, 1, 1], dtype=int64), array([0, 1, 3, 4, 0, 2, 4], dtype=int64))
[0 1 3 4 5 7 9]
[4 3]
（3）查找不重复的元素 ：np.unique()
查找部分还有一项重要功能，即查找所有不重复的元素。我们此前学习过利用内置的方法set，将数据做成集合来实现查找不重复值的目的，但那种方法对于大数据集运算时间较长。对于numpy数组，我们用np.unique()方法；而对于Series或DataFrame，我们用其成员方法的.unique()。它们都支持对去重，但效果因为numpy和pandas本身的限制略有不同：
a = np.array([1, 2, 'alpha', 'alpha', 2])
s = pd.Series([1, 2, 'alpha', 'alpha', 2])
np.unique(a)
s.unique()
运算结果如下：
['1' '2' 'alpha'] # numpy数组所有元素都是同一类型，因此数字会转成字符串
[1 2 'alpha'] # Series则没有这一限制，这里它的数据类型为Object
这种查找所有不重复项的功能，可以和《Python学习笔记（8-2）：数据分析——数据预处理》中的pd.drop_duplicates去重函数进行比较。
对于缺乏Python基础的同仁，可以通过免费专栏《Python学习笔记（基础）》从零开始学习Python
结语
请始终相信“Done is better than perfect” ，不要过分追求完美，即刻行动就是最好的开始， 一个模块一个模块地积累和练习，必将有所收获。
还有其他的问题欢迎在评论区留言！
[版权申明] 非商业目的注明出处可自由转载，转载请标明出处！！！
博客：butterfly_701c