numpy--ndarray的创建、数据类型及矢量计算_初始ndarray 创建行向量-CSDN博客

本文链接：https://blog.csdn.net/m0_58830154/article/details/125628471

NumPy的核心特征之一就是N维数组对象——ndarray。ndarray是一个快速、灵活的大型数据集的容器，可以允许我们使用类似标量的操作语法对大型数据集进行快速的计算。

ndarray的创建

通过array函数创建ndarray

array函数接受一切序列型的对象（也包括其他数组），然后产生一个新的含有传入数据的NumPy数组。以一个列表的转换为例：

In [7]: data1 = [6, 7.5, 8, 0, 1]

In [8]: arr1 = np.array(data1)
In [9]: arr1
Out[9]: array([6. , 7.5, 8. , 0. , 1. ]) 
# 传入列表，生成一维数组

传入嵌套序列（如由一组等长列表组成的列表），将会生成一个多维数组：

In [10]: data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]

In [11]: arr2 = np.array(data2)
In [12]: arr2
Out[12]:
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])
# 传入嵌套列表，生成一个二维数组

生成的数组都会有ndim和shape属性，表示生成数组的维度和形状。

In [13]: arr2.ndim
Out[13]: 2

In [14]: arr2.shape
Out[14]: (2, 4)

通过zeros函数创建全0数组

向zeros函数传入一个表示形状的整数或元组，就可以创建一个指定形状的全0数组。

In [16]: np.zeros(8) # 传入一个整数，生成一维数组
Out[16]: array([0., 0., 0., 0., 0., 0., 0., 0.])

In [17]: np.zeros((3, 4)) # 传入元组(3, 4)，生成一个3*4的二维数组
Out[17]:
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

In [18]: np.zeros((2, 3, 4)) #传入元组(2, 3, 4),生成2*3*4的三维数组
Out[18]:
array([[[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]],

       [[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]]])

通过ones函数创建全1数组

ones函数的用法与zeros类似，只不过是生成指定形状的全1数组。

通过empty函数创建空数组

empty函数的用法与zeros类似，返回一个指定形状的没有任何具体数值的数组。

In [19]: np.empty((2, 4))
Out[19]:
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.]])
# 认为np.empty会返回全0数组的想法是不安全的，很多情况下，会返回内存中的一些垃圾值。

创建数组的其他函数

下表列出了一些其他的数组创建函数。由于NumPy关注的是数值计算，因此没有特别说明数据类型都是float64。

函数	说明
array	将输入数据（列表、元组、数组或者其他序列）转换为ndarray。要么推断出dtype，要么指定dtype
asarray	将输入转换为ndarray，如果输入的本身就是一个ndarray就不进行转换
arange	类似于Python内置的range，但返回的是一个ndarray
ones, ones_like	ones以整数或者元组为对象，根据指定形状创建一个全1数组；ones_like以另一个数组为参数，根据其形状创建一个全1数组
zeros, zeros_like	类似于ones和ones_like，只不过生成的是全0数组
empty, empty_like	创建新数组，只分配内存空间但不填充具体值
eye, identity	创建一个N*N的单位矩阵
full, full_like	见下文

np.full基础语法：

 np.full(shape, fill_value, dtype=None, order='C')

函数返回一个给定形状和dtype的数组，用fill_value填充
参数：fill_value为标量或者类似数组

In [23]: np.full((2, 3), 3) # fill_value = 3
Out[23]:
array([[3, 3, 3],
       [3, 3, 3]])

In [24]: np.full((2, 3), np.nan) #fill_value = np.nan
Out[24]:
array([[nan, nan, nan],
       [nan, nan, nan]])

np.full_like的基础语法

numpy.full_like(a, fill_value, dtype=None)

full_like函数返回与指定数组具有相同形状和数据类型的数组
参数：a为数组，其形状和数据类型决定了新生成数组的形状和数据类型

In [26]: arr2
Out[26]:
array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

In [27]: np.full_like(arr2, 10)
Out[27]:
array([[10, 10, 10, 10],
       [10, 10, 10, 10]])

ndarray的数据类型

dtype是一个特殊的对象，它含有ndarray数据类型的信息：

In [28]: arr1 = np.array([1, 2, 3], dtype=np.float64)

In [29]: arr2 = np.array([1, 2, 3], dtype=np.int32)

In [30]: arr1.dtype
Out[30]: dtype('float64')

In [31]: arr2.dtype
Out[31]: dtype('int32')

通过astype方法转换数据类型

通过ndarray的astype方法可以转换数据类型：

In [32]: arr = np.array([1, 2, 3, 4, 5])

In [33]: arr.dtype
Out[33]: dtype('int32')

In [34]: float_arr = arr.astype(np.float64)

In [35]: float_arr.dtype
Out[35]: dtype('float64')

在上面的例子中，将整数转换成了浮点数。如果将浮点数转换为整数，则小数部分就会被舍弃：

In [36]: arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])

In [37]: arr.astype(np.int32)
Out[37]: array([ 3, -1, -2,  0, 12, 10])

数值型的字符串，也可以使用astype将其转换为数值：

In [38]: numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)

In [39]: numeric_strings.astype(float)
Out[39]: array([ 1.25, -9.6 , 42.  ])

astype(array.dtype)：按指定数组的类型进行转换

通过向astype传递一个数组的dtype属性，可以按照数组的数据类型转换其他序列：

In [40]: int_array = np.arange(10)

In [41]: cailbers = np.array([0.22, 0.27, 0.357, 0.38, 0.44, 0.50])

In [43]: int_array.astype(cailbers.dtype)
Out[43]: array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])

ndarray的数学运算

数组使我们不编写循环也可以对数据执行批量运算，NumPy用户将其称为矢量化。大小相等的数组之间的任何算数运算都会运用到元素级：

In [44]: arr = np.array([[1., 2., 3.], [4., 5., 6.]])

In [45]: arr
Out[45]:
array([[1., 2., 3.],
       [4., 5., 6.]])

In [46]: arr * arr
Out[46]:
array([[ 1.,  4.,  9.],
       [16., 25., 36.]])

数组与标量的运算会将标量与数组的每个元素进行运算：

In [47]: 1/arr
Out[47]:
array([[1.        , 0.5       , 0.33333333],
       [0.25      , 0.2       , 0.16666667]])

In [48]: arr ** 0.5
Out[48]:
array([[1.        , 1.41421356, 1.73205081],
       [2.        , 2.23606798, 2.44948974]])

大小相同的数组之间的比较会生成布尔值数组：

In [49]: arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])

In [50]: arr2
Out[50]:
array([[ 0.,  4.,  1.],
       [ 7.,  2., 12.]])

In [51]: arr2 > arr
Out[51]:
array([[False,  True, False],
       [ True, False,  True]])