1. C 语言存储风格 : 行优先存储 (默认)
2. F (Fortran) 语言风格存储 : 列优先存储

arr_name.ndim : 维度信息

arr_name.shape : 形状信息

arr_name.dtype : 数据元素类型

arr_name.size : 总元素数

np.pi : 圆周率pi = 3.141592653589793

arr_name.itemsize : 数组中数据元素的字节数

arr_name.nbytes : 数组中的所有数据消耗掉的字节数。不计算数组的开销，因此数组占用的实际空间将稍微大一点。

实例

import numpy as np

arr1 = np.array([1, 2, 3], dtype=int)
print(arr1)  # [1. 2. 3.]
print(f"数组维度{arr1.ndim}")  # 数组维度1
print(arr1.shape)  # (3,)
print(arr1.dtype)  # int32
print(arr1.size)  # 3
print(arr1.itemsize)  # 4
print(arr1.nbytes)  # 12

数组的创建 : .array(p_object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

• 参数

  参数	描述
  p_object	数组，任何显示数组接口的对象，返回数组的方法或任何（嵌套）序列。
  dtype	数据类型,可选参数.数据所需的数据类型,如果未给定则为在序列中保存对象所需的最小类型
  copy	布尔参数,可选参数.如果为true（默认），则复制对象
  order	可选参数,值为 {'K', 'A', 'C', 'F'}。指定阵列的内存布局，  K : 默认,保存原 F 和 C 风格不变,否则自动选择 F 或 C 风格  A : 如果输入是F而不是C，则F风格不变，否则为C风格  C : C 语言存储风格  F : Fortran 语言风格存储

将多维数组展平为一维数组 : arr_name.flatten(order='C'), a.ravel([order])

• 区别

  • 按行展开数组的值时,修改 flatten() 不会影响原数组的值, 修改 ravel() 会修改原数组的值

    import numpy as np
    
    arr = np.arange(1, 17).reshape((4, 4))
    """
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]
     [13 14 15 16]]
    """
    
    arr_flatten = arr.flatten()  # [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
    arr_ravel = arr.ravel()  # [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
    
    arr_flatten[0] = 1000
    
    print(arr)
    """
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]
     [13 14 15 16]]
    """
    
    arr_ravel[0] = 1000
    
    print(arr)
    """
    [[1000    2    3    4]
     [   5    6    7    8]
     [   9   10   11   12]
     [  13   14   15   16]]
    """

  • 按列展开数组的值时,修改 flatten() 与 ravel() 都不会影响原数组的值

    import numpy as np
    
    arr = np.arange(1, 17).reshape((4, 4))
    """
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]
     [13 14 15 16]]
    """
    
    arr_flatten = arr.flatten(order='F')  # [ 1  5  9 13  2  6 10 14  3  7 11 15  4  8 12 16]
    arr_ravel = arr.ravel(order='F')  # [ 1  5  9 13  2  6 10 14  3  7 11 15  4  8 12 16]
    
    arr_flatten[0] = 1000
    print(arr)
    """
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]
     [13 14 15 16]]
    """
    arr_ravel[0] = 1000
    print(arr)
    """
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]
     [13 14 15 16]]
    """

生成一维数组,返回给定间隔内的等间距值 : .arange([start,] stop[, step,], dtype=None)

• 值是在半开区间[start，stop)内生成的

  参数	描述
  start	可选参数,默认为0,数值类型.间隔的开始。间隔包括此值。
  stop	数值类型,必选参数.间隔的结束,间隔不包括此值
  step	可选参数,数值类型.值之间的间距
  dtype	可选参数.输出数组的类型,如果不赋值,从其他输入参数推断数据类型。

a.reshape(shape, order='C') : 。将一维数组变成多维数组.返回包含具有新形状的相同数据的数组

• 常与 arange() 结合使用

• 生成一个固定类型的多维数组，使用前方给出参数填充数组

  import numpy as np
  print(np.arange(10).reshape(2, 5))
  """
  [[0 1 2 3 4]
   [5 6 7 8 9]]
  """

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0) : 在指定的间隔范围内返回均匀间隔的数字 (等差数组)。在**[start, stop)范围内计算，返回num**个(默认为50)均匀间隔的样本。一维数组

• 参数

  参数	描述
  start	返回序列的初始值
  stop	除非endpoint被设置为False，否则stop为序列的终点值。当endpoint=False，返回序列包含num+1个均匀间隔样本的最后一个样本以外的所有样本
  num	整型，可选参数.产生的样本总数。默认值为50。必须为非负值。
  endpoint	bool 类型,可选参数.若为True，则stop为最后一个样本。否则，返回序列不包含stop。默认值为True。
  retstep	bool 类型,可选参数.若为True，返回(samples, step)，step为样本间的步长。
  dtype	返回序列的数据类型。如果dtype未给定，那么从其他输入参数推断其类型。
  axis	整型,可选参数。结果中存储样本的轴

• 实例

  import numpy as np
  
  lin_num = np.linspace(10, 100, num=10)  # 10 ~ 100 (包括 100) 生成 10 个数
  print(lin_num)
  # [ 10.  20.  30.  40.  50.  60.  70.  80.  90. 100.]

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0) : 创建对数等差数列数组，底数为base (等比数组)。一维数组

• 参数

  参数	描述
  start	必选参数,区间起始值为base的start次方。
  stop	必选参数,区间终止值为base的stop次方（是否取得到，需要设定参数endpoint）。
  num	可选参数,等分的个数 (生成的数组内数据的个数)。按照对数，即start和stop值进行等分。默认值为50.
  endpoint	可选参数,若为True（默认），则可以取到区间终止值；否则取不到。
  base	公比
  dtype	可选参数,数据类型。若不指定数据类型，则通过其他参数判断
  axis	整型,可选参数。结果中存储样本的轴

• 实例

  import numpy as np
  
  log_num = np.logspace(2, 3, 10, base=2)  # 2^2 ~ 3^2 (不包括3^2) 之间 等比生成10个数
  print(log_num)  
  # [4.         4.32023896 4.66611616 5.0396842  5.44316    5.87893797    6.34960421 6.85795186 7.4069977  8.        ]

np.zeros(shape, dtype=None, order='C') : 全 0 数组,可以创建任意维度的数组,创建给定形状的ndarray，并将数组中所有元素填充为0

• 参数

  参数	描述
  shape	必选参数,维度,可以是任意纬度
  dtype	可选参数,数据类型。默认为np.float64
  order	可选参数, 数组按一定的顺序排列,默认为 C,{'C', 'F'}  C : 按行排列  F : 按列排列

• 实例

  import numpy as np
  
  zero_arr = np.zeros((3, 4), dtype=float)
  print(zero_arr)
  """
  [[0. 0. 0. 0.]
   [0. 0. 0. 0.]
   [0. 0. 0. 0.]]
  """

np.ones(shape, dtype=None, order='C') : 返回给定形状和类型的新数组，一个全1的n维数组.

• 参数

  参数	描述
  shape	必选参数,维度,可以是任意纬度
  dtype	可选参数,数据类型。默认为np.float64
  order	可选参数, 数组按一定的顺序排列,默认为 C,{'C', 'F'}  C : 按行排列  F : 按列排列

• 实例

  import numpy as np
  
  print(np.ones((2, 4)))
  """
  [[1. 1. 1. 1.]
   [1. 1. 1. 1.]]
  """

np.diag(v, k=0) : 类似于对角矩阵,既可以以一维数组的形式返回对角线元素，也可以将一维数组转换成方阵

• 参数

  参数	描述
  v	array_like.  如果v是二维数组，则返回其第k个对角线的副本。  如果v是一维数组，则返回一个二维数组，其中v在第k个对角线上
  k	整数,可选参数.对角线的位置，大于零位于对角线上面，小于零则在下面。

• 实例

  import numpy as np
  
  print(np.diag((1, 2, 3)))  # 返回一个 3x3 数组，对角线元素为 1, 2, 3
  """
  [[1 0 0]
   [0 2 0]
   [0 0 3]]
  """
  
  diag_arr = np.arange(9).reshape(3, 3)
  print(diag_arr)
  """
  [[0 1 2]
   [3 4 5]
   [6 7 8]]
  """
  
  print(np.diag(diag_arr))  # 返回 数组的对角线  [0 4 8]
  print(np.diag(diag_arr, k=1))  # [1 5]
  print(np.diag(diag_arr, k=-1))  # [3 7]

np.eye(N, M=None, k=0, dtype=float, order='C') : 返回一个二维数组，对角线上为 1，其他位置为零。

• 参数

  参数	描述
  N	整数，行数,输出中的行数
  M	整数，可选参数,输出中的列数。默认为 None。
  k	整数，可选参数,对角线索引：0（默认值）是指主要对角线，正值表示对角线的上边，负值表示到较低的对角线。  k为正整数，指从第k个值开始的右上对角线  k为负整数，指从第-k个值开始的左下对角线
  dtype	可选参数,数据类型。默认为浮点数
  order	可选参数, 数组按一定的顺序排列,默认为 C,{'C', 'F'}  C : 按行排列  F : 按列排列

• 实例

  import numpy as np
  
  print(np.eye(4))
  """
  [[1. 0. 0. 0.]
   [0. 1. 0. 0.]
   [0. 0. 1. 0.]
   [0. 0. 0. 1.]]
  """

np.random.random(size) : 生成0-1之间的随机浮点数，size可以为数组类型(2, 2)

• 固定随机数 (保证多次运行产生随机数不变) : np.random.seed(1) 生成的随机数叫做伪随机数

• 实例

  import numpy as np
  
  # np.random.seed(1)
  print(np.random.random(5))  # [0.19812881 0.22344332 0.00308559 0.5842389  0.67662501]
  print(np.random.random((2, 3)))
  """
  [[0.7775702  0.45005126 0.1029259 ]
   [0.77165046 0.28769795 0.72999339]]
  """

np.random.randn(d0, d1, ..., dn) : 从 标准正态分布 中返回一个或多个样本。

• 案例

  import numpy as np
  print(np.random.randn(2))  # [-0.61441249  0.44007701]

np.random.rand(d0, d1, ..., dn) : 产生 0-1 之间**均匀分布 (在一定范围内,一个新数据落在任何子区域的概率是一致的) **的随机数，可传入可变长数字

• 实例

  import numpy as np
  
  print(np.random.rand(5))  # [0.55158559 0.58835226 0.57084476 0.16372193 0.22398622]
  print(np.random.rand(2, 3))
  """
  [[0.9423069  0.03469337 0.48966077]
   [0.80035928 0.64656614 0.23262355]]
  """

np.random.stardard_normal(size=None) : 从标准正态分布（均值= 0，stdev = 1）中抽取样本。

• 参数 :

  • size : 整数或整数元组，可选输出形状。如果给定的形状是例如 （m，n，k），则绘制 m * n * k 个样本。默认为无，返回单个值。

• 与 np.random.randn 区别:

  • randn 返回shape为(d0, d1, ..., dn)的标准正态分布（均值为0，标准差为1）的数组
  • stardard_normal 它的shape由size参数指定，对于多维数组，size必须是元组形式

• 实例

  np.random.standard_normal((2, 3, 4))
  """
  array(
  [[[ 0.4114533 ,  0.11426395,  1.43661828, -0.27262121],
    [ 1.90990117,  0.15856119,  0.08476711,  2.59285364],
    [-0.86035996, -0.89235802, -1.13702572,  0.50942391]],
  
    [[-0.21854179, -0.25182636, -0.1003288 , -0.37723832],
    [-0.29564125,  0.31380058, -0.38441272, -0.51012865],
    [ 0.06783913, -0.16966757,  1.07430531, -1.21000938]]]
    )
  """

np.random.randint(low, high=None, size=None, dtype='l') : 从“低”（包含）到“高”（不含）返回随机整数。生成一个整数或N维整数数组，

• 取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。

• 参数

  参数	描述
  low	int 或 类似int的数组 从分布中得出的最低（带符号）整数（除非high = None，在这种情况下此参数比最高这样的整数）
  high	int 或 类似int的数组，可选如果提供，则在最大（有符号）整数上方绘制一个从分布中获取（如果high = None，请参见上面的行为）。如果为数组，则必须包含整数值
  size	整数或整数元组，可选输出形状。如果给定的形状是例如**(m，n，k)，则绘制m * n * k**个样本。默认为无，返回单个值。
  dtype	可选参数,数据类型,默认值为 np.int

np.random.uniform(low=0.0, high=1.0, size=None) : 指定范围 [low, high) 随机小数数组,均匀分布

• 参数

  参数	描述
  low	可选参数，float或者一组float的数组,默认是0
  high	必选参数,float或者一组float的数组，默认是1
  size	整数或整数元组，可选输出形状。如果给定的形状是例如**(m，n，k)，则绘制m * n * k**个样本。默认为无，返回单个值。

模块参数

• np.random.binomial(n, p, size=None) : 产生二项分布的随机数

  参数	描述
  n	int型或者一个int型的数组，大于等于0，接受浮点数但是会被变成整数来使用。(表示n次的试验)
  p	float或者一组float的数组，大于等于0且小于等于1.(表示的试验成功的概率)
  size	可选项，int或者int的元祖，表示的输出的大小，如果提供了size，例如(m,n,k)，那么会返回mnk个样本。如果size=None，也就是默认没有的情况，当n和p都是一个数字的时候只会返回一个值，否则返回的是np.broadcast(n,p).size个样本

• np.random.normal(loc=0.0, scale=1.0, size=None) : 产生正态 (高斯) 分布的随机数

  参数	描述
  loc	float,概率分布的均值，对应着整个分布的中心center
  scale	float,概率分布的标准差，对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高
  size	int型或者一个int型的数组,输出的shape，默认为None，只输出一个值

• np.random.beta(a, b, size=None) : 产生 beta 分布的随机数

  参数	描述
  a	float型或者一个float型的数组 α(阿尔法)形态分布,必须是非负的
  b	float型或者一个float型的数组
  size	int型或者一个int型的数组,输出的shape，默认为None，只输出一个值

• np.random.chisquare(df, size=None) : 产生 卡方分布 的随机数

  参数	描述
  df	float型或者一个float型的数组 自由度数,必需大于0
  size	int型或者一个int型的数组,输出的shape，默认为None，只输出一个值

• np.random.gamma(shape, scale=1.0, size=None) : 产生 gamma 分布 的随机数

  参数	描述
  shape	float型或者一个float型的数组 γ (伽马)分布的形状。必须是非负的。
  scale	float型或者一个float型的数组 γ (伽马)分布的尺度。必须是非负的。
  size	int型或者一个int型的数组,输出的shape，默认为None，只输出一个值

数组名[行信息, 列信息](多种方法可以交叉使用)

• 行信息: 下标、下标列表、布尔索引、切片
• 列信息: 下标、下标列表、布尔索引、切片

下标访问 : 返回的是降低一次维度之后的数

import numpy as np

np.random.seed(1)

arr = np.random.randint(1, 100, 8)
print(arr)  # [38 13 73 10 76  6 80 65]
print(arr[0])  # 38
print(arr[0:1])  # [38]

arr1 = np.random.randint(1, 100, (2, 3))
print(arr1)
"""
[[17  2 77]
 [72  7 26]]
"""
print(arr1[0])  # [17  2 77]
print(arr1[0:1])  # [[17  2 77]]

数组的切片 : 数组名[横轴起始: 横轴结束, 竖轴起始: 竖轴结束] 返回的是数组，不会降低维度

import numpy as np

arr = np.arange(20).reshape(4, 5)
print(arr)
"""
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
"""
print(arr[0, 1:5])  # 第 0 行 第 1-4 列的值 [1 2 3 4]
print(arr[1, 1:5])  # 第 1 行 第 1-4 列的值 [6 7 8 9]
print(arr[1:3, 0])  # 第 0 列 第 1-2 行的值 [ 5 10]

使用布尔数组的索引访问

• 一维数组

  np.random.seed(1)
  
  arr = np.random.randint(1, 100, 8)
  # print(arr)  # [38 13 73 10 76  6 80 65]
  arr_bool = arr % 2 != 0
  print(arr[arr_bool])  # [13 73 65]

• 多维数组

  arr1 = np.random.randint(1, 100, (2, 3))
  print(arr1[arr1 % 2 != 0])  # [ 7 99 37]
  arr2 = np.arange(16).reshape(4, 4)
  # 布尔索引
  arr2_bool = [True, False, False, True]
  print(arr2[:, arr2_bool])
  """
  [[ 0  3]
   [ 4  7]
   [ 8 11]
   [12 15]]
  """

数组运算符

• 方法

  运算符	描述
  + ==> np.add(x, y)	数组中数据逐位相加
  - ==> np.subtract(x, y)	数组中数据逐位相减
  * ==> np.multiply(x, y)	矩阵 A 的行的元素 乘以 矩阵 B 的对应列的元素 得到的值再相加
  / ==> np.divide(x, y)
  ** ==> np.sqrt(x)	平方根
  >	数组比较,返回布尔值
  <	数组比较,返回布尔值
  %	取余判断，返回布尔数组

数组特殊运算方法

• 方法

  方法	描述
  sum()	将所有元素相加
  min()	找出最小元素
  max()	找出最大元素
  cumsum()	逐位相加求和并放入新数组
  np.abs(x)、np.fabs(x)	计算数组各元素的绝对值
  np.square(x)	计算数组各元素的平方
  np.sqrt(x)	平方根
  np.log(x)、np.log10(x)、np.log2(x)	计算数组各元素的自然对数、10底对数和2底对数
  arr_name.T	转置 .T 将A的所有元素绕着一条从第1行第1列元素出发的右下方45度的射线作镜面反
  np.transpose()	颠倒 (调换数组的行列值的索引值，类似于求矩阵的转置)

• 实例

  import numpy as np
  
  arr = np.arange(20).reshape(4, 5)
  arr1 = np.arange(20, 40).reshape(4, 5)
  """
  arr : 
  [[ 0  1  2  3  4]
   [ 5  6  7  8  9]
   [10 11 12 13 14]
   [15 16 17 18 19]]
  arr1 :
  [[20 21 22 23 24]
   [25 26 27 28 29]
   [30 31 32 33 34]
   [35 36 37 38 39]]
  """
  print(sum(arr, arr1))
  """
  [[50 55 60 65 70]
   [55 60 65 70 75]
   [60 65 70 75 80]
   [65 70 75 80 85]]
  """
  print(f"arr最大值: {np.max(arr)}, arr1 最大值: {np.max(arr1)}")  # arr最大值: 19, arr1 最大值: 39
  print(f"arr最小值: {np.min(arr)}, arr1 最小值: {np.min(arr1)}")  # arr最小值: 0, arr1 最小值: 20
  print(f"arr逐位相加: {np.cumsum(arr)}") 
  """
  arr逐位相加: [  0   1   3   6  10  15  21  28  36  45  55  66  78  91 105 120 136 153 171 190]
  """
  print(f"arr1逐位相加: {np.cumsum(arr1)}")
  """
  arr1逐位相加: [ 20  41  63  86 110 135 161 188 216 245 275 306 338 371 405 440 476 513 551 590]
  """