Python 中的数组：排序、洗牌、追加、连接等

数组使我们能够高效地存储和处理数据，从而能够执行各种任务。在本文中，我们将探讨与 Python 中的数组关联的最基本最常见操作。

排序和洗牌

排序和洗牌是数据处理和分析中的常见操作。在 Python 中，有可用的内置函数和方法来高效地执行这些任务。

如何在 Python 中获取已排序数组

在 Python 中，可以使用 sorted() 函数对数组（或列表）进行排序。sorted() 函数将可迭代对象作为输入，并返回一个包含原始可迭代对象元素的新已排序列表。

以下是如何使用 sorted() 对数组进行排序的示例

my_array = [5, 2, 1, 4, 3]
sorted_array = sorted(my_array)
print(sorted_array)  # Output: [1, 2, 3, 4, 5]

在此示例中，sorted(my_array) 返回一个新列表，其中包含按排序顺序排列的 my_array 元素。sorted_array 变量存储此已排序列表，然后将其打印到控制台。

需要注意的是，sorted() 函数返回一个新的已排序列表，并且不会就地修改原始数组。如果要对原始数组本身进行排序，则可以使用数组的 sort() 方法

my_array = [5, 2, 1, 4, 3]
my_array.sort()
print(my_array)  # Output: [1, 2, 3, 4, 5]

在这种情况下，my_array.sort() 将就地对 my_array 的元素进行排序，直接修改数组。然后将已排序数组打印到控制台。

如何洗牌数组

要对 Python 中的数组进行洗牌，你可以使用 random 模块中的 random.shuffle() 函数。此函数会随机地对序列的元素进行洗牌，就地进行。这是一个示例

import random

my_array = [1, 2, 3, 4, 5]

random.shuffle(my_array)

print(my_array)

追加、推送、连接和扩展

让我们回顾一下向数组追加或推送元素的方法。

如何向数组追加元素

可以使用列表数据类型提供的 append() 方法向 Python 中的现有数组追加元素。下面是一个向数组（或列表）添加元素的示例

array = ['apple', 'banana', 'orange']
array.append('grape')
print(array) # Output: ['apple', 'banana', 'orange', 'grape']

append() 方法允许将指定元素插入到数组（或列表）的末尾。它会就地修改原始列表，并且不会返回新列表。

你可以将任何数据类型的元素追加到 Python 列表中，包括字符串、数字，甚至其他列表。

如你所见，append() 方法允许你通过添加新元素轻松地扩展数组（或列表）。

注意：append() 方法一次只能添加一个元素。如果你想向数组添加多个元素，可以使用 extend() 方法或使用 + 运算符连接列表。

如何将元素推入数组

在 Python 中，“推送”元素到数组的概念通常与可变数据结构（如列表）相关。可变数据结构允许你通过添加、删除或修改值来修改元素。因此，它与 append() 方法相同，你可以使用列表将元素“推送”到数组中

my_list = []  # Initialize an empty list

# Pushing elements into the list
my_list.append(1)
my_list.append(2)
my_list.append(3)

print(my_list)  # Output: [1, 2, 3]

注意：此方法专门适用于 Python 中的列表。其他数据结构，如 NumPy 数组或不可变元组，有不同的方法或限制来修改其内容。

如何在 Python 中连接数组

要连接 Python 中的数组，你可以使用不同的方法，具体取决于你使用的数组类型。以下是如何组合数组的一些示例

使用标准 Python 列表的 + 运算符

array1 = [1, 2, 3]
array2 = [4, 5, 6]
concatenated = array1 + array2
print(concatenated) # Output: [1, 2, 3, 4, 5, 6]

使用 NumPy 的 concatenate() 函数

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
concatenated = np.concatenate((array1, array2))
print(concatenated) # Output: [1 2 3 4 5 6]

使用 NumPy 的 hstack() 或 vstack() 函数分别进行水平或垂直连接

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
concatenated = np.hstack((array1, array2))
print(concatenated) # Output: [1 2 3 4 5 6]

在此示例中，我们使用 hstack() 函数水平堆叠 array1 和 array2，生成一个新数组 concatenated，其中包含一行中连接的元素。

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
concatenated = np.vstack((array1, array2))
print(concatenated)

输出

[[1 2 3]
 [4 5 6]]

在此示例中，我们使用 vstack() 函数垂直堆叠 array1 和 array2，生成一个新数组 concatenated，其中包含两行中连接的元素。

如何在 Python 中扩展数组

有许多方法允许我们在 Python 中扩展数组。以下是如何在 Python 中合并或组合数组的一些方法

列表

如果你有一个列表，可以使用 extend() 方法将另一个可迭代对象的元素添加到列表末尾。这是一个示例

my_list = [1, 2, 3]
new_elements = [4, 5, 6]

my_list.extend(new_elements)

print(my_list)

NumPy

如果你使用 NumPy 数组，可以使用 concatenate() 函数沿着指定轴组合两个数组。这是一个示例

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

extended_array = np.concatenate((array1, array2))

print(extended_array)

数组模块

如果您使用内置的array模块，则可以使用extend()方法将另一个可迭代对象的元素添加到数组的末尾。这是一个示例

import array as arr

my_array = arr.array('i', [1, 2, 3])
new_elements = arr.array('i', [4, 5, 6])

my_array.extend(new_elements)

print(my_array)

getsizeof() 函数

在 Python 中，没有名为sizeof()的内置函数可以直接获取数组或列表的大小。但是，您可以使用sys模块的getsizeof()函数来估算对象所占用的内存大小。

这是一个示例

import sys

my_list = [10, 20, 30, 40, 50]
size = sys.getsizeof(my_list)

print(size)  # Output: 104 (the size in bytes)

在上面的示例中，我们导入sys模块并使用getsizeof()函数以字节为单位获取my_list对象的大小。

注意：getsizeof()返回的值包括列表对象本身的开销，可能无法准确表示数组/列表元素所占用的内存。

反转和转置

在 Python 中，我们经常遇到需要反转或转置数组的情况。

如何在 Python 中反转数组

您可以使用各种方法在 Python 中反转或翻转数组（列表）。以下是反转 Python 中数组的一些常见方法

使用reverse()方法

my_list = [10, 20, 30, 40, 50]
my_list.reverse()
print(my_list)  # Output: [50, 40, 30, 20, 10]

使用切片技术

my_list = [10, 20, 30, 40, 50]
reversed_list = my_list[::-1]
print(reversed_list)  # Output: [50, 40, 30, 20, 10]

使用reversed()函数

my_list = [10, 20, 30, 40, 50]
reversed_list = list(reversed(my_list))
print(reversed_list)  # Output: [50, 40, 30, 20, 10]

所有这三种方法都能达到相同的效果。第一种方法使用reverse()方法，该方法就地反转列表的元素，修改原始列表。第二种方法使用步长为 -1（[::-1]）的切片，创建一个元素按相反顺序排列的新列表。第三种方法使用reversed()函数创建一个反向迭代器，然后使用list()函数将其转换为列表。

如何在 Python 中转置数组

要在 Python 中转置列表和 NumPy 数组，您可以按照以下步骤操作

转置列表

创建一个列表列表，其中每个内部列表表示原始矩阵的一行。
使用zip(*list)函数转置列表。

这是一个示例

# Create a sample list
list_of_lists = [[1, 2, 3],
                 [4, 5, 6]]

# Transpose the list
transposed_list = list(zip(*list_of_lists))

print(transposed_list) # Output: [(1, 4), (2, 5), (3, 6)]

转置 NumPy 数组

要转置 NumPy 数组，可以使用 NumPy 库提供的transpose()函数，如前一个示例所示。以下是一个专门针对 NumPy 数组的示例

import numpy as np

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

# Transpose the array
transposed_array = np.transpose(array)

print(transposed_array)

输出

[[1 4]
 [2 5]
 [3 6]]

如何检查数组是否为空

要检查数组在 Python 中是否为空，可以使用len()函数或与空数组进行直接比较。以下是如何针对不同类型的数组执行此操作

列表

my_list = []  # Empty list

# Using len() function
if len(my_list) == 0:
    print("Array is empty")

# Direct comparison
if my_list == []:
    print("Array is empty")

NumPy 数组

import numpy as np

my_array = np.array([])  # Empty NumPy array

# Using len() function
if len(my_array) == 0:
    print("Array is empty")

# Direct comparison
if np.array_equal(my_array, np.array([])):
    print("Array is empty")

如何复制数组

您可以使用多种方法在 Python 中复制数组。以下是复制数组的一些常见方法

列表

对于标准 Python 列表，可以使用切片语法[:]或copy()方法创建副本

使用切片

my_list = [1, 2, 3, 4, 5]
my_list_copy = my_list[:]

使用copy()方法

my_list = [1, 2, 3, 4, 5]
my_list_copy = my_list.copy()

NumPy 数组

对于 NumPy 数组，可以使用copy()函数创建副本

import numpy as np

my_array = np.array([1, 2, 3, 4, 5])
my_array_copy = np.copy(my_array)

如何过滤数组

要过滤 Python 中的数组，您可以使用不同的方法，具体取决于您正在使用的数组类型。以下是一些常见方法

列表推导

对于标准 Python 列表，可以使用列表推导创建仅包含基于特定条件的所需元素的新列表。这是一个示例

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Filter elements greater than 5
filtered_list = [x for x in my_list if x > 5]

print(filtered_list)  # Output: [6, 7, 8, 9, 10]

筛选函数

您还可以使用内置的filter()函数以及 lambda 函数或自定义函数，根据给定条件从列表中筛选元素。这是一个示例

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Filter elements greater than 5 using lambda function
filtered_list = list(filter(lambda x: x > 5, my_list))

print(filtered_list)  # Output: [6, 7, 8, 9, 10]

NumPy 数组

对于 NumPy 数组，你可以使用布尔索引根据条件筛选元素。这是一个示例

import numpy as np

my_array = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Filter elements greater than 5
filtered_array = my_array[my_array > 5]

print(filtered_array)  # Output: [ 6  7  8  9 10]

如何在 Python 中连接数组

你可以使用几种不同的方法在 Python 中连接数组。这里有一些常见方法

连接列表元素

对于标准 Python 列表，你可以使用字符串的 join() 方法将列表的元素连接成一个字符串。这是一个示例

my_list = ['Hello', 'World', 'Python']

# Join the list elements with a space separator
joined_string = ' '.join(my_list)

print(joined_string)  # Output: 'Hello World Python'

在这个示例中，join() 方法与空格 ' ' 作为分隔符一起使用，将列表的元素连接成一个字符串。

连接 NumPy 数组元素

对于 NumPy 数组，你可以使用 NumPy 的 char 对象的 join() 方法将数组的元素连接成一个字符串。这是一个示例

import numpy as np

my_array = np.array(['Hello', 'World', 'Python'])

# Join the array elements with a space separator
joined_string = np.char.join(' ', my_array)

print(joined_string)  # Output: ['H e l l o' 'W o r l d' 'P y t h o n']

在这个示例中，来自 np.char 的 join() 方法与空格 ' ' 作为分隔符一起使用，将数组的元素连接成一个字符串。

数组计算的总和

你可以使用不同的方法计算 Python 中数组元素的和。这里有一些常见方法

列表

对于标准 Python 列表，你可以使用内置的 sum() 函数计算所有元素的和

my_list = [1, 2, 3, 4, 5]
array_sum = sum(my_list)
print(array_sum)

NumPy 数组

对于 NumPy 数组，你可以使用 NumPy 库中的 sum() 函数计算所有元素的和

import numpy as np

my_array = np.array([1, 2, 3, 4, 5])
array_sum = np.sum(my_array)
print(array_sum)

数组的最大元素

要找到 Python 中数组中的最大值，你可以使用内置的 max() 函数或 numpy 库的 max() 函数。以下是你可以使用这两种方法的方式

使用内置的 max() 函数

my_array = [5, 2, 9, 1, 7]

# Find the maximum value in the array using the max() function
max_value = max(my_array)

print(max_value)  # Output: 9

使用 numpy 库

import numpy as np

my_array = np.array([5, 2, 9, 1, 7])

# Find the maximum value in the array using the max() function from numpy
max_value = np.max(my_array)

print(max_value)  # Output: 9

扁平化、拆分、切片和转换以及转换为二维数组

在 Python 中，展平、拆分和转换为 2D 数组是处理多维数据结构时的常见操作。我们来复习一下基础知识。

如何展平数组

你可以使用各种方法在 Python 中展平数组。以下是针对不同类型数组的一些方法

展平嵌套列表

你可以使用列表解析和递归展平嵌套列表。这是一个示例

def flatten_list(nested_list):
    flattened = []
    for item in nested_list:
        if isinstance(item, list):
            flattened.extend(flatten_list(item))
        else:
            flattened.append(item)
    return flattened

nested_list = [[1, 2, 3], [4, [5, 6]], [7, 8, 9]]
flattened_list = flatten_list(nested_list)
print(flattened_list) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

展平 NumPy 数组

你可以使用 NumPy 提供的 flatten() 方法展平数组。这是一个示例

import numpy as np

array = np.array([[1, 2, 3], [4, 5, 6]])
flattened_array = array.flatten()
print(flattened_array) # Output: [1 2 3 4 5 6]

使用 NumPy 展平多维数组

如果你有一个多维 NumPy 数组并希望将其展平，你可以使用 ravel() 方法。这是一个示例

import numpy as np

array = np.array([[1, 2, 3], [4, 5, 6]])
flattened_array = array.ravel()
print(flattened_array) # Output: [1 2 3 4 5 6]

如何在 Python 中将 1d 数组转换为 2d 数组

要将 1d 数组转换为 Python 中的 2d 数组，你可以使用 NumPy 库提供的 reshape() 方法。reshape() 方法允许你更改数组的形状而不修改其数据。以下是如何重塑数组的一个示例

import numpy as np

# 1d array
arr_1d = np.array([1, 2, 3, 4, 5, 6])

# Convert to 2d array
arr_2d = arr_1d.reshape((2, 3))

print(arr_2d)

输出

[[1 2 3]
 [4 5 6]]

reshape() 方法采用数组的所需形状作为其参数。在这种情况下，我们传递 (2, 3) 将数组重塑为 2x3 矩阵。原始 1d 数组中的元素数量必须与指定形状中的元素数量匹配。如果元素数量不兼容，将引发 ValueError。

注意：reshape() 方法返回具有所需形状的新数组；它不修改原始数组。

如何将数组拆分为块

要将数组拆分为 Python 中的块，你可以使用不同的方法，具体取决于你正在处理的数组或数据结构的类型。这里有一些方法

列表推导

如果你有一个列表，你可以使用列表解析将其拆分为特定大小的块。这是一个示例

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
chunk_size = 3

chunks = [my_list[i:i+chunk_size] for i in range(0, len(my_list), chunk_size)]

print(chunks)

NumPy

如果你使用的是 NumPy 数组，你可以使用 array_split() 函数将数组拆分为大小相等的块。这是一个示例

import numpy as np

my_array = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
chunk_size = 3

chunks = np.array_split(my_array, len(my_array) // chunk_size)

print(chunks)

数组模块

如果你使用的是内置的 array 模块，你可以使用循环将数组拆分为块。这是一个示例

import array as arr

my_array = arr.array('i', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
chunk_size = 3

chunks = [my_array[i:i+chunk_size] for i in range(0, len(my_array), chunk_size)]

print(chunks)

在 Python 中切片数组

要在 Python 中对数组（或列表）进行切片，可以使用切片符号 array[start:stop:step]，其中

start 是切片开始的索引（包括）。
stop 是切片结束的索引（不包括）。
step 是索引之间的间隔（可选，默认值为 1）。

以下是一些在 Python 中对数组进行切片的示例

my_array = [10, 20, 30, 40, 50, 60, 70, 80]

# Slice from index 2 to 5 (exclusive)
slice_1 = my_array[2:5]
print(slice_1)  # Output: [30, 40, 50]

# Slice from index 1 to the end of the array
slice_2 = my_array[1:]
print(slice_2)  # Output: [20, 30, 40, 50, 60, 70, 80]

# Slice from the beginning to index 4 (exclusive)
slice_3 = my_array[:4]
print(slice_3)  # Output: [10, 20, 30, 40]

# Slice with a step of 2
slice_4 = my_array[1:7:2]
print(slice_4)  # Output: [20, 40, 60]

# Slice in reverse order
slice_5 = my_array[::-1]
print(slice_5)  # Output: [80, 70, 60, 50, 40, 30, 20, 10]

在上面的示例中，我们有一个名为 my_array 的数组。通过指定适当的 start、stop 和 step 值，我们可以拆分数组，创建其不同的切片。

第一个示例创建了一个从索引 2 到 5（不包括）的切片，结果为 [30, 40, 50]。第二个示例创建了一个从索引 1 到数组末尾的切片，结果为 [20, 30, 40, 50, 60, 70, 80]。第三个示例创建了一个从开头到索引 4（不包括）的切片，结果为 [10, 20, 30, 40]。第四个示例创建了一个步长为 2 的切片，结果为 [20, 40, 60]。第五个示例通过使用负步长值 ([::-1]) 创建了一个反向切片，结果为 [80, 70, 60, 50, 40, 30, 20, 10]。

如何在 Python 中绘制数组

要在 Python 中绘制数组，你可以使用不同的库，具体取决于数组的类型和所需的绘图。以下是一些使用流行库的示例

Matplotlib（用于一维和二维数组）

Matplotlib 是 Python 中广泛使用的绘图库。你可以使用它来绘制一维和二维数组。以下是一个示例

import numpy as np
import matplotlib.pyplot as plt

# Plotting a 1D array
array_1d = np.array([1, 2, 3, 4, 5])
plt.plot(array_1d)
plt.show()

# Plotting a 2D array as an image
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
plt.imshow(array_2d, cmap='gray')
plt.show()

Seaborn（用于统计可视化）

Seaborn 是基于 Matplotlib 的统计数据可视化库。它提供了更高级别的函数来创建信息丰富的绘图。以下是一个示例

import numpy as np
import seaborn as sns

# Plotting a 1D array
array_1d = np.array([1, 2, 3, 4, 5])
sns.lineplot(x=np.arange(len(array_1d)), y=array_1d)
plt.show()

# Plotting a 2D array as a heatmap
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
sns.heatmap(array_2d, annot=True, cmap='coolwarm')
plt.show()

数组维度

你可以使用不同的库和数据结构来确定数组的维度。以下是一些方法

NumPy

如果你使用的是 NumPy 数组，可以使用 shape 属性获取数组的维度。以下是一个示例

import numpy as np

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

# Get the dimensions of the array
dimensions = array.shape

print(dimensions)  # Output: (2, 3)

列表的列表

如果你有一个表示为列表的列表的数组，可以使用 len() 函数来确定维度。以下是如何确定数组形状的一个示例

array = [[1, 2, 3], [4, 5, 6]]

# Get the dimensions of the array
rows = len(array)
columns = len(array[0])

print(rows, columns)  # Output: 2 3

数组模块

如果你使用的是内置的 array 模块，可以使用 len() 函数来确定数组的大小。以下是一个示例

import array as arr

array = arr.array('i', [1, 2, 3, 4, 5])

# Get the dimensions of the array
size = len(array)

print(size)  # Output: 5

数组是否包含特定元素？

要检查值是否存在于 Python 中的数组中，你可以使用不同的方法，具体取决于你使用的数组或数据结构的类型。以下是一些示例

列表

如果你有一个列表，可以使用 in 运算符来检查值是否存在。以下是一个示例

my_list = [1, 2, 3, 4, 5]

# Check if the value 3 is present in the list
if 3 in my_list:
    print("Value 3 is present in the list")

NumPy 数组

如果你使用的是 NumPy 数组，可以使用 np.isin() 函数来检查值是否存在。以下是一个示例

import numpy as np

my_array = np.array([1, 2, 3, 4, 5])

# Check if the value 3 is present in the array
if np.isin(3, my_array):
    print("Value 3 is present in the array")

数组模块

如果你使用的是内置的 array 模块，可以使用循环或 index() 方法来检查值是否存在。以下是一个示例

import array as arr

my_array = arr.array('i', [1, 2, 3, 4, 5])

# Check if the value 3 is present in the array
if 3 in my_array:
    print("Value 3 is present in the array")

数组运算

在 Python 中，你可以使用不同的库和数据结构对数组执行各种操作。以下是一些常用的操作

使用 NumPy 进行数学运算

NumPy 为数组提供了广泛的数学运算，例如逐元素运算、线性代数、统计运算等。以下是一些示例

import numpy as np

# Element-wise operations
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

addition = array1 + array2
subtraction = array1 - array2
multiplication = array1 * array2
division = array1 / array2

# Linear algebra operations
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])

matrix_multiplication = np.dot(matrix1, matrix2)
matrix_inverse = np.linalg.inv(matrix1)
eigenvalues, eigenvectors = np.linalg.eig(matrix1)

# Statistical operations
data = np.array([1, 2, 3, 4, 5, 6])
mean = np.mean(data)
median = np.median(data)
std_deviation = np.std(data)

列表运算

对于表示为 Python 列表的数组，您可以执行基本运算，如连接、切片、追加等。以下是一些示例

# Concatenation
list1 = [1, 2, 3]
list2 = [4, 5, 6]

concatenated_list = list1 + list2

# Slicing
array = [1, 2, 3, 4, 5]
sliced_array = array[1:4]  # [2, 3, 4]

# Appending
array = [1, 2, 3]
array.append(4)

这些只是您可以在 Python 中对数组执行的一些运算示例。

如何比较数组

让我们回顾如何在 Python 中比较数组。以下是一些方法

NumPy

如果您使用 NumPy 数组，则可以使用 NumPy 提供的逐元素比较运算符。以下是一个示例

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([1, 4, 3])

# Element-wise comparison
result = array1 == array2

print(result)

您还可以使用其他逐元素比较运算符，如 <、>、<=、>=、!= 等，来执行不同类型的比较。

列表

如果您有列表，可以使用 == 运算符对其进行比较。以下是一个示例

list1 = [1, 2, 3]
list2 = [1, 4, 3]

# Compare lists
result = list1 == list2

print(result)

注意：== 运算符比较列表中的元素和元素顺序。如果您想检查列表是否具有相同的元素（忽略顺序），可以使用 set() 函数将列表转换为集合，然后对其进行比较。

数组模块

如果您使用内置的 array 模块，可以使用循环逐元素比较数组。以下是一个示例

import array as arr

array1 = arr.array('i', [1, 2, 3])
array2 = arr.array('i', [1, 4, 3])

# Element-wise comparison
result = [a == b for a, b in zip(array1, array2)]

print(result)

数组的乘法

要在 Python 中执行数组的逐元素乘法，您可以对 NumPy 数组使用 * 运算符，或对常规 Python 列表使用列表解析。以下是如何使用这两种方法执行数组乘法

NumPy 数组

如果您使用 NumPy 数组，可以使用 * 运算符执行逐元素乘法。以下是一个示例

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

result = array1 * array2

print(result) # Output will be: [ 4 10 18]

使用列表解析的 Python 列表

如果您使用常规 Python 列表，可以使用列表解析执行逐元素乘法。以下是一个示例

list1 = [1, 2, 3]
list2 = [4, 5, 6]

result = [a * b for a, b in zip(list1, list2)]

print(result) # Output will be: [4, 10, 18]

删除元素或清除数组

让我们看看从数组中删除元素的方法。

如何在 Python 中从数组中删除第一个元素

有几种方法可以在 Python 中从数组中删除第一个元素。以下是一些示例

使用切片删除标准 Python 列表的第一个元素

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:]
print(new_list) # Output: [2, 3, 4, 5]

使用切片删除 NumPy 数组的第一个元素

import numpy as np

my_array = np.array([1, 2, 3, 4, 5])
new_array = my_array[1:]
print(new_array) # Output: [2 3 4 5]

使用 NumPy 的 delete() 函数就地修改原始数组

import numpy as np

my_array = np.array([1, 2, 3, 4, 5])
new_array = np.delete(my_array, 0)
print(new_array) # Output: [2 3 4 5]

注意：在前两个示例中，我们创建了一个新列表或数组，而不修改原始列表或数组。在第三个示例中，delete() 函数返回一个新数组，但它就地修改了原始数组。

根据您是要创建一个不包含第一个元素的新数组还是修改原始数组本身，选择适合您需求的方法。

数组的 `pop()` 方法

在 Python 中，您可以使用 pop() 方法从数组或列表中删除并返回一个元素。pop() 方法默认删除最后一个元素，但您也可以指定要删除的元素的索引。以下是一些示例

列表

如果您使用列表，可以使用 pop() 方法删除并返回最后一个元素。以下是一个示例

my_list = [1, 2, 3, 4, 5]

popped_element = my_list.pop()

print(popped_element)  # Output: 5
print(my_list)         # Output: [1, 2, 3, 4]

您还可以将索引传递给 pop() 方法，以删除并返回特定位置的元素。例如

my_list = [1, 2, 3, 4, 5]

popped_element = my_list.pop(2)

print(popped_element)  # Output: 3
print(my_list)         # Output: [1, 2, 4, 5]

数组模块

如果您使用内置的 array 模块，可以使用 pop() 方法删除并返回最后一个元素。以下是一个示例

import array as arr

my_array = arr.array('i', [1, 2, 3, 4, 5])

popped_element = my_array.pop()

print(popped_element)  # Output: 5
print(my_array)        # Output: array('i', [1, 2, 3, 4])

注意：`pop() 方法仅适用于列表，不适用于 NumPy 数组。

如何清除数组

要在 Python 中清除数组，您可以将一个空数组或列表分配给表示该数组的变量。以下是如何使用这两种方法清除数组

清除 NumPy 数组

如果您使用 NumPy 数组，可以将一个空 NumPy 数组分配给该变量。以下是一个示例

import numpy as np

my_array = np.array([1, 2, 3, 4, 5])

my_array = np.array([])

print(my_array) # Output: []

清除常规 Python 列表

如果您使用常规 Python 列表，可以将一个空列表分配给该变量。以下是一个示例

my_list = [1, 2, 3, 4, 5]

my_list = []

print(my_list) # Output: []

如何在 Python 中从已排序数组中删除重复项

让我们看看如何从 Python 中的已排序数组中删除重复项。下面是使用列表的常见方法

sorted_array = [1, 1, 2, 2, 3, 4, 4, 5, 5, 5]

# Create a new list with unique elements
unique_array = []
for num in sorted_array:
    if num not in unique_array:
        unique_array.append(num)

print(unique_array)  # Output: [1, 2, 3, 4, 5]

或者，如果你使用 NumPy 数组，可以使用 np.unique() 函数来实现相同的结果

import numpy as np

sorted_array = np.array([1, 1, 2, 2, 3, 4, 4, 5, 5, 5])

# Get unique elements from the sorted array
unique_array = np.unique(sorted_array)

print(unique_array)  # Output: [1 2 3 4 5]

与我们一起做出贡献！

不要犹豫，在 GitHub 上为 Python 教程做出贡献：创建分支，更新内容并发出拉取请求。

开始

Aliaksei Markaran作者

Python 开发人员，内容经理。

Aliaksandr Sumich贡献者

更新：05/03/2024 - 21:53

Evgeniy Melnikov审阅者

已审阅并批准

数组运算

目录

排序和洗牌

如何在 Python 中获取已排序数组

如何洗牌数组

追加、推送、连接和扩展

如何向数组追加元素

如何将元素推入数组

如何在 Python 中连接数组

如何在 Python 中扩展数组

getsizeof() 函数

反转和转置

如何在 Python 中反转数组

如何在 Python 中转置数组

如何检查数组是否为空

如何复制数组

如何过滤数组

如何在 Python 中连接数组

数组计算的总和

数组的最大元素

扁平化、拆分、切片和转换以及转换为二维数组

如何展平数组

如何在 Python 中将 1d 数组转换为 2d 数组

如何将数组拆分为块

在 Python 中切片数组

如何在 Python 中绘制数组

数组维度

数组是否包含特定元素？

数组运算

如何比较数组

数组的乘法

删除元素或清除数组

如何在 Python 中从数组中删除第一个元素

数组的 pop() 方法

如何清除数组

如何在 Python 中从已排序数组中删除重复项

与我们一起做出贡献！

数组的 `pop()` 方法