当前位置：极客教程 > Numpy > Numpy 问答 > NumPy中创建空数组并追加元素的全面指南

NumPy中创建空数组并追加元素的全面指南

NumPy中创建空数组并追加元素的全面指南

参考：numpy empty array append

NumPy是Python中用于科学计算的核心库，它提供了高性能的多维数组对象和用于处理这些数组的工具。在NumPy中，创建空数组并向其追加元素是常见的操作。本文将详细介绍如何使用NumPy创建空数组，以及如何向这些数组追加元素。我们将探讨不同的方法、最佳实践和常见陷阱，以帮助您更有效地使用NumPy进行数据处理和分析。

1. 创建空数组

在NumPy中，有多种方法可以创建空数组。我们将探讨最常用的几种方法。

1.1 使用np.empty()

np.empty()函数是创建空数组最直接的方法之一。它创建一个指定形状和类型的新数组，但不初始化数组元素。

import numpy as np

# 创建一个一维空数组
empty_1d = np.empty(5)
print("1D empty array from numpyarray.com:", empty_1d)

# 创建一个二维空数组
empty_2d = np.empty((3, 4))
print("2D empty array from numpyarray.com:", empty_2d)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们首先创建了一个长度为5的一维空数组，然后创建了一个3行4列的二维空数组。需要注意的是，np.empty()创建的数组可能包含随机值，因为它只是分配内存而不初始化。

1.2 使用np.zeros()

如果您想创建一个所有元素都为零的数组，可以使用np.zeros()函数。

import numpy as np

# 创建一个一维零数组
zeros_1d = np.zeros(5)
print("1D zeros array from numpyarray.com:", zeros_1d)

# 创建一个二维零数组
zeros_2d = np.zeros((3, 4))
print("2D zeros array from numpyarray.com:", zeros_2d)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子创建了一个长度为5的一维零数组和一个3行4列的二维零数组。所有元素的初始值都是0。

1.3 使用np.ones()

类似地，如果您想创建一个所有元素都为1的数组，可以使用np.ones()函数。

import numpy as np

# 创建一个一维全1数组
ones_1d = np.ones(5)
print("1D ones array from numpyarray.com:", ones_1d)

# 创建一个二维全1数组
ones_2d = np.ones((3, 4))
print("2D ones array from numpyarray.com:", ones_2d)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子创建了一个长度为5的一维全1数组和一个3行4列的二维全1数组。所有元素的初始值都是1。

1.4 使用np.full()

如果您想创建一个所有元素都为特定值的数组，可以使用np.full()函数。

import numpy as np

# 创建一个一维数组，所有元素都是3.14
full_1d = np.full(5, 3.14)
print("1D full array from numpyarray.com:", full_1d)

# 创建一个二维数组，所有元素都是'numpyarray.com'
full_2d = np.full((3, 4), 'numpyarray.com')
print("2D full array from numpyarray.com:", full_2d)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们首先创建了一个长度为5的一维数组，所有元素都是3.14。然后创建了一个3行4列的二维数组，所有元素都是字符串’numpyarray.com’。

2. 向数组追加元素

创建空数组后，我们经常需要向其追加元素。NumPy提供了几种方法来实现这一点。

2.1 使用np.append()

np.append()函数是向NumPy数组追加元素最常用的方法之一。

import numpy as np

# 创建一个初始数组
initial_array = np.array([1, 2, 3])

# 追加单个元素
appended_array = np.append(initial_array, 4)
print("Array after appending single element from numpyarray.com:", appended_array)

# 追加多个元素
appended_array = np.append(initial_array, [4, 5, 6])
print("Array after appending multiple elements from numpyarray.com:", appended_array)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们首先创建了一个初始数组[1, 2, 3]。然后我们使用np.append()函数向这个数组追加了一个单独的元素4，接着又追加了多个元素[4, 5, 6]。

2.2 使用np.concatenate()

np.concatenate()函数可以用来连接两个或多个数组。

import numpy as np

# 创建两个初始数组
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

# 连接两个数组
concatenated_array = np.concatenate((array1, array2))
print("Concatenated array from numpyarray.com:", concatenated_array)

# 连接多个数组
array3 = np.array([7, 8, 9])
multi_concatenated_array = np.concatenate((array1, array2, array3))
print("Multi-concatenated array from numpyarray.com:", multi_concatenated_array)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子展示了如何使用np.concatenate()函数连接两个或多个数组。首先，我们连接了array1和array2，然后我们连接了array1、array2和array3。

2.3 使用np.hstack()和np.vstack()

np.hstack()和np.vstack()函数分别用于水平和垂直堆叠数组。

import numpy as np

# 创建两个初始数组
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

# 水平堆叠
hstacked_array = np.hstack((array1, array2))
print("Horizontally stacked array from numpyarray.com:", hstacked_array)

# 垂直堆叠
vstacked_array = np.vstack((array1, array2))
print("Vertically stacked array from numpyarray.com:", vstacked_array)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们首先使用np.hstack()函数水平堆叠了两个数组，然后使用np.vstack()函数垂直堆叠了相同的两个数组。

3. 高效追加元素的技巧

虽然np.append()和其他函数提供了简单的方法来追加元素，但在处理大量数据时，这些方法可能不是最高效的。以下是一些提高效率的技巧。

3.1 预分配内存

当您知道最终数组的大小时，预先分配内存可以显著提高性能。

import numpy as np

# 预分配内存
n = 1000
array = np.empty(n)

# 填充数组
for i in range(n):
    array[i] = i

print("Array created with pre-allocated memory from numpyarray.com:", array[:10])  # 只打印前10个元素
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们预先创建了一个大小为1000的空数组，然后在循环中填充它。这比反复调用np.append()要快得多。

3.2 使用列表然后转换为NumPy数组

对于动态增长的数据，先使用Python列表，然后在最后转换为NumPy数组可能更高效。

import numpy as np

# 使用列表动态增长
data_list = []
for i in range(1000):
    data_list.append(i)

# 转换为NumPy数组
array = np.array(data_list)

print("Array created from list from numpyarray.com:", array[:10])  # 只打印前10个元素
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个方法利用了Python列表的动态特性，然后一次性转换为NumPy数组，通常比反复调用np.append()更快。

3.3 使用np.resize()

np.resize()函数可以用来改变数组的大小，这在某些情况下可能比np.append()更高效。

import numpy as np

# 创建初始数组
array = np.array([1, 2, 3])

# 使用np.resize()增加数组大小
resized_array = np.resize(array, 6)
resized_array[3:] = [4, 5, 6]

print("Resized array from numpyarray.com:", resized_array)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们首先创建了一个包含3个元素的数组，然后使用np.resize()将其大小增加到6，最后填充新的元素。

4. 处理多维数组

到目前为止，我们主要讨论了一维数组。但NumPy的强大之处在于它能够轻松处理多维数组。

4.1 向多维数组追加行或列

对于多维数组，我们可以使用np.vstack()或np.hstack()来追加行或列。

import numpy as np

# 创建一个2x3的数组
array_2d = np.array([[1, 2, 3], [4, 5, 6]])

# 追加一行
new_row = np.array([[7, 8, 9]])
array_with_new_row = np.vstack((array_2d, new_row))
print("Array with new row from numpyarray.com:\n", array_with_new_row)

# 追加一列
new_column = np.array([[10], [11], [12]])
array_with_new_column = np.hstack((array_with_new_row, new_column))
print("Array with new column from numpyarray.com:\n", array_with_new_column)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子展示了如何向2D数组追加一行和一列。我们首先使用np.vstack()追加了一行，然后使用np.hstack()追加了一列。

4.2 使用np.insert()

np.insert()函数允许我们在指定位置插入新的行或列。

import numpy as np

# 创建一个2x3的数组
array_2d = np.array([[1, 2, 3], [4, 5, 6]])

# 在第二行之前插入一行
new_row = np.array([7, 8, 9])
array_with_inserted_row = np.insert(array_2d, 1, new_row, axis=0)
print("Array with inserted row from numpyarray.com:\n", array_with_inserted_row)

# 在第二列之前插入一列
new_column = np.array([10, 11, 12])
array_with_inserted_column = np.insert(array_with_inserted_row, 1, new_column, axis=1)
print("Array with inserted column from numpyarray.com:\n", array_with_inserted_column)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们首先在第二行之前插入了一行，然后在第二列之前插入了一列。axis=0表示操作行，axis=1表示操作列。

5. 处理结构化数组

NumPy的结构化数组允许我们在单个数组中存储不同类型的数据。这在处理复杂数据结构时非常有用。

5.1 创建结构化数组

import numpy as np

# 定义结构化数组的数据类型
dt = np.dtype([('name', 'U20'), ('age', 'i4'), ('city', 'U20')])

# 创建一个空的结构化数组
structured_array = np.array([], dtype=dt)

print("Empty structured array from numpyarray.com:", structured_array)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们定义了一个包含’name’、’age’和’city’字段的结构化数组类型，然后创建了一个空的结构化数组。

5.2 向结构化数组追加元素

import numpy as np

# 定义结构化数组的数据类型
dt = np.dtype([('name', 'U20'), ('age', 'i4'), ('city', 'U20')])

# 创建一个空的结构化数组
structured_array = np.array([], dtype=dt)

# 追加元素
new_element = np.array([('Alice', 30, 'New York')], dtype=dt)
structured_array = np.append(structured_array, new_element)

print("Structured array after appending from numpyarray.com:", structured_array)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子展示了如何向结构化数组追加元素。我们创建了一个新的元素，然后使用np.append()函数将其追加到数组中。

6. 性能考虑

在处理大型数组时，性能是一个重要的考虑因素。以下是一些提高性能的建议：

6.1 避免频繁调用np.append()

频繁调用np.append()可能会导致性能问题，因为每次调用都会创建一个新的数组。

import numpy as np
import time

# 使用np.append()
start_time = time.time()
array = np.array([])
for i in range(10000):
    array = np.append(array, i)
end_time = time.time()
print(f"Time taken withnp.append() from numpyarray.com: {end_time - start_time} seconds")

# 预分配内存
start_time = time.time()
array = np.empty(10000)
for i in range(10000):
    array[i] = i
end_time = time.time()
print(f"Time taken with pre-allocation from numpyarray.com: {end_time - start_time} seconds")
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子比较了使用np.append()和预分配内存两种方法的性能差异。通常，预分配内存的方法会快得多。

6.2 使用向量化操作

NumPy的强大之处在于其向量化操作。尽可能使用向量化操作而不是循环可以显著提高性能。

import numpy as np
import time

# 使用循环
start_time = time.time()
array = np.empty(1000000)
for i in range(1000000):
    array[i] = i ** 2
end_time = time.time()
print(f"Time taken with loop from numpyarray.com: {end_time - start_time} seconds")

# 使用向量化操作
start_time = time.time()
array = np.arange(1000000) ** 2
end_time = time.time()
print(f"Time taken with vectorization from numpyarray.com: {end_time - start_time} seconds")
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子比较了使用循环和向量化操作计算平方的性能差异。向量化操作通常会快得多。

7. 处理大型数据集

当处理大型数据集时，内存管理变得尤为重要。以下是一些处理大型数据集的技巧：

7.1 使用内存映射

对于非常大的数据集，可以使用内存映射文件来避免将整个数据集加载到内存中。

import numpy as np

# 创建一个大型数组并保存到文件
large_array = np.arange(1000000)
np.save('large_array.npy', large_array)

# 使用内存映射加载数组
mmap_array = np.load('large_array.npy', mmap_mode='r')

print("First 10 elements of memory-mapped array from numpyarray.com:", mmap_array[:10])
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们首先创建了一个大型数组并将其保存到文件中。然后，我们使用内存映射模式加载这个数组，这样可以在不将整个数组加载到内存的情况下访问数组的元素。

7.2 使用生成器

对于超大型数据集，可以使用生成器来逐块处理数据。

import numpy as np

def data_generator(chunk_size=1000):
    for i in range(0, 1000000, chunk_size):
        yield np.arange(i, min(i + chunk_size, 1000000))

# 使用生成器处理数据
for chunk in data_generator():
    # 处理每个数据块
    processed_chunk = chunk ** 2
    # 这里可以进行进一步的操作，比如保存处理后的数据

print("Data processing with generator from numpyarray.com completed")
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子展示了如何使用生成器来逐块处理大型数据集。这种方法可以有效地控制内存使用，适用于处理超出可用内存大小的数据集。

8. 高级技巧和注意事项

在使用NumPy处理数组时，还有一些高级技巧和注意事项值得关注：

8.1 使用np.r_和np.c_

np.r_和np.c_是用于快速构建和组合数组的便捷工具。

import numpy as np

# 使用np.r_构建数组
array_r = np.r_[1:4, 0, 4, [5, 6, 7]]
print("Array constructed with np.r_ from numpyarray.com:", array_r)

# 使用np.c_构建数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
array_c = np.c_[a, b]
print("Array constructed with np.c_ from numpyarray.com:\n", array_c)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

这个例子展示了如何使用np.r_和np.c_快速构建和组合数组。np.r_用于行方向的组合，而np.c_用于列方向的组合。

8.2 处理不同数据类型

当追加不同数据类型的元素时，NumPy会尝试找到一个能够容纳所有元素的通用数据类型。

import numpy as np

# 创建一个整数数组
int_array = np.array([1, 2, 3])

# 追加浮点数
mixed_array = np.append(int_array, 4.5)
print("Mixed array from numpyarray.com:", mixed_array)
print("Data type of mixed array:", mixed_array.dtype)
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，当我们向整数数组追加一个浮点数时，整个数组会被转换为浮点类型。

8.3 使用masked arrays

masked arrays允许我们在数组中标记某些值为无效或缺失。

import numpy as np

# 创建一个masked array
data = np.array([1, 2, -999, 4, 5])
masked_array = np.ma.masked_array(data, mask=[0, 0, 1, 0, 0])

print("Masked array from numpyarray.com:", masked_array)
print("Mean of masked array:", masked_array.mean())
Python

Output:

NumPy中创建空数组并追加元素的全面指南

在这个例子中，我们创建了一个masked array，其中值-999被标记为无效。当我们计算平均值时，这个无效值会被忽略。

9. 总结

NumPy提供了丰富的工具和方法来创建空数组并追加元素。从简单的np.empty()和np.append()到更高级的技巧如预分配内存和使用结构化数组，我们可以根据具体需求选择最合适的方法。

在处理大型数据集时，性能和内存管理变得尤为重要。使用向量化操作、内存映射和生成器等技术可以帮助我们更有效地处理数据。

最后，理解NumPy的数据类型系统和高级特性如masked arrays可以帮助我们更灵活地处理各种数据分析场景。

通过掌握这些技巧和方法，我们可以更有效地利用NumPy进行数据处理和科学计算，从而在数据分析和机器学习等领域取得更好的成果。

记住，选择正确的方法取决于具体的使用场景、数据大小和性能要求。在实际应用中，可能需要尝试不同的方法并进行性能测试，以找到最适合您特定需求的解决方案。

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

NumPy 精品教程

登录

找回密码？

注册