numpy如何创建数组？多种方法详解

NumPy提供多种创建数组的方法：np.array()从列表转换数组，支持多维及类型自动转换；np.zeros()、np.ones()、np.full()分别创建全0、全1或指定值的数组；np.arange()按步长生成等差序列，np.linspace()按数量生成等间隔数；np.random.rand()、randint()、normal()生成不同分布的随机数组；可通过dtype参数指定数据类型以优化内存；reshape()可改变数组形状并支持-1自动推断维度；concatenate()、stack()、hstack()、vstack()实现沿轴或新维度的数组合并。

Numpy创建数组的方法很多，最常用的是np.array()，但还有其他更灵活高效的方式，比如np.zeros()、np.ones()、np.arange()等等。选择哪种方式取决于你的具体需求。

np.array()创建数组、np.zeros()、np.ones()、np.arange()、np.linspace()、np.random.rand()

如何使用np.array()从Python列表创建NumPy数组？

np.array()是最基础的创建数组的方法。它接受一个Python列表或元组作为输入，并尝试将其转换为NumPy数组。

import numpy as np

my_list = [1, 2, 3, 4, 5]
my_array = np.array(my_list)
print(my_array) # 输出: [1 2 3 4 5]
print(type(my_array)) # 输出: 

如果列表中的元素类型不一致，NumPy会尝试自动进行类型转换。比如，如果列表中同时包含整数和浮点数，那么所有元素都会被转换为浮点数。

mixed_list = [1, 2.5, 3]
mixed_array = np.array(mixed_list)
print(mixed_array) # 输出: [1.  2.5 3. ]
print(mixed_array.dtype) # 输出: float64

np.array()还可以创建多维数组：

matrix = [[1, 2, 3], [4, 5, 6]]
matrix_array = np.array(matrix)
print(matrix_array)
# 输出:
# [[1 2 3]
#  [4 5 6]]
print(matrix_array.shape) # 输出: (2, 3)

np.zeros()、np.ones()和np.full()有什么用途？

这三个函数用于创建特定形状且元素值相同的数组。np.zeros()创建全0数组，np.ones()创建全1数组，np.full()可以指定填充的值。

zeros_array = np.zeros((2, 3)) # 创建一个2x3的全0数组
print(zeros_array)
# 输出:
# [[0. 0. 0.]
#  [0. 0. 0.]]

ones_array = np.ones((3, 2)) # 创建一个3x2的全1数组
print(ones_array)
# 输出:
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]

full_array = np.full((2, 2), 7) # 创建一个2x2的数组，所有元素都是7
print(full_array)
# 输出:
# [[7 7]
#  [7 7]]

这些函数在初始化数组时非常有用，尤其是在进行数值计算时。例如，你可以用np.zeros()创建一个累加器，然后逐步更新它的值。

如何使用np.arange()和np.linspace()创建数值序列数组？

np.arange()类似于Python的range()函数，但它返回的是一个NumPy数组。它可以生成一个等差数列，你需要指定起始值、终止值和步长。

arange_array = np.arange(0, 10, 2) # 从0开始，到10（不包含），步长为2
print(arange_array) # 输出: [0 2 4 6 8]

np.linspace()则用于生成指定数量的等间隔数值。你需要指定起始值、终止值和元素数量。

linspace_array = np.linspace(0, 1, 5) # 从0到1（包含），生成5个等间隔的数
print(linspace_array) # 输出: [0.   0.25 0.5  0.75 1.  ]

np.arange()更适合需要精确控制步长的情况，而np.linspace()更适合需要精确控制元素数量的情况。np.linspace 默认包含终止值，可以通过 endpoint=False 来排除终止值，使其行为更像 arange。

如何创建随机数数组？

NumPy的np.random模块提供了多种生成随机数的函数。

random_array = np.random.rand(2, 3) # 生成一个2x3的数组，元素是0到1之间的随机数
print(random_array)
# 输出 (示例):
# [[0.123 0.456 0.789]
#  [0.987 0.654 0.321]]

randint_array = np.random.randint(0, 10, (3, 3)) # 生成一个3x3的数组，元素是0到9之间的随机整数
print(randint_array)
# 输出 (示例):
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

normal_array = np.random.normal(0, 1, (2, 2)) # 生成一个2x2的数组，元素服从均值为0，标准差为1的正态分布
print(normal_array)
# 输出 (示例):
# [[ 0.123 -0.456]
#  [-0.789  0.987]]

np.random.rand()生成均匀分布的随机数，np.random.randint()生成随机整数，np.random.normal()生成服从正态分布的随机数。 还有其他很多随机数生成函数，可以根据你的需求选择。

如何指定数组的数据类型？

NumPy数组的元素必须是相同类型的。NumPy会自动推断数据类型，但你也可以显式指定。

int_array = np.array([1, 2, 3], dtype=np.int32)
print(int_array.dtype) # 输出: int32

float_array = np.array([1, 2, 3], dtype=np.float64)
print(float_array.dtype) # 输出: float64

bool_array = np.array([0, 1, 0], dtype=bool)
print(bool_array) # 输出: [False  True False]

指定数据类型可以节省内存空间，提高计算效率。例如，如果你的数据都是整数，那么使用np.int8或np.int16可能比使用默认的np.int64更合适。

如何改变现有数组的形状？

可以使用np.reshape()函数改变数组的形状。

my_array = np.arange(12)
print(my_array) # 输出: [ 0  1  2  3  4  5  6  7  8  9 10 11]

reshaped_array = my_array.reshape((3, 4)) # 改变形状为3x4
print(reshaped_array)
# 输出:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

注意，np.reshape()不会改变原始数组，而是返回一个新的数组。 如果你希望直接修改原始数组，可以使用array.resize()方法。但resize()会直接修改数组本身，并且如果新的尺寸大于原始尺寸，会用0填充。 另外，reshape 操作需要保证新数组的元素个数和原数组一致，否则会报错。可以使用 -1 让 numpy 自动计算某个维度的大小。

my_array = np.arange(12)
reshaped_array = my_array.reshape((2, -1)) # numpy 自动计算列数
print(reshaped_array)
# 输出:
# [[ 0  1  2  3  4  5]
#  [ 6  7  8  9 10 11]]

如何合并多个数组？

可以使用np.concatenate()、np.stack()、np.hstack()和np.vstack()等函数合并数组。

np.concatenate()可以沿着指定的轴连接数组。

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

concatenated_array = np.concatenate((a, b), axis=0) # 沿着行（axis=0）连接
print(concatenated_array)
# 输出:
# [[1 2]
#  [3 4]
#  [5 6]]

c = np.array([[7, 8], [9, 10]])
concatenated_array = np.concatenate((a, c), axis=1) # 沿着列（axis=1）连接
print(concatenated_array)
# 输出:
# [[ 1  2  7  8]
#  [ 3  4  9 10]]

np.stack()沿着新的轴连接数组。

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

stacked_array = np.stack((a, b), axis=0) # 沿着新的行（axis=0）堆叠
print(stacked_array)
# 输出:
# [[1 2 3]
#  [4 5 6]]

stacked_array = np.stack((a, b), axis=1) # 沿着新的列（axis=1）堆叠
print(stacked_array)
# 输出:
# [[1 4]
#  [2 5]
#  [3 6]]

np.hstack()和np.vstack()是np.concatenate()的简化版本，分别用于水平和垂直方向的连接。

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

hstack_array = np.hstack((a, b)) # 水平方向连接
print(hstack_array) # 输出: [1 2 3 4 5 6]

vstack_array = np.vstack((a, b)) # 垂直方向连接
print(vstack_array)
# 输出:
# [[1 2 3]
#  [4 5 6]]

选择哪种合并方式取决于你希望如何组织数组。concatenate 最通用，stack 可以在新的维度上堆叠，而 hstack 和 vstack 则分别适用于水平和垂直拼接的场景。