numpy位运算#

位运算是一种在二进制数字的位级别上进行操作的一类运算，它们直接操作二进制数字的各个位，而不考虑数字的整体值。

位运算在计算机科学中广泛应用于优化和处理底层数据。

NumPy “bitwise_” 开头的函数是位运算函数。

NumPy 位运算包括以下几个函数：

1
import numpy as np
2

3
arr1 = np.array([True, False, True], dtype=bool)
4
arr2 = np.array([False, True, False], dtype=bool)
5

6
result_and = np.bitwise_and(arr1, arr2)
7
result_or = np.bitwise_or(arr1, arr2)
8
result_xor = np.bitwise_xor(arr1, arr2)
9
result_not = np.bitwise_not(arr1)
10

11
print("AND:", result_and)  # [False, False, False]
12
print("OR:", result_or)    # [True, True, True]
13
print("XOR:", result_xor)  # [True, True, True]
14
print("NOT:", result_not)  # [False, True, False]
15

16
# 按位取反
17
arr_invert = np.invert(np.array([1, 2], dtype=np.int8))
18
print("Invert:", arr_invert)  # [-2, -3]
19

20
# 左移位运算
21
arr_left_shift = np.left_shift(5, 2)
22
print("Left Shift:", arr_left_shift)  # 20
23

24
# 右移位运算
25
arr_right_shift = np.right_shift(10, 1)
26
print("Right Shift:", arr_right_shift)  # 5

字符串函数#

以下函数用于对 dtype 为 numpy.string_或 numpy.unicode_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。

这些函数在字符数组类（numpy.char）中定义。

• numpy.char.add()/multiply()/center()

numpy.char.add() 函数依次对两个数组的元素进行字符串连接。

1
import numpy as np
2

3
print ('连接两个字符串：')
4
print (np.char.add(['hello'],[' xyz']))
5
print ('\\n')
6

7
print ('连接示例：')
8
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))
9

10
print (np.char.multiply('Runoob ',3))
11

12
# np.char.center(str , width,fillchar) ：
13
# str: 字符串，width: 长度，fillchar: 填充字符
14
print (np.char.center('Runoob', 20,fillchar = '*'))

• numpy.char.capitalize()/title()/lower()/upper()

1
import numpy as np
2

3
print (np.char.capitalize('runoob'))
4

5
print (np.char.capitalize('runoob'))
6

7
#操作数组
8
print (np.char.lower(['RUNOOB','GOOGLE']))
9

10
# 操作字符串
11
print (np.char.lower('RUNOOB'))

• numpy.char.split()/splitlines()/strip()

numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。

1
import numpy as np
2

3
# 分隔符默认为空格
4
print (np.char.split ('i like runoob?'))
5
# 分隔符为 .
6
print (np.char.split ('www.runoob.com', sep = '.'))
7

8
# 换行符 \\n
9
# \\n，\\r，\\r\\n 都可用作换行符。
10
print (np.char.splitlines('i\\nlike runoob?'))
11
print (np.char.splitlines('i\\rlike runoob?'))
12

13
# 移除字符串头尾的 a 字符
14
print (np.char.strip('ashok arunooba','a'))
15

16
# 移除数组元素头尾的 a 字符
17
print (np.char.strip(['arunooba','admin','java'],'a'))

• numpy.char.join()/replace()/encode()/decode()

numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串

1
import numpy as np
2

3
# 操作字符串
4
print (np.char.join(':','runoob'))
5

6
# 指定多个分隔符操作数组元素
7
print (np.char.join([':','-'],['runoob','google']))
8

9
print (np.char.replace ('i like runoob', 'oo', 'cc'))
10

11
a = np.char.encode('runoob', 'cp500')
12
print (a)
13

14
print (np.char.decode(a,'cp500'))

numpy数学函数#

1
import numpy as np
2

3
a = np.array([0,30,45,60,90])
4
print ('不同角度的正弦值：')
5
# 通过乘 pi/180 转化为弧度
6
print (np.sin(a*np.pi/180))
7
print ('\\n')
8
print ('数组中角度的余弦值：')
9
print (np.cos(a*np.pi/180))
10
print ('\\n')
11
print ('数组中角度的正切值：')
12
print (np.tan(a*np.pi/180))

1
import numpy as np
2

3
a = np.array([0,30,45,60,90])
4
print ('含有正弦值的数组：')
5
sin = np.sin(a*np.pi/180)
6
print (sin)
7
print ('\\n')
8
print ('计算角度的反正弦，返回值以弧度为单位：')
9
inv = np.arcsin(sin)
10
print (inv)
11
print ('\\n')
12
print ('通过转化为角度制来检查结果：')
13
print (np.degrees(inv))
14
print ('\\n')
15
print ('arccos 和 arctan 函数行为类似：')
16
cos = np.cos(a*np.pi/180)
17
print (cos)
18
print ('\\n')
19
print ('反余弦：')
20
inv = np.arccos(cos)
21
print (inv)
22
print ('\\n')
23
print ('角度制单位：')
24
print (np.degrees(inv))
25
print ('\\n')
26
print ('tan 函数：')
27
tan = np.tan(a*np.pi/180)
28
print (tan)
29
print ('\\n')
30
print ('反正切：')
31
inv = np.arctan(tan)
32
print (inv)
33
print ('\\n')
34
print ('角度制单位：')
35
print (np.degrees(inv))

算术函数#

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。

需要注意的是数组必须具有相同的形状或符合数组广播规则。

1
import numpy as np
2

3
a = np.arange(9, dtype = np.float_).reshape(3,3)
4
print ('第一个数组：')
5
print (a)
6
print ('\\n')
7
print ('第二个数组：')
8
b = np.array([10,10,10])
9
print (b)
10
print ('\\n')
11
print ('两个数组相加：')
12
print (np.add(a,b))
13
print ('\\n')
14
print ('两个数组相减：')
15
print (np.subtract(a,b))
16
print ('\\n')
17
print ('两个数组相乘：')
18
print (np.multiply(a,b))
19
print ('\\n')
20
print ('两个数组相除：')
21
print (np.divide(a,b))

• numpy.reciprocal()

  numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。

  1
  import numpy as np
  2
  
  3
  a = np.array([0.25,  1.33,  1,  100])
  4
  print ('我们的数组是：')
  5
  print (a)
  6
  print ('\\n')
  7
  print ('调用 reciprocal 函数：')
  8
  print (np.reciprocal(a))

• numpy.power()

  numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

  1
  import numpy as np
  2
  
  3
  a = np.array([10,100,1000])
  4
  print ('我们的数组是；')
  5
  print (a)
  6
  print ('\\n')
  7
  print ('调用 power 函数：')
  8
  print (np.power(a,2))
  9
  print ('\\n')
  10
  print ('第二个数组：')
  11
  b = np.array([1,2,3])
  12
  print (b)
  13
  print ('\\n')
  14
  print ('再次调用 power 函数：')
  15
  print (np.power(a,b))

• numpy.mod()

  numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

  1
  import numpy as np
  2
  
  3
  a = np.array([10,20,30])
  4
  b = np.array([3,5,7])
  5
  print ('第一个数组：')
  6
  print (a)
  7
  print ('\\n')
  8
  print ('第二个数组：')
  9
  print (b)
  10
  print ('\\n')
  11
  print ('调用 mod() 函数：')
  12
  print (np.mod(a,b))
  13
  print ('\\n')
  14
  print ('调用 remainder() 函数：')
  15
  print (np.remainder(a,b))

统计函数#

• numpy.amin() 和 numpy.amax()

  numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

  1
  numpy.amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
  2
  
  3
  # 参数说明：
  4
  #     a: 输入的数组，可以是一个NumPy数组或类似数组的对象。
  5
  #     axis: 可选参数，用于指定在哪个轴上计算最小值。如果不提供此参数，则返回整个数组的最小值。可以是一个整数表示轴的索引，也可以是一个元组表示多个轴。
  6
  #     out: 可选参数，用于指定结果的存储位置。
  7
  #     keepdims: 可选参数，如果为True，将保持结果数组的维度数目与输入数组相同。如果为False（默认值），则会去除计算后维度为1的轴。
  8
  #     initial: 可选参数，用于指定一个初始值，然后在数组的元素上计算最小值。
  9
  #     where: 可选参数，一个布尔数组，用于指定仅考虑满足条件的元素。

  numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

  1
  numpy.amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
  2
  
  3
  # 参数说明：
  4
  #     a: 输入的数组，可以是一个NumPy数组或类似数组的对象。
  5
  #     axis: 可选参数，用于指定在哪个轴上计算最大值。如果不提供此参数，则返回整个数组的最大值。可以是一个整数表示轴的索引，也可以是一个元组表示多个轴。
  6
  #     out: 可选参数，用于指定结果的存储位置。
  7
  #     keepdims: 可选参数，如果为True，将保持结果数组的维度数目与输入数组相同。如果为False（默认值），则会去除计算后维度为1的轴。
  8
  #     initial: 可选参数，用于指定一个初始值，然后在数组的元素上计算最大值。
  9
  #     where: 可选参数，一个布尔数组，用于指定仅考虑满足条件的元素。

  1
  import numpy as np
  2
  
  3
  a = np.array([[3,7,5],[8,4,3],[2,4,9]])
  4
  print ('我们的数组是：')
  5
  print (a)
  6
  print ('\\n')
  7
  print ('调用 amin() 函数：')
  8
  print (np.amin(a,1))
  9
  print ('\\n')
  10
  print ('再次调用 amin() 函数：')
  11
  print (np.amin(a,0))
  12
  print ('\\n')
  13
  print ('调用 amax() 函数：')
  14
  print (np.amax(a))
  15
  print ('\\n')
  16
  print ('再次调用 amax() 函数：')
  17
  print (np.amax(a, axis =  0))

• numpy.ptp()

  numpy.ptp() 函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

  1
  numpy.ptp(a,axis=None,out=None,keepdims=<no value>,initial=<no value>,where=<no value>)
  2
  
  3
  # 参数说明：
  4
  #     a: 输入的数组，可以是一个 NumPy 数组或类似数组的对象。
  5
  #     axis: 可选参数，用于指定在哪个轴上计算峰-峰值。如果不提供此参数，则返回整个数组的峰-峰值。可以是一个整数表示轴的索引，也可以是一个元组表示多个轴。
  6
  #     out: 可选参数，用于指定结果的存储位置。
  7
  #     keepdims: 可选参数，如果为 True，将保持结果数组的维度数目与输入数组相同。如果为 False（默认值），则会去除计算后维度为1的轴。
  8
  #     initial: 可选参数，用于指定一个初始值，然后在数组的元素上计算峰-峰值。
  9
  # where: 可选参数，一个布尔数组，用于指定仅考虑满足条件的元素。
  10
  
  11
  import numpy as np
  12
  
  13
  a = np.array([[3,7,5],[8,4,3],[2,4,9]])
  14
  print ('我们的数组是：')
  15
  print (a)
  16
  print ('\\n')
  17
  print ('调用 ptp() 函数：')
  18
  print (np.ptp(a))
  19
  print ('\\n')
  20
  print ('沿轴 1 调用 ptp() 函数：')
  21
  print (np.ptp(a, axis =  1))
  22
  print ('\\n')
  23
  print ('沿轴 0 调用 ptp() 函数：')
  24
  print (np.ptp(a, axis =  0))

• numpy.percentile()

  百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。

  首先明确百分位数：
  第 p 个百分位数是这样一个值，它使得至少有 p% 的数据项小于或等于这个值，且至少有 (100-p)% 的数据项大于或等于这个值。
  举个例子：高等院校的入学考试成绩经常以百分位数的形式报告。比如，假设某个考生在入学考试中的语文部分的原始分数为 54 分。相对于参加同一考试的其他学生来说，他的成绩如何并不容易知道。但是如果原始分数54分恰好对应的是第70百分位数，我们就能知道大约70%的学生的考分比他低，而约30%的学生考分比他高。
  这里的 p = 70。

  1
  numpy.percentile(a, q, axis)
  2
  
  3
  # 参数说明：
  4
  #     a: 输入数组
  5
  #     q: 要计算的百分位数，在 0 ~ 100 之间
  6
  #     axis: 沿着它计算百分位数的轴
  7
  
  8
  import numpy as np
  9
  
  10
  a = np.array([[10, 7, 4], [3, 2, 1]])
  11
  print ('我们的数组是：')
  12
  print (a)
  13
  
  14
  print ('调用 percentile() 函数：')
  15
  # 50% 的分位数，就是 a 里排序之后的中位数
  16
  print (np.percentile(a, 50))
  17
  
  18
  # axis 为 0，在纵列上求
  19
  print (np.percentile(a, 50, axis=0))
  20
  
  21
  # axis 为 1，在横行上求
  22
  print (np.percentile(a, 50, axis=1))
  23
  
  24
  # 保持维度不变
  25
  print (np.percentile(a, 50, axis=1, keepdims=True))

• numpy.median()

  numpy.median() 函数用于计算数组 a 中元素的中位数（中值）

  1
  numpy.median(a, axis=None, out=None, overwrite_input=False, keepdims=<no value>)
  2
  
  3
  # 参数说明：
  4
  #     a: 输入的数组，可以是一个 NumPy 数组或类似数组的对象。
  5
  #     axis: 可选参数，用于指定在哪个轴上计算中位数。如果不提供此参数，则计算整个数组的中位数。可以是一个整数表示轴的索引，也可以是一个元组表示多个轴。
  6
  #     out: 可选参数，用于指定结果的存储位置。
  7
  #     overwrite_input: 可选参数，如果为True，则允许在计算中使用输入数组的内存。这可能会在某些情况下提高性能，但可能会修改输入数组的内容。
  8
  #     keepdims: 可选参数，如果为True，将保持结果数组的维度数目与输入数组相同。如果为False（默认值），则会去除计算后维度为1的轴。
  9
  
  10
  import numpy as np
  11
  
  12
  a = np.array([[30,65,70],[80,95,10],[50,90,60]])
  13
  print ('我们的数组是：')
  14
  print (a)
  15
  print ('\\n')
  16
  print ('调用 median() 函数：')
  17
  print (np.median(a))
  18
  print ('\\n')
  19
  print ('沿轴 0 调用 median() 函数：')
  20
  print (np.median(a, axis =  0))
  21
  print ('\\n')
  22
  print ('沿轴 1 调用 median() 函数：')
  23
  print (np.median(a, axis =  1))

• numpy.mean()

  numpy.mean() 函数返回数组中元素的算术平均值，如果提供了轴，则沿其计算。

  算术平均值是沿轴的元素的总和除以元素的数量。

  1
  numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)
  2
  
  3
  # 参数说明：
  4
  
  5
  # a: 输入的数组，可以是一个 NumPy 数组或类似数组的对象。
  6
  # axis: 可选参数，用于指定在哪个轴上计算平均值。如果不提供此参数，则计算整个数组的平均值。可以是一个整数表示轴的索引，也可以是一个元组表示多个轴。
  7
  # dtype: 可选参数，用于指定输出的数据类型。如果不提供，则根据输入数据的类型选择合适的数据类型。
  8
  # out: 可选参数，用于指定结果的存储位置。
  9
  # keepdims: 可选参数，如果为True，将保持结果数组的维度数目与输入数组相同。如果为False（默认值），则会去除计算后维度为1的轴。

• numpy.average()

  numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

  该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

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

  1
  numpy.average(a, axis=None, weights=None, returned=False)
  2
  
  3
  # 参数说明：
  4
  # a: 输入的数组，可以是一个 NumPy 数组或类似数组的对象。
  5
  # axis: 可选参数，用于指定在哪个轴上计算加权平均值。如果不提供此参数，则计算整个数组的加权平均值。可以是一个整数表示轴的索引，也可以是一个元组表示多个轴。
  6
  # weights: 可选参数，用于指定对应数据点的权重。如果不提供权重数组，则默认为等权重。
  7
  # returned: 可选参数，如果为True，将同时返回加权平均值和权重总和。

• numpy.average()

  numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

  该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

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

  1
  numpy.average(a, axis=None, weights=None, returned=False)
  2
  
  3
  # 参数说明：
  4
  # a: 输入的数组，可以是一个 NumPy 数组或类似数组的对象。
  5
  # axis: 可选参数，用于指定在哪个轴上计算加权平均值。如果不提供此参数，则计算整个数组的加权平均值。可以是一个整数表示轴的索引，也可以是一个元组表示多个轴。
  6
  # weights: 可选参数，用于指定对应数据点的权重。如果不提供权重数组，则默认为等权重。
  7
  # returned: 可选参数，如果为True，将同时返回加权平均值和权重总和。
  8
  
  9
  import numpy as np
  10
  
  11
  a = np.array([1,2,3,4])
  12
  print ('我们的数组是：')
  13
  print (a)
  14
  print ('\\n')
  15
  print ('调用 average() 函数：')
  16
  print (np.average(a))
  17
  print ('\\n')
  18
  # 不指定权重时相当于 mean 函数
  19
  wts = np.array([4,3,2,1])
  20
  print ('再次调用 average() 函数：')
  21
  print (np.average(a,weights = wts))
  22
  print ('\\n')
  23
  # 如果 returned 参数设为 true，则返回权重的和
  24
  print ('权重的和：')
  25
  print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))
  26
  
  27
  # 在多维数组中，可以指定用于计算的轴。
  28
  a = np.arange(6).reshape(3,2)
  29
  print ('我们的数组是：')
  30
  print (a)
  31
  print ('\\n')
  32
  print ('修改后的数组：')
  33
  wt = np.array([3,5])
  34
  print (np.average(a, axis =  1, weights = wt))
  35
  print ('\\n')
  36
  print ('修改后的数组：')
  37
  print (np.average(a, axis =  1, weights = wt, returned =  True))

• 标准差

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

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

  标准差公式如下：

  std = sqrt(mean((x - x.mean())^2))

  1
  import numpy as np
  2
  
  3
  print (np.std([1,2,3,4]))

• 方差

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

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

  1
  import numpy as np
  2
  
  3
  print (np.var([1,2,3,4]))

NumPy 排序、条件筛选函数#

NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。

• numpy.sort()

  numpy.sort() 函数返回输入数组的排序副本。函数格式如下：

  1
  numpy.sort(a, axis, kind, order)
  2
  
  3
  # 参数说明：
  4
  #     a: 要排序的数组
  5
  #     axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
  6
  #     kind: 默认为'quicksort'（快速排序）
  7
  #     order: 如果数组包含字段，则是要排序的字段

• numpy.argsort()

  numpy.argsort() 函数返回的是数组值从小到大的索引值。

  1
  import numpy as np
  2
  
  3
  x = np.array([3,  1,  2])
  4
  print ('我们的数组是：')
  5
  print (x)
  6
  print ('\\n')
  7
  print ('对 x 调用 argsort() 函数：')
  8
  y = np.argsort(x)
  9
  print (y)
  10
  print ('\\n')
  11
  print ('以排序后的顺序重构原数组：')
  12
  print (x[y])

• numpy.lexsort()

  numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

  1
  import numpy as np
  2
  
  3
  nm =  ('raju','anil','ravi','amar')
  4
  dv =  ('f.y.',  's.y.',  's.y.',  'f.y.')
  5
  ind = np.lexsort((dv,nm))
  6
  print ('调用 lexsort() 函数：')
  7
  print (ind)
  8
  print ('\\n')
  9
  print ('使用这个索引来获取排序后的数据：')
  10
  print ([nm[i]  +  ", "  + dv[i]  for i in ind])

• msort、sort_complex、partition、argpartition

  函数	描述
  msort(a)	数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。
  sort_complex(a)	对复数按照先实部后虚部的顺序进行排序。
  partition(a, kth[, axis, kind, order])	指定一个数，对数组进行分区
  argpartition(a, kth[, axis, kind, order])	可以通过关键字 kind 指定算法沿着指定轴对数组进行分区

• numpy.argmax() 和 numpy.argmin()

  numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

• numpy.nonzero()

  numpy.nonzero() 函数返回输入数组中非零元素的索引。

• numpy.where()

  numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

• numpy.extract()

  numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

NumPy 字节交换#

在几乎所有的机器上，多字节对象都被存储为连续的字节序列。字节顺序，是跨越多字节的程序对象的存储规则。

• 大端模式：指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
• 小端模式：指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。

numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。

1
import numpy as np
2

3
A = np.array([1, 256, 8755], dtype=np.int16)
4
print(A)
5
print(list(map(hex, A)))
6
print(A.byteswap(inplace=True))
7
print(list(map(hex, A)))

无复制#

简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符，类似于 C 中的指针。

此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。

1
import numpy as np
2

3
a = np.arange(6)
4
print ('我们的数组是：')
5
print (a)
6
print ('调用 id() 函数：')
7
print (id(a))
8
print ('a 赋值给 b：')
9
b = a
10
print (b)
11
print ('b 拥有相同 id()：')
12
print (id(b))
13
print ('修改 b 的形状：')
14
b.shape =  3,2
15
print (b)
16
print ('a 的形状也修改了：')
17
print (a)

视图或浅拷贝#

ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数变化不会改变原始数据的维数。

1
import numpy as np
2

3
# 最开始 a 是个 3X2 的数组
4
a = np.arange(6).reshape(3,2)
5
print ('数组 a：')
6
print (a)
7
print ('创建 a 的视图：')
8
b = a.view()
9
print (b)
10
print ('两个数组的 id() 不同：')
11
print ('a 的 id()：')
12
print (id(a))
13
print ('b 的 id()：' )
14
print (id(b))
15
# 修改 b 的形状，并不会修改 a
16
b.shape =  2,3
17
print ('b 的形状：')
18
print (b)
19
print ('a 的形状：')
20
print (a)
21

22
# 使用切片创建视图修改数据会影响到原始数组：
23
arr = np.arange(12)
24
print ('我们的数组：')
25
print (arr)
26
print ('创建切片：')
27
a=arr[3:]
28
b=arr[3:]
29
a[1]=123
30
b[2]=234
31
print(arr)
32
print(id(a),id(b),id(arr[3:]))

副本或深拷贝#

ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。

1
import numpy as np
2

3
a = np.array([[10,10],  [2,3],  [4,5]])
4
print ('数组 a：')
5
print (a)
6
print ('创建 a 的深层副本：')
7
b = a.copy()
8
print ('数组 b：')
9
print (b)
10
# b 与 a 不共享任何内容
11
print ('我们能够写入 b 来写入 a 吗？')
12
print (b is a)
13
print ('修改 b 的内容：')
14
b[0,0]  =  100
15
print ('修改后的数组 b：')
16
print (b)
17
print ('a 保持不变：')
18
print (a)

转置矩阵#

NumPy 中除了可以使用 numpy.transpose 函数来对换数组的维度，还可以使用 T 属性。。

例如有个 m 行 n 列的矩阵，使用 t() 函数就能转换为 n 行 m 列的矩阵。

1
import numpy as np
2

3
a = np.arange(12).reshape(3,4)
4

5
print ('原数组：')
6
print (a)
7
print ('\\n')
8

9
print ('转置数组：')
10
print (a.T)

matlib.empty()#

matlib.empty() 函数返回一个新的矩阵，语法格式为：

1
numpy.matlib.empty(shape, dtype, order)
2

3
# 参数说明：
4
#     shape: 定义新矩阵形状的整数或整数元组
5
#     Dtype: 可选，数据类型
6
#     order: C（行序优先） 或者 F（列序优先）
7

8
import numpy.matlib
9
import numpy as np
10

11
print (np.matlib.empty((2,2)))
12
# 填充为随机数据

numpy.matlib.zeros()#

numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。

1
import numpy as np
2

3
print (np.matlib.zeros((2,2)))

numpy.matlib.ones()#

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。

1
import numpy.matlib
2
import numpy as np
3

4
print (np.matlib.ones((2,2)))

numpy.matlib.eye()#

numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。

1
numpy.matlib.eye(n, M,k, dtype)
2

3
# 参数说明：
4
#     n: 返回矩阵的行数
5
#     M: 返回矩阵的列数，默认为 n
6
#     k: 对角线的索引
7
#     dtype: 数据类型
8

9
import numpy.matlib
10
import numpy as np
11

12
print (np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float))

numpy.matlib.identity()#

numpy.matlib.identity() 函数返回给定大小的单位矩阵。

单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。

1
import numpy.matlib
2
import numpy as np
3

4
# 大小为 5，类型位浮点型
5
print (np.matlib.identity(5, dtype =  float))

numpy.matlib.rand()#

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。

1
import numpy.matlib
2
import numpy as np
3

4
print (np.matlib.rand(3,3))
5

6
# 矩阵总是二维的，而 ndarray 是一个 n 维数组。 两个对象都是可互换的。
7
import numpy.matlib
8
import numpy as np
9

10
i = np.matrix('1,2;3,4')
11
print (i)
12

13
j = np.asarray(i)
14
print (j)
15

16
k = np.asmatrix (j)
17
print (k)

中文使用#

Matplotlib 默认情况不支持中文，我们可以使用以下简单的方法来解决。

1. 下载 思源黑体
2. 把下载的OTF字体放到代码文件下即可
3. matplotlib.font_manager.FontProperties(fname="SourceHanSansSC-Bold.otf")fname指定字体库路径

1
import numpy as np
2
from matplotlib import pyplot as plt
3
import matplotlib
4

5
# fname 为 你下载的字体库路径，注意 SourceHanSansSC-Bold.otf 字体的路径
6
zhfont1 = matplotlib.font_manager.FontProperties(fname="SourceHanSansSC-Bold.otf")
7

8
x = np.arange(1,11)
9
y =  2  * x +  5
10
plt.title("菜鸟教程 - 测试", fontproperties=zhfont1)
11

12
# fontproperties 设置中文显示，fontsize 设置字体大小
13
plt.xlabel("x 轴", fontproperties=zhfont1)
14
plt.ylabel("y 轴", fontproperties=zhfont1)
15
plt.plot(x,y)
16
plt.show()

NumPy Bitwise Operations#

Bitwise operations are a class of operations that perform on binary numbers at the bit level, directly manipulating the individual bits of binary representations without regard to the overall value.

Bitwise operations are widely used in computer science for optimization and handling of low-level data.

NumPy “bitwise_” prefixed functions are bitwise operation functions.

NumPy bitwise operations include the following functions:

1
import numpy as np
2

3
arr1 = np.array([True, False, True], dtype=bool)
4
arr2 = np.array([False, True, False], dtype=bool)
5

6
result_and = np.bitwise_and(arr1, arr2)
7
result_or = np.bitwise_or(arr1, arr2)
8
result_xor = np.bitwise_xor(arr1, arr2)
9
result_not = np.bitwise_not(arr1)
10

11
print("AND:", result_and)  # [False, False, False]
12
print("OR:", result_or)    # [True, True, True]
13
print("XOR:", result_xor)  # [True, True, True]
14
print("NOT:", result_not)  # [False, True, False]
15

16
# Bitwise NOT
17
arr_invert = np.invert(np.array([1, 2], dtype=np.int8))
18
print("Invert:", arr_invert)  # [-2, -3]
19

20
# Left shift
21
arr_left_shift = np.left_shift(5, 2)
22
print("Left Shift:", arr_left_shift)  # 20
23

24
# Right shift
25
arr_right_shift = np.right_shift(10, 1)
26
print("Right Shift:", arr_right_shift)  # 5

String Functions#

The following functions operate on arrays with dtype numpy.string_ or numpy.unicode_ to perform vectorized string operations. They are based on the standard string functions in the Python standard library.

These functions are defined in the character array class (numpy.char).

• numpy.char.add()/multiply()/center()

The numpy.char.add() function concatenates the elements of two arrays element-wise.

1
import numpy as np
2

3
print ('Concatenating two strings:')
4
print (np.char.add(['hello'],[' xyz']))
5
print ('\\n')
6

7
print ('Concatenation examples:')
8
print (np.char.add(['hello', 'hi'],[' abc', ' xyz']))
9

10
print (np.char.multiply('Runoob ',3))
11

12
# np.char.center(str , width,fillchar) ：
13
# str: string, width: length, fillchar: fill character
14
print (np.char.center('Runoob', 20,fillchar = '*'))

• numpy.char.capitalize()/title()/lower()/upper()

1
import numpy as np
2

3
print (np.char.capitalize('runoob'))
4

5
print (np.char.capitalize('runoob'))
6

7
# operate on arrays
8
print (np.char.lower(['RUNOOB','GOOGLE']))
9

10
# operate on strings
11
print (np.char.lower('RUNOOB'))

• numpy.char.split()/splitlines()/strip()

numpy.char.split() splits strings by a specified separator and returns an array. By default, the separator is a space.

1
import numpy as np
2

3
# Separator defaults to space
4
print (np.char.split ('i like runoob?'))
5
# Separator is .
6
print (np.char.split ('www.runoob.com', sep = '.'))
7

8
# Newline characters \\n
9
# \\n, \\r, \\r\\n can all be used as line breaks.
10
print (np.char.splitlines('i\\nlike runoob?'))
11
print (np.char.splitlines('i\\rlike runoob?'))
12

13
# Remove the leading and trailing 'a' from the string
14
print (np.char.strip('ashok arunooba','a'))
15

16
# Remove the leading and trailing 'a' from array elements
17
print (np.char.strip(['arunooba','admin','java'],'a'))

• numpy.char.join()/replace()/encode()/decode()

numpy.char.join() function joins the elements of an array or strings using a specified separator.

1
import numpy as np
2

3
# operate on strings
4
print (np.char.join(':','runoob'))
5

6
# operate on multiple separators for array elements
7
print (np.char.join([':','-'],['runoob','google']))
8

9
print (np.char.replace ('i like runoob', 'oo', 'cc'))
10

11
a = np.char.encode('runoob', 'cp500')
12
print (a)
13

14
print (np.char.decode(a,'cp500'))

NumPy Mathematical Functions#

1
import numpy as np
2

3
a = np.array([0,30,45,60,90])
4
print ('Sine values for different angles:')
5
# Convert to radians by multiplying pi/180
6
print (np.sin(a*np.pi/180))
7
print ('\\n')
8
print ('Cosine values for angles in the array:')
9
print (np.cos(a*np.pi/180))
10
print ('\\n')
11
print ('Tangent values for angles in the array:')
12
print (np.tan(a*np.pi/180))

1
import numpy as np
2

3
a = np.array([0,30,45,60,90])
4
print ('Array with sine values:')
5
sin = np.sin(a*np.pi/180)
6
print (sin)
7
print ('\\n')
8
print ('Inverse sine of the angles, result in radians:')
9
inv = np.arcsin(sin)
10
print (inv)
11
print ('\\n')
12
print ('Check the result by converting back to degrees:')
13
print (np.degrees(inv))
14
print ('\\n')
15
print ('Inverse cosine and arctan behave similarly:')
16
cos = np.cos(a*np.pi/180)
17
print (cos)
18
print ('\\n')
19
print ('Arccosine:')
20
inv = np.arccos(cos)
21
print (inv)
22
print ('\\n')
23
print ('Angle in degrees:')
24
print (np.degrees(inv))
25
print ('\\n')
26
print ('Tangent:')
27
tan = np.tan(a*np.pi/180)
28
print (tan)
29
print ('\\n')
30
print ('Inverse tangent:')
31
inv = np.arctan(tan)
32
print (inv)
33
print ('\\n')
34
print ('Angle in degrees:')
35
print (np.degrees(inv))

Arithmetic Functions#

NumPy arithmetic functions include simple addition, subtraction, multiplication, and division: add(), subtract(), multiply() and divide().

Note that arrays must have the same shape or be broadcastable.

1
import numpy as np
2

3
a = np.arange(9, dtype = np.float_).reshape(3,3)
4
print ('First array:')
5
print (a)
6
print ('\\n')
7
print ('Second array:')
8
b = np.array([10,10,10])
9
print (b)
10
print ('\\n')
11
print ('Addition of the two arrays:')
12
print (np.add(a,b))
13
print ('\\n')
14
print ('Subtraction of the two arrays:')
15
print (np.subtract(a,b))
16
print ('\\n')
17
print ('Multiplication of the two arrays:')
18
print (np.multiply(a,b))
19
print ('\\n')
20
print ('Division of the two arrays:')
21
print (np.divide(a,b))

• numpy.reciprocal()

  numpy.reciprocal() returns the reciprocal of each element in the input array. For example, the reciprocal of 1/4 is 4/1.

  1
  import numpy as np
  2
  
  3
  a = np.array([0.25,  1.33,  1,  100])
  4
  print ('Our array:')
  5
  print (a)
  6
  print ('\\n')
  7
  print ('Calling reciprocal function:')
  8
  print (np.reciprocal(a))

• numpy.power()

  numpy.power() takes the elements in the first input array as bases and raises them to the powers of the corresponding elements in the second input array.

  1
  import numpy as np
  2
  
  3
  a = np.array([10,100,1000])
  4
  print ('Our array:')
  5
  print (a)
  6
  print ('\\n')
  7
  print ('Calling power function:')
  8
  print (np.power(a,2))
  9
  print ('\\n')
  10
  print ('Second array:')
  11
  b = np.array([1,2,3])
  12
  print (b)
  13
  print ('\\n')
  14
  print ('Calling power function again:')
  15
  print (np.power(a,b))

• numpy.mod()

  numpy.mod() computes the remainder after division for corresponding elements in the input arrays. The numpy.remainder() function produces the same result.

  1
  import numpy as np
  2
  
  3
  a = np.array([10,20,30])
  4
  b = np.array([3,5,7])
  5
  print ('First array:')
  6
  print (a)
  7
  print ('\\n')
  8
  print ('Second array:')
  9
  print (b)
  10
  print ('\\n')
  11
  print ('Calling mod() function:')
  12
  print (np.mod(a,b))
  13
  print ('\\n')
  14
  print ('Calling remainder() function:')
  15
  print (np.remainder(a,b))

Statistical Functions#

• numpy.amin() and numpy.amax()

  numpy.amin() is used to compute the minimum value of elements in an array along a specified axis.

  1
  numpy.amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
  2
  
  3
  # Parameter descriptions:
  4
  #     a: input array, can be a NumPy array or array-like object.
  5
  #     axis: optional parameter to specify along which axis to compute the minimum. If not provided, returns the minimum of the entire array. Can be an integer or a tuple of axes.
  6
  #     out: optional parameter for the output storage.
  7
  #     keepdims: optional parameter; if True, keeps the number of dimensions of the result the same as input. If False (default), reduces axes of length 1.
  8
  #     initial: optional parameter to specify an initial value for the minimum calculation.
  9
  #     where: optional boolean array to specify which elements to consider.

  numpy.amax() is used to compute the maximum value along a specified axis of the array.

  1
  numpy.amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
  2
  
  3
  # Parameter descriptions:
  4
  #     a: input array, can be a NumPy array or array-like object.
  5
  #     axis: optional parameter to specify along which axis to compute the maximum. If not provided, returns the maximum of the entire array. Can be an integer or a tuple of axes.
  6
  #     out: optional parameter for the output storage.
  7
  #     keepdims: optional parameter; if True, keeps the number of dimensions of the result the same as input. If False (default), reduces axes of length 1.
  8
  #     initial: optional parameter to specify an initial value for the maximum calculation.
  9
  #     where: optional boolean array to specify which elements to consider.

1
import numpy as np
2

3
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
4
print ('Our array is:')
5
print (a)
6
print ('\\n')
7
print ('Calling amin() function:')
8
print (np.amin(a,1))
9
print ('\\n')
10
print ('Calling amin() again:')
11
print (np.amin(a,0))
12
print ('\\n')
13
print ('Calling amax() function:')
14
print (np.amax(a))
15
print ('\\n')
16
print ('Calling amax() again:')
17
print (np.amax(a, axis =  0))