五、numpy函数

1、字符串函数

是用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作基于python内置库中的标准字符串函数在字符数组类（numpy.char）中定义

add()

对两个数组的元素进行字符串连接

print(np.char.add(["花花世界"], ["菩萨金刚"]))

[‘花花世界菩萨金刚’]

multiply()

返回按元素多重连接后的字符串

print(np.char.multiply("心中悲喜你是否会窒息.", 2))

心中悲喜你是否会窒息.心中悲喜你是否会窒息.

center()

将字符串居中，并使用指定字符在左侧和右侧进行填充

print(np.char.center(["神之眼", "蒙德"], 8, fillchar="+"))

[‘++神之眼+++’ ‘+++蒙德+++’]

capitalize()

将字符串第一个字母转换为大写

print(np.char.capitalize(["there's a name in my dream!"]))

[“There’s a name in my dream!”]

title()

将字符串的每个单词的第一个字母转换为大写

print(np.char.title(["there's a name in my dream!"]))

[“There’S A Name In My Dream!”]

lower()

数组元素转换为小写

upper()

数组元素转换为大写

split()

指定分隔符对字符串进行分割，并返回数组列表

print(np.char.split(["There's a name in my dream!"], sep=" "))

[list([“There’s”, ‘a’, ‘name’, ‘in’, ‘my’, ‘dream!’])]

splitlines()

返回元素中的行列表，以换行符分割

print(np.char.splitlines(["There's a name\n in \nmy dream!"]))

[list([“There’s a name”, ’ in ', ‘my dream!’])]

strip()

移除元素开头或结尾处的特定字符

print(np.char.strip(["++花花世界+", "菩萨金刚+"], '+'))

[‘花花世界’ ‘菩萨金刚’]

join()

通过指定分隔符来连接数组中的元素

print(np.char.join(["_", ":"], ["花花世界", "菩萨金刚"]))

[‘花_花_世_界’ ‘菩:萨:金:刚’]

replace()

使用新字符串替换字符串中的所有子字符串

print(np.char.replace(["花花世界", "一花一世界，一念一菩提"], "花", "~"))

[‘~~世界’ ‘一~一世界，一念一菩提’]

encode()

编码，数组元素依次调用str.encode

decode()

解码，数组元素依次调用str.decode

x = np.char.encode(["花花世界", "一花一世界，一念一菩提"], "utf-8")
print(x)
print(np.char.decode(x, "utf-8"))

[b’\xe8\x8a\xb1\xe8\x8a\xb1\xe4\xb8\x96\xe7\x95\x8c’
b’\xe4\xb8\x80\xe8\x8a\xb1\xe4\xb8\x80\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x8c\xe4\xb8\x80\xe5\xbf\xb5\xe4\xb8\x80\xe8\x8f\xa9\xe6\x8f\x90’]
[‘花花世界’ ‘一花一世界，一念一菩提’]

2、数学函数

标准三角函数sin()\cos()\tan()

a = np.array([0, 30, 45, 60, 90])
print("正弦值：", np.sin(a * np.pi / 180))
print("余弦值：", np.cos(a * np.pi / 180))
print("正切值：", np.tan(a * np.pi / 180))

正弦值： [0. 0.5 0.70710678 0.8660254 1. ]
余弦值： [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
正切值： [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]

反三角函数arcsin()\arccos()\arctan()

a = np.array([0, 30, 45, 60, 90])
sin = np.sin(a*np.pi/180)
print(sin)
inv = np.arcsin(sin)
print(inv)
print("角度制单位：",np.degrees(inv))

[0. 0.5 0.70710678 0.8660254 1. ]
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制单位： [ 0. 30. 45. 60. 90.]

around()

原型：numpy.around(arr,decimals=0)

作用：返回指定数字的四舍五入值

参数	说明
arr	数组
decimals	舍入的小数位数。默认值为0.如果为负，整数将四舍五入到小数点左侧的位置

x = np.random.random(3)
x = np.append(x, 345.6666)
x = np.around(x, decimals=5)
print(x)
print(np.around(x))
print(np.around(x, decimals=1))
print(np.around(x, decimals=-1))-1))

[9.003700e-01 9.866100e-01 3.360900e-01 3.456666e+02]
[ 1. 1. 0. 346.]
[9.000e-01 1.000e+00 3.000e-01 3.457e+02]
[ 0. 0. 0. 350.]

floor()

作用：向下取整，返回不大于输入参数的最大整数。

ceil()

作用：向上取整，返回输入值的上限。

3、算术函数

add()\subtract()\multiply()\divide()

作用：加减乘除

reciprocal()

作用：返回参数逐元素的倒数

x = np.array([0.5, 0.25, 100])
print(np.reciprocal(x))   # [2.   4.   0.01]

当参数为0时，报错如下：

RuntimeWarning: divide by zero encountered in reciprocal
print(np.reciprocal(x))

故：使用方法是用除法实现

power()

作用：将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂

x = np.array([10, 10])
y = np.array([2, 3])
print(np.power(x, y))
print(np.power(2, 4))

[ 100 1000]
16

mod()\remainder()

作用：计算输入数组中相应元素的相除后的余数

x = np.array([10, 10])
y = np.array([2, 3])
print(np.mod(x, y))
print(np.remainder(x, y))

[0 1]
[0 1]

4、统计函数

amax()、amin()

作用：计算数组中的元素沿指定轴的最大值、最小值

x = np.random.randint(1, 11, 9).reshape((3, 3))
print(x)

print(np.amax(x, 0))  # 列
print(np.amax(x, 1))  # 行

[[ 9 9 1]
[ 7 10 5]
[ 2 4 1]]
[ 9 10 5]
[ 9 10 4]

ptp()

作用：计算数组中元素最大值与最小值的差（最大值-最小值）

x = np.random.randint(1, 11, 9).reshape((3, 3))
print(x)

print(np.ptp(x))
print(np.ptp(x, 0))
print(np.ptp(x, 1))

[[10 8 3]
[ 9 7 2]
[ 3 9 1]]
9
[7 2 2]
[7 7 8]

percentile()

原型：numpy.percentile(a,q,axis)

作用：百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。

参数	说明
a	输入数组
q	要计算的百分位数，在0~100之间
axis	沿着它计算百分位数的轴

首先明确百分位数：

第 p 个百分位数是这样一个值，它使得至少有 p% 的数据项小于或等于这个值，且至少有 (100-p)% 的数据项大于或等于这个值。

举个例子：高等院校的入学考试成绩经常以百分位数的形式报告。比如，假设某个考生在入学考试中的语文部分的原始分数为 54 分。相对于参加同一考试的其他学生来说，他的成绩如何并不容易知道。但是如果原始分数54分恰好对应的是第70百分位数，我们就能知道大约70%的学生的考分比他低，而约30%的学生考分比他高。

x = np.random.randint(1, 11, 9).reshape((3, 3))
print(x)
print(np.percentile(x, 50))   # x中的元素，50%大于等于8.0，50%小于8.0
print(np.percentile(x, 10, axis=0))

[[ 8 9 10]
[ 9 8 7]
[ 2 10 8]]
8.0
[3.2 8.2 7.2]

median()

作用：算数组中元素的中位数（中值）

x = np.random.randint(1, 11, 9).reshape((3, 3))
print(x)
print(np.median(x, axis=0))

[[10 5 10]
[ 8 5 4]
[ 2 9 4]]
[8. 5. 4.]

mean()

作用：返回数组中元素的算术平均值。如果提供了轴，则沿其计算

average()

作用：根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值，可以接受一个轴参数。如果没有指定轴，则数组会被展开

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

加权平均值=(66+103+3*4)/(6+3+4)

x = np.random.randint(1, 11, 9).reshape((3, 3))
wts = np.random.randint(1, 11, 9).reshape((3, 3))
print(x)
print(wts)
print(np.average(x, weights=wts, axis=0))

[[ 5 6 10]
[ 3 10 9]
[ 1 3 5]]
[[ 8 6 6]
[ 9 3 1]
[10 4 3]]
[2.85185185 6. 8.4 ]

标准差

标准差是一组数据平均值分散程度的一种度量

标准差是方差的算术平方根

公式：std=sqrt(mean((x - x.mean())^2))

x = np.random.randint(1, 11, 5)
print(x)
print(np.std(x)) # std()函数

[9 9 2 5 9]
2.85657137141714

方差

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。

换句话说，标准差是方差的平方根。

x = np.random.randint(1, 11, 5)
print(x)
print(np.std(x))
print(np.var(x))

[4 3 2 8 8]
2.5298221281347035
6.4

5、排序函数

种类	速度	最坏情况	工作空间	稳定性
‘quicksort’(快速排序)	1	O（n^2）	0	否
‘mergesort’(归并排序)	2	O（n*log(n)）	~n/2	是
‘heapsort’(堆排序)	3	O（n*log(n)）	0	否

sort()

原型：sort(a,axis,kind,order)

功能：返回输入数组的排序副本

参数	说明
a	要排序的数组
axis	沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序，axis=0按列排序，axis=1按行排序
kind	排序算法，默认为‘quicksort’
order	如果数组包含字段，则是要排序的字段

x = np.random.randint(1, 11, 12).reshape((3, 4))
print(x)
print(np.sort(x))
print(np.sort(x, axis=0))

dt = np.dtype([("name", "S10"), ("age", int)])
data = np.array([("wht", 26), ("zhangheng", 26), ("dx", 14), ("wy", 18), ("zm", 22)], dtype=dt)
print(data)
print(np.sort(data, order="age"))  # 当排序时，如果age相同时，则按照其他列排序0))

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

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

[[ 2 2 4 3]
[ 3 3 6 8]
[ 7 3 9 10]]
[(b’wht’, 26) (b’zhangheng’, 26) (b’dx’, 14) (b’wy’, 18) (b’zm’, 22)]
[(b’dx’, 14) (b’wy’, 18) (b’zm’, 22) (b’wht’, 26) (b’zhangheng’, 26)]

argsort()

作用：对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。

这个索引数组用于构造排序后的数组。

x = np.random.randint(1, 100, 3)
print(x)
a = np.argsort(x)
# print(x)
print(a)
for i in a:
    print(x[i], end=" ")

[51 71 39]
[2 0 1]
39 51 71

lexsort()

作用：使用键序列执行间接排序，键可以看做是电子表格中的一列。该函数返回一个索引数组，使用它可以获得排序数据。

这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。

msort()

作用：数组按第一个轴排序，返回排序后的数组副本。

说明：np.msort(a)相当于np.sort(a,axis=0)

sort_complex(a)

作用：对复数按照先实部后虚部的顺序进行排序

partition(a,kth[,axis,kind,order])

作用：指定一个数，对数组进行分区

注意：kth为下标

x = np.random.randint(1, 10, 5)
print(x)
print(np.partition(x, 2))

[1 8 3 7 1]
[1 1 3 7 8]

argpartition(a,kth[,axis,kind,order])

作用：可以通过关键字kind指定算法沿着指定轴对数组进行分区

x = np.random.randint(1, 100, 5)
print(x)
print(np.argpartition(x, 2))  # 返回排序的下标
print(x[np.argpartition(x, -2)[-2]])  # 第2大的值
print(x[np.argpartition(x, 2)[2]])  # 第3小的值

[32 91 91 36 92]
[0 3 2 1 4]
91
91

6、搜索函数

max()、min()

作用：沿给定轴返回最大和最小值

argmax()、argmin()

作用：沿给定轴返回最大和最小元素的索引

nonzero()

作用：返回输入数组中非零元素的索引

x = np.random.randint(0, 10, 12).reshape((3, 4))
print(x)
print(np.nonzero(x))
r, l = np.nonzero(x)
print(r)
print(l)
sum = 0
for i in r:
    print(x[i][l[sum]], end=" ")
    sum += 1

[[3 5 2 8]
[2 0 3 9]
[8 8 2 2]]
(array([0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 2, 3, 0, 1, 2, 3], dtype=int64))
[0 0 0 0 1 1 1 2 2 2 2]
[0 1 2 3 0 2 3 0 1 2 3]
3 5 2 8 2 3 9 8 8 2 2

where()

作用：返回输入数组中满足给定条件的元素的索引

x = np.random.randint(0, 100, 9).reshape((3, 3))
print(x)
print(np.where(x > 30))
r, l = np.where(x > 30)
sum = 0
for i in r:
    print(x[i][l[sum]], end=" ")
    sum += 1

[[ 7 35 56]
[65 8 24]
[86 56 0]]
(array([0, 0, 1, 2, 2], dtype=int64), array([1, 2, 0, 0, 1], dtype=int64))
35 56 65 86 56

extract()

作用：根据某个条件从数组中抽取元素，返回满足条件的元素

x = np.random.randint(0, 100, 9).reshape((3, 3))
# 定义条件，对3整除
condition = np.mod(x, 3) == 0
print(x)
print(np.extract(condition=condition, arr=x))  # 返回元素
print(np.where(np.mod(x, 3) == 0))  # 返回索引

[[52 68 15]
[38 57 65]
[17 32 35]]
[15 57]
(array([0, 1], dtype=int64), array([2, 1], dtype=int64))

------ 以上内容均为学习笔记仅供参考，如有不准确或错误内容，望您批评指教。