Python中的Numpy库中的创建数组

numpy：提供快速、高效的数值计算和数组操作，可以进行矩阵运算、统计计算、随机数生成等。

# 导包

import numpy as np

方法一：array()函数

用于创建数组。它可以将输入的序列（列表、元组等）转换为 NumPy 数组。

# 将列表转换为一维数组
arr1 = np.array([1, 2, 3])
print(arr1)

[1 2 3]

# 将嵌套的列表转换为二维数组
arr2 = np.array([[1, 2,3, 4], [5,6,7,8]])
print(arr2)

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

方法二：arange()函数

用于创建等差数组的函数。它的语法如下：

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

• start：起始值（包含在数组中）。
• stop：终止值（不包含在数组中）。
• step：两个相邻元素之间的步长，即增量。默认值为 1。
• dtype：返回数组的数据类型。如果未提供，则会根据输入参数推断出合适的数据类型。

arr3 = np.arange(2,10,0.5)
print(arr3)

[2.  2.5 3.  3.5 4.  4.5 5.  5.5 6.  6.5 7.  7.5 8.  8.5 9.  9.5]

方法三：linspace() 函数

用于创建等间隔数组的函数。它的语法如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

• start：起始值。
• stop：终止值。
• num：要生成的等分点个数。默认值为 50。
• endpoint：如果为 True，则在数组中包含终止值 stop；如果为 False，则不包含终止值 stop。默认为 True。
• retstep：如果为 True，则返回值中包含定义的等间隔。默认为 False。
• dtype：返回数组的数据类型。如果未提供，则会根据输入参数推断出合适的数据类型。

arr4=np.linspace(-10,10,50)
arr4

array([-10.        ,  -9.59183673,  -9.18367347,  -8.7755102 ,
        -8.36734694,  -7.95918367,  -7.55102041,  -7.14285714,
        -6.73469388,  -6.32653061,  -5.91836735,  -5.51020408,
        -5.10204082,  -4.69387755,  -4.28571429,  -3.87755102,
        -3.46938776,  -3.06122449,  -2.65306122,  -2.24489796,
        -1.83673469,  -1.42857143,  -1.02040816,  -0.6122449 ,
        -0.20408163,   0.20408163,   0.6122449 ,   1.02040816,
         1.42857143,   1.83673469,   2.24489796,   2.65306122,
         3.06122449,   3.46938776,   3.87755102,   4.28571429,
         4.69387755,   5.10204082,   5.51020408,   5.91836735,
         6.32653061,   6.73469388,   7.14285714,   7.55102041,
         7.95918367,   8.36734694,   8.7755102 ,   9.18367347,
         9.59183673,  10.        ])

当然也可以这样表达

arr5 = np.linspace(3*10,4*10,50)
arr5

array([30.        , 30.20408163, 30.40816327, 30.6122449 , 30.81632653,
       31.02040816, 31.2244898 , 31.42857143, 31.63265306, 31.83673469,
       32.04081633, 32.24489796, 32.44897959, 32.65306122, 32.85714286,
       33.06122449, 33.26530612, 33.46938776, 33.67346939, 33.87755102,
       34.08163265, 34.28571429, 34.48979592, 34.69387755, 34.89795918,
       35.10204082, 35.30612245, 35.51020408, 35.71428571, 35.91836735,
       36.12244898, 36.32653061, 36.53061224, 36.73469388, 36.93877551,
       37.14285714, 37.34693878, 37.55102041, 37.75510204, 37.95918367,
       38.16326531, 38.36734694, 38.57142857, 38.7755102 , 38.97959184,
       39.18367347, 39.3877551 , 39.59183673, 39.79591837, 40.        ])

方法四：fromstring()函数

用于从字符串中解析数据并创建数组的函数。

语法如下：

np.fromstring(string, dtype=float, count=-1, sep='')

• string 是要解析的字符串。
• dtype 是要指定的数据类型，默认为 float。可以根据需要使用 NumPy 中支持的任何数据类型。
• count 是要解析的元素个数，默认为 -1（解析整个字符串）。
• sep 是用于分隔元素的字符串，默认为空字符串。

s = "1 2 3 4 5"

arr6 = np.fromstring(s, dtype=int, sep=" ")

print(arr6)

[1 2 3 4 5]

方法五：numpy.fromregex() 函数

用于从字符串中通过正则表达式模式解析数据，并将匹配的结果存储在数组中。
语法如下：

np.fromregex(file, regexp, dtype, encoding=None)

• file 是包含要解析的数据的文件名或文件对象。
• regexp 是用于匹配数据的正则表达式模式。
• dtype 是结果数组的数据类型。
• encoding 是文件的编码类型，用于读取文件（仅适用于文件名的情况）。

file = "data.txt"

pattern = r"\d+"

arr7 = np.fromregex(file, pattern, dtype=int)

print(arr7) # 输出：[1 2 3 4 5]

方法六:random()随机生成数组

np.random.random（第一个维度，第二个维度，....，第N个维度）

arr8=np.random.random((4,3))
arr8

array([[0.17554718, 0.64905413, 0.68791596],
       [0.20084343, 0.83677715, 0.86927928],
       [0.68760523, 0.60506459, 0.60496762],
       [0.12632738, 0.07280087, 0.34293735]])

array9=np.random.random((2,2,2,4,3))
array9

array([[[[[0.45664163, 0.95234811, 0.17061628],
          [0.57853453, 0.46691206, 0.20460998],
          [0.51213163, 0.81746363, 0.90542167],
          [0.33612475, 0.62992522, 0.63333755]],

         [[0.92844906, 0.3714141 , 0.54362568],
          [0.04758357, 0.84824477, 0.581455  ],
          [0.68711894, 0.21155428, 0.13025328],
          [0.97887995, 0.9954646 , 0.05161358]]],


        [[[0.83989648, 0.54547092, 0.68597446],
          [0.72758852, 0.5006877 , 0.08464366],
          [0.13596665, 0.4618085 , 0.17416592],
          [0.20949098, 0.44488433, 0.35802268]],

         [[0.12267464, 0.9197447 , 0.28437713],
          [0.07000297, 0.18755069, 0.83134594],
          [0.3678099 , 0.56839274, 0.41898489],
          [0.99331135, 0.52271127, 0.95732121]]]],



       [[[[0.6220117 , 0.58862238, 0.28806227],
          [0.68136494, 0.05556181, 0.30319163],
          [0.08280294, 0.08658508, 0.79951398],
          [0.32105972, 0.23324923, 0.74339933]],

         [[0.97529563, 0.61139475, 0.85581674],
          [0.00719896, 0.45658126, 0.70879461],
          [0.04215692, 0.89635489, 0.28024791],
          [0.29296942, 0.45297925, 0.23805959]]],


        [[[0.736719  , 0.08487675, 0.19498049],
          [0.58496082, 0.41728818, 0.84304876],
          [0.43165673, 0.671034  , 0.02028252],
          [0.11157652, 0.9565571 , 0.5422995 ]],

         [[0.69608238, 0.28270437, 0.10632713],
          [0.14204014, 0.51387207, 0.66809133],
          [0.64010019, 0.85383196, 0.30398406],
          [0.94389578, 0.56828273, 0.36738243]]]]])

方法七：identity()函数

创建一个对角矩阵，即主对角线上的元素为 1，其余元素为 0。

arr10 = np.identity(5)

print(arr10)

[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]

方法八：full()函数

创建一个指定形状和填充值的数组。

语法如下：

np.full((a,b,c....), 5)

abc为维度数，5为填充值

arr11= np.full((3,2, 2), 5)
print(arr11)

[[[5 5]
  [5 5]]

 [[5 5]
  [5 5]]

 [[5 5]
  [5 5]]]