Python中列表中最小元素的索引

当我们需要随机访问时，我们在 python 程序中使用列表来存储不同类型的对象。在这篇文章中，我们将讨论在 python 中寻找列表中最小元素的索引的不同方法。

目录

1. 使用for循环计算列表中最小元素的索引
   1. Python 中的 len() 函数
   2. Python 中的 range() 函数
2. 使用min()函数和index()方法获得列表中最小元素的索引
   1. Python中的min()函数
   2. Python中的index()方法
3. 使用Numpy模块计算列表中最小元素的索引
4. 多次出现的情况下列表中最小元素的索引
   1. 使用min()函数和For循环计算列表中最小元素的索引
   2. 使用min()函数和列表理解的列表中最小元素的索引
   3. 使用min()函数和enumerate()函数计算列表中最小元素的索引
5. 总结

使用for循环获得列表中最小元素的索引

我们在 python 中使用 for 循环来遍历一个容器对象（如列表）的元素。为了使用 for 循环找到列表中最小元素的索引，我们可以使用 len() 函数和range() 函数。

Python 中的 len() 函数

python 中的len() 函数用于查找一个集合对象的长度，如 list 或 tuple。它把像列表这样的容器对象作为其输入参数，执行后返回集合对象的长度。你可以在下面的例子中观察到这一点。

myList = [1, 2, 23, 32, 12, 44, 34, 55, 46, 21, 12]
print("The list is:", myList)
list_len = len(myList)
print("Length of the list is:", list_len)

输出。

The list is: [1, 2, 23, 32, 12, 44, 34, 55, 46, 21, 12]
Length of the list is: 11

在这里，我们把一个有11个元素的列表传给了len() 函数。执行后，它返回相同的值。

Python 中的 range() 函数

range() 函数是用来在Python中生成一个数字序列的。在最简单的情况下，range() 函数将一个正数 N 作为输入参数，并返回一个包含从 0 到 N-1 的数字的序列。你可以在下面的例子中观察到这一点。

sequence = range(11)
print("The sequence is:", sequence)

输出。

The sequence is: range(0, 11)

为了在python中使用for循环、 len() 函数和range() 函数找到一个列表中最小元素的索引，我们将使用以下步骤。

• 首先，我们将使用len() 函数计算出输入列表的长度。我们将把这个值存储在一个变量中list_len 。
• 在计算出列表的长度后，我们将使用range() 函数创建一个从0到 list_len-1 的数字序列。
• 现在，我们将定义一个变量min_index ，并假设列表中的最小元素存在于索引0处，将其赋值为0。
• 创建序列后，我们将使用for循环遍历序列中的数字。迭代时，我们将在每个索引处访问输入列表中的元素。
• 在每个索引处，我们将检查当前索引处的元素是否小于列表中min_index 索引处的元素。如果当前元素小于min_index ，我们将更新min_index 为当前索引。

执行for循环后，你将在min_index 变量中得到列表中最小元素的索引。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
min_index = 0
list_len = len(myList)
for index in range(list_len):
    if myList[index] < myList[min_index]:
        min_index = index
print("Index of the minimum element is:", min_index)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Index of the minimum element is: 3

在上面的方法中，如果列表中有多个元素出现，你将得到最小元素的最左边的索引。为了得到最小元素出现的最右边的索引，你可以在比较列表中的元素时使用小于或等于操作符，而不是小于操作符。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
min_index = 0
list_len = len(myList)
for index in range(list_len):
    if myList[index] <= myList[min_index]:
        min_index = index
print("Index of the minimum element is:", min_index)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Index of the minimum element is: 11

使用min()函数和index()方法的列表中最小元素的索引

我们可以使用min() 函数和 index() 方法来查找 python 中列表中最小元素的索引，而不是使用 for 循环来迭代整个列表。

Python中的min()函数

min() 函数用于查找容器对象中的最小元素，如列表、元组或集合。min() 函数将一个集合对象如 list 作为其输入参数。执行后，它返回列表中的最小元素。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
min_val = min(myList)
print("The minimum value is:", min_val)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
The minimum value is: 1

Python中的index()方法

index() 方法是用来寻找一个元素在列表中的位置。当在一个列表上调用时，index() 方法将一个元素作为其输入参数。执行后，它返回该元素第一次出现的索引。例如，我们可以找到列表中第23个元素的索引，如下图所示。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
index = myList.index(23)
print("Index of 23 is:", index)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Index of 23 is: 2

如上所述，如果一个元素有多个出现，index() 方法只返回该元素的最左边的索引。如果我们将元素1作为输入参数传给index() 方法，尽管元素1也存在于索引11处，但输出结果将是3。

如果输入参数中的元素不存在于列表中，index() 方法会引发一个ValueError 异常，说该元素不存在于列表中。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
index = myList.index(105)
print("Index of 105 is:", index)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Traceback (most recent call last):
  File "/home/aditya1117/PycharmProjects/pythonProject/string12.py", line 3, in <module>
    index = myList.index(105)
ValueError: 105 is not in list

在这里，我们将105作为输入参数传递给index() 方法。然而，105并不存在于列表中。因此，程序遇到ValueError 异常，显示 105 不存在于列表中。

为了使用min() 函数和index() 函数找到列表中最小元素的索引，我们将使用以下步骤。

首先，我们将使用min() 函数找到列表中的最小元素。我们将把这个值存储在一个变量中：min_val 。

在找到列表中的最小值后，我们将在列表中调用index() 方法，并将min_val 作为其输入参数。执行后，index() 方法将返回列表中最小元素的索引。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
min_val = min(myList)
index = myList.index(min_val)
print("Index of minimum value is:", index)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Index of minimum value is: 3

这种方法只能在元素多次出现的情况下找到列表中最小元素的最左边的索引。如果你想获得最小元素的最右边的索引，你可以使用上一节中讨论的for循环和len() 函数的方法。

使用Numpy模块获取列表中最小元素的索引

numpy 模块被设计为以高效的方式处理数字和数组。我们也可以使用numpy 模块在 python 中找到列表中最小元素的索引。

numpy 模块为我们提供了argmin() 方法来查找 NumPy 数组中最小元素的索引。argmin() 方法，当在一个numpy 数组上调用时，返回数组中最小元素的索引。

为了使用argmin() 方法获得列表中最小元素的索引，我们将首先把列表转换成Numpy数组。为此，我们将使用array() 函数。

array() 函数将一个列表作为其输入参数并返回一个numpy数组。你可以在下面的例子中观察到这一点。

import numpy

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
array = numpy.array(myList)
print("The array is:", array)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
The array is: [11  2 23  1 32 12 44 34 55 46 21  1 12]

在将列表转换为numpy数组后，我们将对数组调用 argmin() 方法。执行后，argmin() 方法将返回最小元素的索引。

import numpy

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
array = numpy.array(myList)
min_index = array.argmin()
print("Index of minimum element is:", min_index)

输出结果。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Index of minimum element is: 3

当最小元素有多个出现时，argmin() 函数将返回最小元素的最左边的索引。在上面的例子中，你可以看到argmin() 方法返回3，即使最小元素1也存在于索引11处。

多次出现情况下列表中最小元素的索引

有时，我们可能需要在一个列表中找到所有最小元素的出现次数。在下面的章节中，我们将讨论在多处出现的情况下寻找列表中最小元素的索引的不同方法。

使用min()函数和For Loop查找列表中最小元素的索引

当最小元素在列表中出现多次时，我们可以使用min() 函数和for循环来获得最小元素的索引。为此，我们将使用以下步骤。

• 首先，我们将创建一个名为min_indices 的空列表来存储最小元素的索引。
• 然后，我们将使用len() 函数找到输入列表的长度。我们将把这个长度存储在一个变量list_len 。
• 获得列表的长度后，我们将使用range() 函数创建一个从0到list_len-1的数字序列。
• 接下来，我们将使用min() 函数找到列表中的最小元素。
• 在找到最小元素后，我们将使用for循环来迭代数字序列。迭代时，我们将检查列表中当前索引的元素是否等于最小元素。
  • 如果我们找到一个等于最小元素的元素，我们将使用append() 方法将其索引追加到min_indices 列表中。append() 方法，当在min_indices 列表上调用时，将把index 作为其输入参数。执行后，它将把index 作为一个元素加入到min_indices 列表中。
  • 如果当前索引的数字不等于最小的元素，我们将移动到下一个元素。

执行for循环后，我们将得到列表中最小元素的索引。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
min_val = min(myList)
list_indices = []
list_len = len(myList)
sequence = range(list_len)
for index in sequence:
    if myList[index] == min_val:
        list_indices.append(index)
print("Indices of minimum element are:", list_indices)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Indices of minimum element are: [3, 11]

使用min()函数和列表理解得到的列表中最小元素的索引

列表理解是通过对元素施加一些条件，利用现有列表中的元素创建一个新的列表。列表理解的一般语法如下。

new_list=[f(element) for element in existing_list if condition]

这里

• new_list 是执行语句后创建的列表。
• existing_list 是输入的列表。
• element 代表现有列表中的一个元素。这个变量用于遍历existing_list 。
• condition 是对元素施加的条件或 。f(element)

为了使用python中的列表理解法找到列表中最小元素的索引，我们将使用以下步骤。

• 首先，我们将使用len() 函数找到输入列表的长度。我们将把这个长度存储在一个变量中list_len 。
• 获得列表的长度后，我们将使用range() 函数创建一个从 0 到 list_len-1 的数字序列。
• 接下来，我们将使用min() 函数找到列表中的最小元素。
• 找到最小元素后，我们将使用列表理解来获得最小元素的索引列表。
• 在列表的理解中。
  • 我们将使用数字序列来代替existing_list 。
  • element 将代表数列中的元素。
  • f(element) 将等同于element 。
  • 取代condition ，我们将使用输入列表中索引元素的值应等于最小元素的条件。

执行该语句后，我们将得到new_list ，其中包含列表中最小元素的索引，如下所示。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
min_val = min(myList)
list_len = len(myList)
sequence = range(list_len)
new_list = [index for index in sequence if myList[index] == min_val]
print("Indices of minimum element are:", new_list)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Indices of minimum element are: [3, 11]

使用min()函数和enumerate()函数的列表中最小元素的索引

我们可以使用enumerate() 和min() 函数来查找列表中最小元素的索引，而不是使用 len() 函数和range() 函数。

Python 中的 enumerate() 函数

enumerate() 函数用于枚举一个容器对象的元素，如 list 或 tuple。

enumerate() 函数将一个容器对象如 list 作为其输入参数。执行后，它返回一个包含元组的枚举列表。列表中的每个元组包含两个元素。元组的第一个元素是分配给一个元素的索引。第二个元素是原始列表中的相应元素，它被作为输入给enumerate() 函数。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
enumerated_list = list(enumerate(myList))
print("Enumerated list is:", enumerated_list)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Enumerated list is: [(0, 11), (1, 2), (2, 23), (3, 1), (4, 32), (5, 12), (6, 44), (7, 34), (8, 55), (9, 46), (10, 21), (11, 1), (12, 12)]

为了使用enumerate() 函数找到列表中最小元素的索引，我们将使用以下步骤。

• 首先，我们将创建一个名为min_indices 的空列表来存储最小元素的索引。
• 之后，我们将使用min() 函数找到输入列表中的最小元素。
• 然后，我们将使用enumerate() 函数从输入列表中创建一个枚举列表。
• 获得枚举列表后，我们将使用for循环遍历枚举列表中的图元。
• 在迭代图元时，我们将检查当前图元中的元素是否等于最小元素。
• 如果当前元组中的元素等于最小元素，我们将使用append() 方法将当前索引追加到min_indices 。否则，我们将移动到枚举列表中的下一个元组。

执行for循环后，我们将得到min_indices 列表中最小元素的索引。你可以在下面的例子中观察到这一点。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
enumerated_list = list(enumerate(myList))
min_indices = []
min_element = min(myList)
for element_tuple in enumerated_list:
    index = element_tuple[0]
    element = element_tuple[1]
    if element == min_element:
        min_indices.append(index)
print("Indices of minimum element are:", min_indices)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Indices of minimum element are: [3, 11]

我们不用for循环来遍历枚举列表中的图元，而是用列表理解来找到列表中最小元素的索引，如下图所示。

myList = [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
print("The list is:", myList)
enumerated_list = list(enumerate(myList))
min_element = min(myList)
min_indices = [index for (index, element) in enumerated_list if element == min_element]
print("Indices of minimum element are:", min_indices)

输出。

The list is: [11, 2, 23, 1, 32, 12, 44, 34, 55, 46, 21, 1, 12]
Indices of minimum element are: [3, 11]

总结

在这篇文章中，我们讨论了在 python 中寻找列表中最小元素的索引的不同方法。我们还讨论了在最小元素多次出现的情况下寻找列表中所有最小元素的索引。

要在 python 中找到一个列表中最小元素的索引，我建议你使用min() 函数和 index() 方法。这种方法在有多个元素出现的情况下给出最小元素的最左边的索引。

如果你需要在 python 中找到列表中最小元素的最右边的索引，你可以使用 for 循环和 less than 或 equal to 操作符的方法。

在多次出现的情况下，如果你需要在python中获得一个列表中最小元素的所有索引，你可以使用for循环的方法或者使用enumerate() 函数的方法。两者的执行效率几乎相同。