Numpy 数组创建

数组创建

创建数组有 6 种通用机制：

• 从其他 Python 结构（即列表和元组）转换

• 内在的 NumPy 数组创建函数（例如 arange、1、0 等）

• 复制、加入或改变现有数组

• 从磁盘读取数组，无论是标准格式还是自定义格式

• 通过使用字符串或缓冲区从原始字节创建数组

• 特殊库函数的使用（例如，随机）

您可以使用这些方法来创建 ndarrays 或Structured arrays。

将 Python 序列转换为 NumPy 数组

可以使用 Python 序列（例如列表和元组）定义 NumPy 数组。列表和元组分别使用[…]和定义(…)。列表和元组可以定义 ndarray 创建：

• 一个数字列表将创建一个一维数组，

• 列表列表将创建一个二维数组，

• 进一步的嵌套列表将创建更高维的数组。通常，任何数组对象在 NumPy 中都称为ndarray。

>>> a1D = np.array([1, 2, 3, 4])
>>> a2D = np.array([[1, 2], [3, 4]])
>>> a3D = np.array([[[1, 2], [3, 4]],
                    [[5, 6], [7, 8]]])

使用numpy.array定义新数组时，应考虑数组中元素的dtype，可以明确指定。此功能使您可以更好地控制底层数据结构以及如何在 C/C++ 函数中处理元素。如果您不小心dtype 分配，您可能会遇到不必要的溢出，因此

>>> a = np.array([127, 128, 129], dtype=np.int8)
>>> a
array([ 127, -128, -127], dtype=int8)

一个 8 位有符号整数表示从 -128 到 127 的整数。将int8数组分配给此范围之外的整数会导致溢出。此功能经常会被误解。如果您使用 mismatching 执行计算dtypes，您可能会得到不需要的结果，例如：

>>> a = array([2, 3, 4], dtype = np.uint32)
>>> b = array([5, 6, 7], dtype = np.uint32)
>>> c_unsigned32 = a - b
>>> print('unsigned c:', c_unsigned32, c_unsigned32.dtype)
unsigned c: [4294967293 4294967293 4294967293] uint32
>>> c_signed32 = a - b.astype(np.int32)
>>> print('signed c:', c_signed32, c_signed32.dtype)
signed c: [-3 -3 -3] int64

请注意，当您对两个相同dtype: 的数组执行操作时 uint32，结果数组的类型相同。当您使用不同的 执行操作时dtype，NumPy 将分配一个新类型，该类型满足计算中涉及的所有数组元素，这里uint32并且int32都可以表示为int64。

默认的 NumPy 行为是分别以 64 位有符号整数或双精度浮点数int64和 来创建数组float。如果您希望数组是某种类型，那么您需要指定dtype创建数组的时间。

内在的 NumPy 数组创建函数

NumPy 有超过 40 个用于创建数组的内置函数，如数组创建例程中所述。这些函数可以根据它们创建的数组的维度大致分为三类：

• 一维数组

• 二维数组

• 数组

一维数组创建函数

# 一维数组创建函数例如numpy.linspace和numpy.arange通常需要至少两个输入，start和stop。
>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2, 10, dtype=float)
array([ 2., 3., 4., 5., 6., 7., 8., 9.])
>>> np.arange(2, 3, 0.1)
array([ 2. , 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9])

>>> np.linspace(1., 4., 6)
array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

二维数组创建函数
二维数组创建函数例如numpy.eye、numpy.diag和numpy.vander 定义表示为二维数组的特殊矩阵的属性。

np.eye(n, m)定义一个二维单位矩阵。i=j（行索引和列索引相等）的元素为 1，其余为 0，如下所示：

>>> np.eye(3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> np.eye(3, 5)
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.]])

numpy.diag可以定义一个具有沿对角线给定值的方形二维数组：

>>> np.diag([1, 2, 3])
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag([1, 2, 3], 1)
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])
>>> a = np.array([[1, 2], [3, 4]])
>>> np.diag(a)
array([1, 4])

一般 ndarray 创建函数

ndarray 创建函数，例如numpy.ones, numpy.zeros，并random根据所需的形状定义数组。

>>> np.zeros((2, 3))
array([[0., 0., 0.],
       [0., 0., 0.]])
>>> np.zeros((2, 3, 2))
array([[[0., 0.],
        [0., 0.],
        [0., 0.]],

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

numpy.ones将创建一个填充有 1 个值的数组。

>>> np.ones((2, 3))
array([[ 1., 1., 1.],
       [ 1., 1., 1.]])
>>> np.ones((2, 3, 2))
array([[[1., 1.],
        [1., 1.],
        [1., 1.]],

       [[1., 1.],
        [1., 1.],
        [1., 1.]]])

numpy.random 创建各种数组

import numpy as np
np.random.rand(2,4)#[0,1)之间的浮点数

array([[0.67977477, 0.5149095 , 0.10177092, 0.91938221],
       [0.95192014, 0.87443815, 0.34748479, 0.45779791]])

#指定数学期望和方差的正态分布
# np.random.randn()
arr=2.5 * np.random.randn(2,4)+3  #2.5是标准差，3是期望
arr

array([[ 1.91951089,  4.94412015,  4.47746282,  8.64489976],
       [-1.66824526,  1.49159955,  5.86474873,  0.18926745]])

# numpy.random.random()方法返回随机生成的一个实数（浮点数），它在[0,1)范围内。
np.random.random((2,4))

array([[0.64301086, 0.64041592, 0.34696627, 0.80146329],
       [0.15012755, 0.65225712, 0.55239764, 0.33422284]])

#np.randint(low, high=None, size=None, dtype='l') 生成整数
#产生[0,10)之间的随机整数8个，以数组的形式返回

temp3=np.random.randint(10,size=8)
temp3

array([2, 9, 8, 9, 6, 6, 3, 3])

复制、加入或改变现有数组

创建阵列后，您可以复制、连接或改变这些现有阵列以创建新阵列。当您将一个数组或其元素分配给一个新变量时，您必须显式指定numpy.copy该数组，否则该变量是原始数组的视图。

>>> a = np.array([1, 2, 3, 4, 5, 6])
>>> b = a[:2]
>>> b += 1
>>> print('a =', a, '; b =', b)
a = [2 3 3 4 5 6]; b = [2 3]

在此示例中，您没有创建新数组。您创建了一个变量， b用于查看a. 当您将 1 添加到 时，b您将通过将 1 添加到 得到相同的结果a[:2]。如果要创建 新数组，请使用numpy.copy数组创建例程，如下所示：

>>> a = np.array([1, 2, 3, 4])
>>> b = a[:2].copy()
>>> b += 1
>>> print('a = ', a, 'b = ', b)
a =  [1 2 3 4 5 6] b =  [2 3]

有许多程序加入现有阵列例如numpy.vstack， numpy.hstack和numpy.block。以下是使用以下命令将四个 2×2 数组连接为 4×4 数组的示例block：

>>> A = np.ones((2, 2))
>>> B = np.eye((2, 2))
>>> C = np.zeros((2, 2))
>>> D = np.diag((-3, -4))
>>> np.block([[A, B],
              [C, D]])
array([[ 1.,  1.,  1.,  0. ],
       [ 1.,  1.,  0.,  1. ],
       [ 0.,  0., -3.,  0. ],
       [ 0.,  0.,  0., -4. ]])

txt,csv读取数组

>>> np.loadtxt('simple.csv', delimiter = ',', skiprows = 1) 
array([[0., 0.],
       [1., 1.],
       [2., 4.],
       [3., 9.]])