官方 Python 文档包含有关 数组 的信息。但是，在 Python 中，通常用于表示数组的内置数据结构是 列表。官方文档主要关注列表，而不是单独的数组数据类型。列表是有序的、可变的，并且可以包含不同 数据类型 的元素。你可以使用其索引访问列表中的元素，并且可以对列表执行各种操作，例如追加、插入或删除元素。牢记这些事实，我们将从数组的角度来看列表。
Python 的数组
让我们看看 Python 中的数组是什么。数组是一种数据结构，用于存储同类型元素的集合。它是一个容器，包含固定数量的项，并且可以使用其索引访问这些元素。Python 提供了多种使用数组的方法，包括列表等内置数据结构和 NumPy 库的 ndarray。
有几种方法可以在 Python 中创建数组。正如我们已经提到的，列表通常在 Python 中用作数组。但是，如果你想提高性能并减少某些用例的内存消耗，则可以使用 Python 中的 array 模块。它提供了一种创建与传统列表相比更高效、更紧凑的数组的方法，它允许你定义特定数据类型的数组。
要使用 array 模块，首先需要导入它
import array
接下来，你可以通过指定所需的数据类型代码并使用值对其进行初始化来在 Python 中创建数组。以下是如何创建整数数组的示例
my_array = array.array('i', [1, 2, 3, 4, 5])
在上面的示例中，'i' 表示带符号整数的数据类型代码。你可以根据你的特定需求选择不同的数据类型代码（例如，'f' 表示浮点数，'d' 表示双精度浮点数，'b' 表示字节等）。
创建数组后，你可以使用索引访问其元素，就像使用常规列表一样。你还可以修改数组中的值或对数组执行各种可用操作。
注意：当你要处理大量数字数据或需要与以特定格式预期数据的低级库进行交互时，
array模块特别有用。对于异构元素的一般用途集合，内置列表类型通常更灵活，并且在 Python 中更常用。
Python 中的数组与列表
在 Python 中，“数组”和“列表”这两个术语通常可以互换使用，但它们指的是具有某些区别的不同数据结构。我们来探讨一下它们之间的差异
-
内存分配：Python 中的数组由
array模块提供，表示固定大小、同构的元素集合。与列表相比，它们通常更省内存，因为它们将相同类型的元素连续存储在内存中。另一方面，列表是异构的，可以存储不同类型的元素。列表作为动态数组实现，可以自动调整自身大小以容纳新元素。 -
数据类型：数组受限于特定数据类型。创建数组时，需要指定它将保存的元素类型（例如，整数、浮点数、字符）。此限制允许数组对其元素提供更有效的存储和操作。列表是异构的，可以在同一列表中包含不同数据类型的元素。
-
灵活性：与数组相比，列表更灵活。它们可以动态增长或缩小，因为可以在任何位置添加或删除元素。数组一旦创建，就具有固定大小，并且无法更改。如果你需要修改数组的大小，则必须创建一个具有所需大小的新数组，并从旧数组中复制元素。
-
操作和方法：数组和列表都提供常见的操作，如索引、切片和迭代。但是，数组有
array模块提供的其他方法，例如对整个数组进行有效的数学运算（例如，求和、乘积），与对列表进行等效运算相比，速度可能更快。外部库：一些外部库（如 NumPy）提供了多维数组，这些数组广泛用于数值计算。NumPy 数组在数组上提供高效的存储和矢量化操作，使其针对数值计算进行了高度优化。列表没有这样的内置功能。
总之，数组是固定大小、同构的元素集合，它们具有内存效率并提供特定操作，而列表是动态、异构的集合，提供更大的灵活性和通用性。数组和列表之间的选择取决于程序的特定要求，例如内存使用情况、数据类型约束以及对动态调整大小或专门操作的需求。
如何创建数组
在 Python 中，可以使用各种方法和库创建数组。在创建数组时还应考虑一些其他参数。
带有整数的简单数组
可以使用内置的 array 模块或简单地初始化一个空列表在 Python 中创建数组。以下是创建数组的两个示例
- 使用
array模块初始化一个整数数组
import array
# Create an array of integers
my_array = array.array('i', [1, 2, 3, 4, 5])
- 第二种方法是声明一个列表而不是数组
# Create a list
my_list = [1, 2, 3, 4, 5]
要创建一个空数组，可以按照上面提到的方法进行操作。接下来，我们将介绍如何定义大小为 n 的数组。
大小为 N 的数组
要在 Python 中创建一个特定大小的数组，可以使用多种方法，包括使用列表解析或使用 NumPy。以下是一些数组声明的示例
使用列表解析
n = 5
my_array = [0] * n
print(my_array) # Output: [0, 0, 0, 0, 0]
使用 NumPy
import numpy as np
n = 5
my_array = np.zeros(n)
print(my_array) # Output: [0. 0. 0. 0. 0.]
随机生成数组
要在 Python 中生成随机数组，可以使用 Python 标准库中的 random 模块 或 numpy 库。以下是使用这两种方法的示例
使用 random 模块
import random
# Generate a random array of size n
n = 5
random_array = [random.randint(0, 100) for _ in range(n)]
print(random_array) # Output: [47, 92, 32, 12, 80]
使用 numpy 库
import numpy as np
# Generate a random array of size n
n = 5
random_array = np.random.randint(0, 100, size=n)
print(random_array) # Output: [92 76 32 48 11]
这两种方法都允许生成随机整数数组。根据特定要求调整参数（a、b 和 size）以控制随机数组的范围和大小。
Python 中的 2D 数组
以下是如何使用 np.array() 函数在 Python 中初始化多维数组的示例
import numpy as np
# Create a 2-dimensional array
arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2)
# Output:
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
还可以使用列表的列表创建二维数组，其中每个内部列表表示一行。以下是如何使用嵌套列表创建和初始化 2D 数组的示例
# Create a 2D array with 3 rows and 4 columns
array_2d = [[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]]
# Accessing elements
print(array_2d[0][2]) # Output: 2 (element at row 0, column 2)
print(array_2d[1][3]) # Output: 7 (element at row 1, column 3)
# Modifying elements
array_2d[2][1] = 99 # Changing element at row 2, column 1 to 99
print(array_2d[2][1]) # Output: 99
# Iterating through the array
for row in array_2d:
for element in row:
print(element, end=' ')
print()
如何在 Python 中创建 NumPy 数组
要在 Python 中创建 NumPy 数组，可以使用 numpy.array() 函数。以下是 np 数组初始化的示例
import numpy as np
# Create a 1-dimensional array
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
# Output: [1 2 3 4 5]
在上面的代码中，import numpy as np 导入 NumPy 模块，使我们能够使用其 函数 和 类。
Python 中的字符串数组
要创建 Python 中的字符串数组，可以使用列表，其中列表的每个元素都表示一个字符串。以下是一个示例
array = ['apple', 'banana', 'orange', 'grape']
print(array) # Output: ['apple', 'banana', 'orange', 'grape']
在上面的示例中，我们使用列表创建了一个名为 array 的字符串数组。列表的每个元素都表示一个字符串。结果数组包含四个字符串：“apple”、“banana”、“orange”和“grape”。
字典数组
在 Python 中，可以通过简单地初始化一个列表并添加字典作为其元素来创建 字典数组（或列表）。每个字典都可以包含表示不同属性的键值对。以下是一个示例
# Create an array of dictionaries
array_of_dictionaries = [
{"name": "John", "age": 25, "city": "New York"},
{"name": "Alice", "age": 30, "city": "London"},
{"name": "Bob", "age": 35, "city": "Paris"}
]
# Accessing values
print(array_of_dictionaries[0]["name"]) # Output: John
print(array_of_dictionaries[1]["age"]) # Output: 30
print(array_of_dictionaries[2]["city"]) # Output: Paris
Python 中的元组数组
在 Python 中，可以使用不同的数据结构创建 元组数组。以下是一些示例
- 元组列表
可以使用列表创建元组数组。每个元组都表示数组中的一个元素。以下是一个示例
# List of tuples
array = [(1, 'apple'), (2, 'banana'), (3, 'orange')]
# Accessing elements in the array
for item in array:
number, fruit = item
print(f"Number: {number}, Fruit: {fruit}")
- NumPy 元组数组
如果使用 NumPy 数组，可以使用 np.array() 函数创建元组数组。以下是一个示例
import numpy as np
# NumPy array of tuples
array = np.array([(1, 'apple'), (2, 'banana'), (3, 'orange')])
# Accessing elements in the array
for item in array:
number, fruit = item
print(f"Number: {number}, Fruit: {fruit}")
- array 模块
如果使用内置 array 模块，可以使用 array 构造函数创建元组数组。以下是一个示例
import array as arr
# Array of tuples
array = arr.array('i', [(1, 2), (3, 4), (5, 6)])
# Accessing elements in the array
for item in array:
number1, number2 = item
print(f"Number 1: {number1}, Number 2: {number2}")
字节数组
在 Python 中，可以使用内置 bytearray 或 bytes 类型创建字节数组。以下是创建和使用字节数组的示例
使用 bytearray
my_array = bytearray([0x41, 0x42, 0x43, 0x44]) # Creating a bytearray from a list of byte values
print(my_array) # Output: bytearray(b'ABCD')
# Accessing individual bytes
print(my_array[0]) # Output: 65
print(hex(my_array[1])) # Output: 0x42
# Modifying bytes
my_array[2] = 0x45
print(my_array) # Output: bytearray(b'ABED')
使用 bytes
my_array = bytes([0x41, 0x42, 0x43, 0x44]) # Creating a bytes object from a list of byte values
print(my_array) # Output: b'ABCD'
# Accessing individual bytes
print(my_array[0]) # Output: 65
print(hex(my_array[1])) # Output: 0x42
bytearray 和 bytes 都表示字节序列，并且可以在许多上下文中互换使用。根据需要可变字节序列还是不可变字节序列选择合适的类型。
Python 中数组的 range() 函数
在 Python 中，你可以使用 range() 函数创建一个 数字 数组或列表。range() 函数生成一个指定范围内的数字序列。
以下是使用 range() 函数创建数字数组或列表的一些示例
- 创建一个数字范围作为列表
my_list = list(range(5))
print(my_list)
# Output: [0, 1, 2, 3, 4]
- 创建一个具有指定开始和结束的数字范围
my_list = list(range(2, 10))
print(my_list)
# Output: [2, 3, 4, 5, 6, 7, 8, 9]
- 创建一个具有指定开始、结束和步长的数字范围
my_list = list(range(1, 11, 2))
print(my_list)
# Output: [1, 3, 5, 7, 9]
range() 函数可用于根据不同的开始、结束和步长值创建数字数组或列表。通过使用 list() 函数将范围对象转换为列表，你可以获得范围的列表表示形式。
零数组
在 Python 中，你可以使用各种库和数据结构创建一个零数组。以下是一些示例
- NumPy
如果你安装了 NumPy，你可以使用 NumPy 库中的 zeros() 函数创建一个零数组。以下是一个示例
import numpy as np
# Create a 1-dimensional array of 5 zeros
zeros_array = np.zeros(5)
print(zeros_array)
你还可以通过将形状指定为元组来创建多维零数组。例如
import numpy as np
# Create a 2-dimensional array of 3 rows and 4 columns, filled with zeros
zeros_array = np.zeros((3, 4))
print(zeros_array)
- 列表解析
如果你更喜欢使用列表，你可以使用列表解析创建一个零数组。以下是一个示例
# Create a 1-dimensional array of 5 zeros using list comprehension
zeros_array = [0] * 5
print(zeros_array)
对于多维数组，你可以嵌套列表解析。以下是一个示例
# Create a 2-dimensional array of 3 rows and 4 columns, filled with zeros using nested list comprehension
zeros_array = [[0] * 4 for _ in range(3)]
print(zeros_array)
Python 中数组的长度
你可以使用 len() 函数获取数组（或任何序列）的长度。len() 函数返回序列中的元素数量。
以下是使用 len() 获取数组长度的示例
my_array = [1, 2, 3, 4, 5]
length = len(my_array)
print(length) # Output: 5
在此示例中，len(my_array) 计数数组元素并返回 my_array 列表的长度，即 5。length 变量存储此值，然后将其打印到控制台。
注意：
len()函数不仅适用于数组，还适用于任何可迭代对象，例如列表、元组、字符串或集合。
Python 中的数组索引
在 Python 中，索引数组通常使用列表表示。列表的索引用于访问和操作其中的元素，因此你可以使用索引访问数组（或列表）的各个元素。数组索引允许你通过引用数组中元素的位置或索引来从数组中检索特定元素。
数组索引从 0 开始，因此数组的第一个元素位于索引 0，第二个元素位于索引 1，依此类推。
以下是 Python 中使用数组索引的示例
my_array = [10, 20, 30, 40, 50]
element = my_array[2]
print(element) # Output: 30
在此示例中，my_array[2] 检索 my_array 中索引为 2 的元素，即 30。然后将该值存储在 element 变量中并打印到控制台。
你还可以使用负索引从数组末尾访问元素。使用负索引时，-1 表示最后一个元素，-2 表示倒数第二个元素，依此类推。
my_array = [10, 20, 30, 40, 50]
element = my_array[-1]
print(element) # Output: 50
在这种情况下，my_array[-1] 检索 my_array 的最后一个元素，即 50。该值存储在 element 变量中并打印到控制台。
你还可以使用索引来修改元素的值或使用切片从数组中提取元素子集。
使用“for”循环遍历数组
在 Python 中，你可以使用“for”循环遍历数组元素并对每个元素执行操作。根据你使用的数组类型，有不同的方法可以遍历数组。以下是遍历数组的一些示例
- 使用 for 循环和标准 Python 列表
my_list = [1, 2, 3, 4, 5]
for element in my_list:
print(element)
输出
1
2
3
4
5
- 使用
for循环和 NumPy 数组
import numpy as np
my_array = np.array([1, 2, 3, 4, 5])
for element in my_array:
print(element)
输出
1
2
3
4
5
- 使用
for循环和多维 NumPy 数组
import numpy as np
my_array = np.array([[1, 2], [3, 4], [5, 6]])
for row in my_array:
for element in row:
print(element)
输出
1
2
3
4
5
6
Python 数组或数据帧
我们已经了解了什么是数组，我们来看看 DataFrame。
数据框（pandas）是 pandas 库提供的二维表格数据结构。它用途广泛，广泛用于数据操作和分析任务。数据框可以保存不同类型的数据（例如，整数、浮点数、字符串），并提供强大的索引、切片、分组和聚合功能。在处理大型数据集、执行复杂操作或需要使用标记或结构化数据时，数据框特别有用。
下面是一个创建数据框的示例
import pandas as pd
data = {'Name': ['John', 'Alice', 'Bob'],
'Age': [25, 30, 35],
'Country': ['USA', 'Canada', 'UK']}
df = pd.DataFrame(data)
print(df)
输出
Name Age Country
0 John 25 USA
1 Alice 30 Canada
2 Bob 35 UK
在此示例中，我们使用字典 data 创建数据框 df，然后打印结果数据框。
数据框提供了许多功能，例如索引、筛选、合并和处理缺失值，使其成为数据分析和操作任务的热门选择。
总之，如果你需要一个用于基本数值计算的简单数据结构，Python 数组就足够了。但是，如果你需要更高级的数据操作、分析和表格结构，数据框（例如 pandas 数据框）将是更好的选择。
如何在 Python 中打印数组
要打印 Python 中的数组，可以使用 print() 函数。具体语法取决于你正在使用的数组类型。以下是一些示例
- 打印标准 Python 列表
my_list = [1, 2, 3, 4, 5]
print(my_list) # Output: [1, 2, 3, 4, 5]
- 打印 NumPy 数组
import numpy as np
my_array = np.array([1, 2, 3, 4, 5])
print(my_array) # Output: [1 2 3 4 5]
- 打印多维 NumPy 数组
import numpy as np
my_array = np.array([[1, 2, 3], [4, 5, 6]])
print(my_array)
输出
[[1 2 3]
[4 5 6]]
如何在数组中查找元素
要在 Python 中查找数组中的元素，可以使用不同的方法，具体取决于你正在使用的数组类型。以下是一些示例
- 列表
如果你有一个标准 Python 列表，可以使用 in 运算符或 index() 方法查找元素
my_list = [1, 2, 3, 4, 5]
# Using the 'in' operator
if 3 in my_list:
print("Element found")
# Using the 'index()' method
try:
index = my_list.index(3)
print("Element found at index:", index)
except ValueError:
print("Element not found")
- NumPy 数组
对于 NumPy 数组，可以使用布尔索引或 where() 函数查找与条件匹配的索引或值
import numpy as np
my_array = np.array([1, 2, 3, 4, 5])
# Using boolean indexing
mask = my_array == 3
indices = np.where(mask)[0]
if indices.size > 0:
print("Element found at indices:", indices)
else:
print("Element not found")
# Using 'where()' function
indices = np.where(my_array == 3)[0]
if indices.size > 0:
print("Element found at indices:", indices)
else:
print("Element not found")
map() 函数
在 Python 中，可以使用 map() 函数将给定函数应用于数组或可迭代对象的每个元素。map() 函数返回一个迭代器，其中包含将提供的函数应用于每个元素的结果。下面是一个使用 map() 和数组的示例
my_array = [1, 2, 3, 4, 5]
# Define a function to apply to each element
def square(x):
return x ** 2
# Apply the square function to each element of the array using map()
result = map(square, my_array)
# Convert the result to a list
result_list = list(result)
print(result_list) # Output: [1, 4, 9, 16, 25]
在此示例中，map() 函数用于将 square() 函数应用于 my_array 的每个元素。square() 函数对每个输入数字求平方，map() 函数返回一个包含平方值的迭代器。最后，使用 list() 函数将结果转换为列表。
或者，你可以使用 lambda 函数和 map() 以更简洁的方式实现相同的结果
my_array = [1, 2, 3, 4, 5]
# Apply the lambda function to each element of the array using map()
result = map(lambda x: x ** 2, my_array)
result_list = list(result)
print(result_list) # Output: [1, 4, 9, 16, 25]
在这种情况下，lambda 函数 lambda x: x ** 2 用于对数组的每个元素求平方。
map() 函数是一个有用的工具，用于将函数应用于 Python 中数组或可迭代对象的每个元素。它简化了转换元素的过程，并提供了一种执行逐元素操作的简洁方法。
使用 JSON 数组
在 Python 中，可以使用 json 模块处理 JSON 数组，该模块提供了用于处理 JSON 数据的函数。以下是如何在 Python 中处理 JSON 数组的示例
import json
# JSON array as a string
json_data = '[{"name": "John", "age": 30}, {"name": "Alice", "age": 25}, {"name": "Bob", "age": 35}]'
# Parse the JSON array string into a Python list
array = json.loads(json_data)
# Accessing elements in the array
for item in array:
name = item['name']
age = item['age']
print(f"Name: {name}, Age: {age}")
你还可以使用 json.dumps() 函数将 Python 列表转换为 JSON 数组。以下是一个示例
import json
# Python list
array = [
{"name": "John", "age": 30},
{"name": "Alice", "age": 25},
{"name": "Bob", "age": 35}
]
# Convert the Python list to a JSON array string
json_data = json.dumps(array)
print(json_data)
如何在 Python 中获取数组的最后一个元素
要获取 Python 中数组的最后一个元素，可以使用索引或内置函数，具体取决于你正在使用的数据结构。以下是一些方法
- 列表
如果你有一个列表，可以使用负索引访问最后一个元素。以下是一个示例
my_list = [1, 2, 3, 4, 5]
last_element = my_list[-1]
print(last_element) # Output: 5
- NumPy 数组
如果你正在使用 NumPy 数组，可以使用 [-1] 索引访问最后一个元素。以下是一个示例
import numpy as np
my_array = np.array([1, 2, 3, 4, 5])
last_element = my_array[-1]
print(last_element) # Output: 5
- array 模块
如果你正在使用内置数组模块，可以使用索引访问最后一个元素。以下是一个示例
import array as arr
my_array = arr.array('i', [1, 2, 3, 4, 5])
last_element = my_array[-1]
print(last_element) # Output: 5
如何在 Python 中保存 NumPy 数组
要在 Python 中保存 NumPy 数组，可以使用 numpy.save() 函数或 numpy.savez() 函数。以下是使用每种函数的方法
-
numpy.save()：此函数将单个 NumPy 数组保存到扩展名为.npy的二进制文件中。你可以指定文件名以及要保存的数组。以下是一个示例
import numpy as np
my_array = np.array([1, 2, 3, 4, 5])
np.save('my_array.npy', my_array)
-
numpy.savez()：此函数将多个 NumPy 数组保存到单个压缩的.npz文件中。你可以提供文件名并将数组作为参数传递。以下是一个示例
import numpy as np
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
np.savez('my_arrays.npz', array1=array1, array2=array2)
bitarray 库
在 Python 中，可以使用 bitarray 库处理位数组。bitarray 库提供了一种灵活高效的方法来处理布尔值数组，其中每个布尔值表示一个位。
要使用 bitarray 库，首先需要安装它。可以使用 pip 通过运行以下命令进行安装
pip install bitarray
安装后，可以使用库中的 bitarray 类开始处理位数组。以下是一个示例
import bitarray
# Create a new bit array with a specified length
my_bitarray = bitarray.bitarray(10)
# Set individual bits
my_bitarray[0] = True
my_bitarray[1] = False
my_bitarray[2] = True
# Access individual bits
print(my_bitarray[0]) # Output: True
print(my_bitarray[1]) # Output: False
print(my_bitarray[2]) # Output: True
# Set multiple bits at once
my_bitarray[3:6] = bitarray.bitarray([True, False, True])
# Access multiple bits at once
print(my_bitarray[3:6]) # Output: bitarray('101')
# Perform bitwise operations
other_bitarray = bitarray.bitarray([True, False, False, True])
result = my_bitarray & other_bitarray # Bitwise AND operation
print(result) # Output: bitarray('1000')
# Convert bitarray to a regular list of booleans
bit_list = my_bitarray.tolist()
print(bit_list) # Output: [True, False, True, True, False, False, False, False, False, False]
Python 中的关联数组
在 Python 中，关联数组通常使用字典实现。字典是无序的键值对集合，其中每个键是唯一的并与一个值关联。它们提供了一种基于特定键而不是数字索引存储和检索数据的方法。以下是如何在 Python 中将字典用作关联数组的示例
# Creating an associative array (dictionary)
student_scores = {
"John": 85,
"Alice": 92,
"Bob": 78,
"Emily": 95
}
# Accessing values using keys
print(student_scores["John"]) # Output: 85
print(student_scores["Alice"]) # Output: 92
# Modifying values
student_scores["Bob"] = 80
print(student_scores["Bob"]) # Output: 80
# Adding new key-value pairs
student_scores["David"] = 88
# Checking if a key exists
if "Emily" in student_scores:
print("Emily's score:", student_scores["Emily"]) # Output: Emily's score: 95
# Removing a key-value pair
del student_scores["Alice"]
# Iterating over keys and values
for student, score in student_scores.items():
print(student, "scored", score)
Python 中的动态数组
在 Python 中，可以使用内置的 list 数据结构创建动态数组。Python 中的动态数组是一个可调整大小的数组，可以根据需要增大或减小。list 数据结构自动提供动态调整大小，允许你在不显式管理数组大小的情况下动态添加或删除元素。
以下是如何在 Python 中创建和使用动态数组的示例
# Create an empty dynamic array
my_array = []
# Append elements dynamically
my_array.append(1)
my_array.append(2)
my_array.append(3)
print(my_array) # Output: [1, 2, 3]
# Modify elements
my_array[1] = 4
print(my_array) # Output: [1, 4, 3]
# Remove elements
my_array.remove(1)
print(my_array) # Output: [4, 3]
深入了解主题
