Python 列表查找，如何在列表中查找项目或者元素索引

在本文中，你将学习如何在Python中查找列表中包含元素的索引。

有几种方法可以实现这一点，在本文中，你将学习三种不同的方式用于查找列表元素的索引
三种技巧如下：

• 使用 index() 方法查找索引；
• 使用 for-loop；
• 使用列表推导式和 enumerate() 函数

Python 列表是什么？

列表是Python中的内置数据类型，也是最强大的数据结构之一。
它可以充当容器，用于存储相同变量名下的多个(通常是相关的)项。
每一个元素都被放置在方括号 [] 内，方括号内的每一项都用 , 隔开。

#  'my_information' 列表变量，包含字符串和数字
my_information = ["John Doe", 34, "London", 1.76]

从上面的示例中，你可以看到列表能包含任何数据类型的项，这意味着列表元素可以是多样的。这与只存储相同类型的项的数组不同，列表具备更大的灵活性。
列表也是可变的，这意味着列表是动态的，列表项可以被更新，新项目可以添加到列表中，任何项都可以在程序的整个生命周期中随时删除。

Python索引概述

列表是项目（元素）的集合，它是一个有序的项目集合，并且在很大程度上保留了定义时的顺序。
列表中的每个元素都有一个唯一的位置来标识它，这个位置就是元素的索引。
Python和其它编程语言一样，索引都从0开始，而不是1。
让我们看一下前文中使用的列表。

my_information = ["John Doe", 34, "London", 1.76]

• 列表的索引为零，计数从0开始；
• 第一个列表元素 "John Doe" 的索引为0；
• 第二个列表元素 34 的索引为1；
• 第三个列表元素 "伦敦" 的索引为2；
• 第四个列表元素 1.76 的索引为3。

索引对于访问特定位置（索引）的元素非常有用，因此，可以通过使用列表元素的索引来获取列表的任意元素。
要访问某个元素，首先使用列表的名称，然后在方括号中使用要访问的元素的索引对应的整数，下面是使用索引访问每个元素的方法：

my_information = ["John Doe", 34, "London", 1.76]

print(my_information[0])
print(my_information[1])
print(my_information[2])
print(my_information[3])

# 输出

#John Doe
#34
#London
#1.76

那么，如何在Python列表中，查找元素的索引呢？

在接下来的部分中，你将看到一些查找列表元素索引的方法

在Python中使用 list 的 Index() 方法查找元素的索引

到目前为止，你已经了解了如何通过引用某个值的索引号来访问该值，但是，当你不知道索引号，而你正在处理一个大的列表时，会发生什么呢？

你可以给出一个值并找到它的索引，这样就可以检查它在列表中的位置，为此，Python内置了 index() 方法被用作搜索工具。 index() 方法的语法如下所示

my_list.index(item, start, end)

让我们来分析一下：

• my_list：正在搜索的列表的名称；
• .index() ：具备3个参数的搜索方法，一个参数是必需的，另外两个是可选的；
• item：必需的参数，它是待搜索其索引的元素；
• start：第一个可选参数，开始搜索的索引。
• end：第二个可选参数，结束搜索的索引。

让我们来看一个仅使用必须参数的示例：

programming_languages = ["JavaScript","Python","Java","C++"]

print(programming_languages.index("Python"))

# 输出
# 1

在上面的例子中， index() 方法只接受 1 个参数，这个参数就是要查找索引的元素，请记住，传递的参数是区分大小写的，这意味着如果你传递的是 "python" 而不是 "Python" ，你会收到一个错误，因为带有小写 "p" 的 "python" 不是列表的一部分。它的返回值是一个整数，这个整数就是传递值的索引。

让我们看另一个例子：

programming_languages = ["JavaScript","Python","Java","C++"]

print(programming_languages.index("React"))

# 输出
# line 3, in <module>
#    print(programming_languages.index("React"))
# ValueError: 'React' is not in list

如果你尝试搜索一个元素，但在正在搜索的列表中没有匹配元素，Python 将抛出一个错误作为返回值，该错误类型是 ValueError ，它表示列表中不存在正在搜索的元素。
防止这种情况发生的一种方法是将 index() 方法的调用放在 try/except 块中。
如果该值不存在，控制台将收到一条消息，表示该值未存储在列表中，因此不存在。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

try:
    print(programming_languages.index("React"))
except ValueError:
    print("That item does not exist")
    
#输出
#That item does not exist

另一种方法是在查找索引之前，先检查元素是否在列表中，输出将是一个布尔值： True 或 False 。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

print("React" in programming_languages)

#输出
#False

index() 方法中的可选参数

让我们来看看下面的例子：

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

print(programming_languages.index("Python"))

#output
#1

在列表类型的变量 programming_languages 中，有3个待搜索的“Python”字符串实例。
因为在本例中，列表元素数很少，所以有一种反向查找的测试方法，可以数一数，算出它们的索引号，然后像你在前面章节中看到的那样引用它们。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

print(programming_languages[1])
print(programming_languages[3])
print(programming_languages[5])

#output
#Python
#Python
#Python

一个在位置1，另一个在位置3，最后一个在位置5。
当使用 index() 方法时，为什么它们不显示在输出中？
使用 index() 方法时，返回值仅为列表中第1个出现的项，其余的不会返回， index() 方法只返回元素第1次出现的位置的索引。
可以尝试将可选的开始和结束参数传递给 index() 方法。

你已经知道，第一次出现从索引1开始，所以这可能是 start 参数的值，对于end参数，可以先找到列表的长度。
要查找长度，请使用 len() 函数。

print(len(programming_languages)) 

#output is 6

end 参数的值将是列表的长度减去1，列表中最后一项的索引总是比列表长度小一个，所以，把所有这些放在一起，下面是如何尝试获取该项的所有3个实例。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

print(programming_languages.index("Python",1,5))

#output
#1

输出仍然只返回第一个实例，尽管开始和结束参数为搜索提供了一系列位置，但使用 index() 方法时返回的值，仍然只是列表中第一个出现的元素。

如何获取列表中所有元素的索引

使用for循环获取列表中所有项目的索引。
让我们使用之前的事例，该列表中出现了三个字符串 “Python” 。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

首先，创建一个新的空列表，这将是存储“Python”所有索引的列表。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

python_indices = []

接下来，使用for循环。这是一种迭代（或循环）列表的方法，并获取原始列表中的每个元素，具体来说，我们循环每个元素的索引号。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

python_indices = []

for programming_language in range(len(programming_languages)):

首先使用for关键字，然后创建一个变量 programming_language ，它将在迭代过程中充当原始列表中每个元素位置的占位符。
接下来，需要指定for循环应该执行的迭代次数，在这种情况下，循环将从开始到结束遍历列表的整个长度。
语法 range(len(programming_languages)) 是访问列表 programming_languages 中所有元素的一种方式。

range() 函数接受一系列数字，这些数字指定开始计数和结束计数的数字。
len() 函数的作用是：计算列表的长度，因此在本例中，计数从0开始，列表的结尾结束。

最后，需要设置一个逻辑条件。
本质上，你的目标是：“如果在迭代过程中，给定位置的元素值等于 Python ，那么将该位置添加到我之前创建的新列表中。”。
使用 append() 方法将元素添加到列表中。

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

python_indices = []

for programming_language in range(len(programming_languages)):
    if programming_languages[programming_language] == "Python":
      python_indices.append(programming_language)

print(python_indices)

#output

#[1, 3, 5]

使用列表推导式和 enumerate() 函数获取列表中所有元素的索引

另一种方法是使用列表推导式来找到某个特定元素的所有索引，列表推导式是一种基于现有列表创建新列表的方法，下面是如何使用列表推导式获得字符串 Python 每次出现的所有索引：

programming_languages = ["JavaScript","Python","Java","Python","C++","Python"]

python_indices  = [index for (index, item) in enumerate(programming_languages) if item == "Python"]

print(python_indices)

#[1, 3, 5]

使用 enumerate() 函数，可以存储满足设置条件的元素的索引。
It first provides a pair (index, item) for each element in the list () that is passed as the argument to the function.
首先它会把列表（ programming_languages ）中的每一个键值对（ (index, item) ），作为参数传递到函数中。
index 表示列表项的索引号， item 表示列表项本身。

然后，它充当一个计数器，从0开始计数，并在每次满足设置的条件时递增，选择并移动符合条件的元素的索引。与列表推导式相结合，它将创建一个包含字符串“Python”的所有索引的新列表。

总结

就在这里！现在，你已经知道了在Python的列表中查找元素索引的一些方法，以及查找元素多次出现的索引的方法。
我希望你觉得这篇文章有用。
感谢阅读和愉快的编码！

一.创建列表

数据类型list，list是python内置的一种高级数据类型。list是一种有序的集合，基于链表实现 在python中应用很广泛

1.基于弱数据类型语言的定义

names=['james', 'michael', 'emma', 'emily']
print('names的数据类型：', type(names))#type（）函数是查看变量类型
print(names)

运行结果如下：

2.通过全局函数list()定义

ls2 = list([1, 2, 3, 4, 5])
print(ls2)

运行结果如下：

3.创建空列表

age=[]#直接创建空列表
print(age)
print(len(age))#len（）函数计算长度
ls1 = list()#通过list（）函数创建
print(ls1)

运行结果：

二.访问列表的值

1.通过下标索引

names = ['james', 'michael', 'emma', 'emily']
print(names[0])
print(names[-1])  #访问列表中的最后一个值
print(names[-2])#访问列表中的倒数第二个元素，反向索引
print(names[len(names)-2]) #效果如上

运行结果如下：

2.通过for循环遍历

names = ['james', 'michael', 'emma', 'emily']
for name in names:
    print(name)  

for i in range(len(names)):
    print(names[i])

运行结果：

3.通过while循环遍历

names = ['james', 'michael', 'emma', 'emily']
index = 0    #通过while循环来列出所有元素
while index < len(names):
    print(names[index])
    index += 1

运行结果如下：

三.列表的分片

a=['egg', 'fish', 'cake', 'tomato', 'james', 'ava', 'michael', 'emma', 'emily']
print(a[1:3]) #按下标0开始，不包括最右边的3
print(a[1:]) #1以及之后的全部
print(a[:3]) #3之前的但不包括3
print(a[:]) #所有
print(a[::2])#[start:end:step]start和end为空的时候，默认是全选，step为空时默认是1,这个表示的是从索引为0开始，以步长为2来选择元素
print(a[1:3:2])#以索引为1开始，索引3结束，步长为2来选择元素
print(a[::-1])#当step为-1时，将列表进行了逆序排序
print(a[::-2])#当步长为正数时，是从左到右以该步长来获取列表中的元素，当步长为负数时，是从右边到左以该步长的绝对值来获取的元素
print(a[0, 1, 3]) #不可以通过离散的索引值来获取

运行结果：

四.列表方法

1.append（）列表后面添加元素

food=['egg', 'fish', 'cake', 'tomato']
food.append('ice') #在list的末尾添加元素
print(food)

运行结果：

2.insert（）指定位置添加元素

food=['egg', 'fish', 'cake', 'tomato']
food.insert(1, 'meat') #在1这个位置添加元素
print(food)

运行结果：

3.pop()删除元素

food=['egg', 'fish', 'cake', 'tomato']
food.pop() #删除list末尾的元素
print(food)
food.pop(0) #删除索引0的元素
print(food)
food[0]='egg' #修改索引0的元素为egg
print(food)

运行结果：

4.count（）返回的是某个元素在列表里面的个数

list1 = [1, 3, 3, 4, 5]
print('count:', list1.count(3))#统计3在列表中出现的次数

运行结果：

5.extend() 合并列表

list1 = [1, 3, 3, 4, 5]
list2 = [6, 5, 8, 9]
list1.extend(list2) #在列表1后面添加列表2
print(list1)

运行结果：

6.index()返回的是元素在列表中的第一个位置

list2 = [1, 2, 4, 5, 7, 4]
print('index:', list2.index(4))  # 从列表中找出第一个数值为4的索引位置，不管第二个

运行结果：

7.remove（）---------- 删除某个元素，如果有重复，删除的是第一次出现的元素，如果元素不存在会报错

list2 = [1, 2, 4, 5, 7, 4]
list2.remove(4)#从列表中找出第一个数值为4的值然后删除，不管第二个
print('remove:', list2)

运行结果：

8.sort()进行排序（从小到大 int类型）可以对字母进行排序（ASCII值）类型不能混

list2 = [1, 2, 4, 5, 7, 4]
list2.sort()#对原列表进行排序
print('sort；', list2)

运行结果：

9.reverse（）将列表进行翻转

list2 = [1, 2, 4, 5, 7, 4]
list2.reverse()
print('reverse；', list2)

运行结果：

10.clear() 清除元素

list2 = [1, 2, 4, 5, 7, 4]
list2.clear()
print(list2)

运行结果：

11.copy() 浅拷贝对象 不等价与 =

list1 = [8, 9, 0]
list2 = list1.copy()
print(list2)

运行结果：

五.列表的操作

1.拼接列表

print('列表相加：', [1, 2, 3]+ [4, 5, 6]) #列表的操作符 + 相当于拼接列表
print('列表相加：', [1, 2, 3]+['a', 'b'])

运行结果：

2.列表相乘

print('列表相乘：', ['a', 'b']*3) #列表相乘

运行结果：

3.判断

print('判断列表元素是否存在于列表中：', 'a' in ['a', 'b'])
print('判断列表元素是否存在于列表中：', 'a' not in['a', 'b'])

运行结果：

六.列表中元素的类型的多样性

a_list=['lemon', 100, ['a', 'b', 'c', 'd'], True]#同一个list的类型可以是字符串，整型，布尔型（true和false），以及嵌套的list
print(a_list)
print(a_list[0])
print(a_list[2])
print(a_list[3])

运行结果：

b_list=['a', 'b', 'c', 'd']
a_list=['lemon', 100, b_list, True]
print(a_list)
item_b=a_list[2][1]#获取嵌套中列表中的单个元素可以用二维的索引获取，类似于二维数组。[2]表示获取a_list的第三个元素，即b_list，#[1]表示获取b_list的第二个元素，即’b‘
print(item_b)

运行结果：

七.列表推导式

new_list=[x for x in iterable]其中的iterable表示可迭代的对象，包括字符串（str）、列表（list）、元组（tuple）、字典（dict）、集合（set）生成器（generator）

str_list=[x.lower()for x in 'Lemon']#lower()将大写转为小写
print(str_list)

运行结果：

list_list=[x**2 for x in [1, 2, 3, 4]]
print(list_list)

运行结果：

tuple_list=[x+2 for x in (1, 2, 3, 4)]
print(tuple_list)

运行结果：

ge_list=[x for x in range(8)]
print(ge_list)

运行结果：

八.列表常用方法总结

1.append（）---------列表后面添加元素
2.insert（）---------向指定的下标处添加元素
3.pop()---------删除元素
4.count（）------返回的是某个元素在列表里面的个数
5.extend() -------合并列表
6.index()--------返回的是元素在列表中的第一个位置
7.remove（）---------- 删除某个元素，如果有重复，删除的是第一次出现的元素，如果元素不存在会报错
8.sort()-------进行排序（从小到大 int类型）可以对字母进行排序（ASCII值）类型不能混
9.reverse（）-------将列表进行翻转
10.clear() -------清除元素
11.copy()----- 浅拷贝对象 不等价与 =

python列表，python键盘输入列表,列表：　　列表的功能

列表：

列表的功能十分强大，它不同于元组和字符串，列表的内容是可变的。本次将介绍一些序列中没有而列表中有的方法。

1、元素赋值

赋值语句是最简单的改变列表的方式，如a=1就是一种改变列表的方式。我们可以通过编号标记某个特定位置的元素，并对该位置的元素重新赋值，如：a=[1,2,3,4,5]print(a)a[1]=5print(a)

那么是否可以赋不同类型的值呢？让我们尝试一下，输入：a=[1,2,3,4,5]print(a)a[1]=‘he‘print(a)

结果是可行的。通过上面的尝试，我们得知，可以对一个列表中的元素赋予不同类型的值。上述列表a中既有int型，也有str型元素。当对列表赋值时使用的编号超过列表最大编号，程序报错：

由此可知，不能给一个不存在的元素赋值。

2、增加元素

一旦初始化了一个列表，我们就不能再往这个列表中增加元素了。若需要往列表中增加元素，则需要将整个列表中的元素都复制一遍，再添加需要增加的元素。python为我们提供了对应的方法append()来解决这个问题。append()方法是一个用于在列表末尾添加新对象的方法。具体语法为：list.append(obj)#其中list为列表，obj为需要添加到列表末尾的对象

append()不是简单地返回修改后的新列表，而是直接修改原来的列表。如：a=[1,2,3,4,5]a.append(0) #在列表a后添加‘0’print(a)a.append(‘aa‘) #在列表a后添加‘aa’print(a)

3、删除元素

Python为我们提供了三种删除元素的方法：

（1）使用del语句删除列表元素

这种方法适用于知道所需要删除的元素在列表中的位置，即知道该元素在列表中的编号。如：a=[1,2,3,4,5]del a[2]print(a)

（2）使用方法pop()删除列表元素

当我们不知道待删除元素的编号，或是删除后还需要用该值时，可以选择这个方法。pop()可以删除列表末尾的元素，删除后的值仍可以打印出来。如：a=[‘1‘,‘2‘,‘3‘]b=a.pop()print(a)print(b)

（3）使用方法remove()删除指定值的元素

当我们只知道待删除元素的值，而不知道其在列表中的位置时，可以使用remove()方法。如：a=[1,2,3,4,5,6]a.remove(1)print(a)

需要注意的是，remove()方法只会删除列表中第一个指定的值，若列表中存在多个相同的值需要删除，需要使用循环语句操作。如：a=[1,4,1,2,1,3,1]a.remove(1)print(a)

a=[1,4,1,2,1,3,1]b=a.count(1)for i in range(b): a.remove(1)print(a)

4、分片赋值

分片赋值我们需要用到一个新函数——list()函数，list()函数可以直接将字符串转换为列表。分片赋值可以使用与原序列不等长的序列将序列分片替换。如：a=list(‘hie‘)print(a)a[1:]=list(‘ello‘)print(a)

分片赋值还可以在不替换任何原有元素的情况下在任意位置插入新元素。a=list(‘h!‘)print(a)a[1:1]=list(‘ello‘)print(a)

同理，分片赋值也支持对序列中任意位置的元素进行删除的操作。a=list(‘hello!‘)print(a)a[1:5]=[]print(a)

列表方法：

方法是与对象有紧密联系的函数，对象可能是列表、数字，也可能是字符串或其他类型的对象。方法的调用语句如下：

对象.方法(参数)

方法的定义方式是将对象放到方法名之前，两者之间用 ‘.’ 隔开，方法后面的括号可以根据需要带上参数。

1、count()

count()方法用于统计某个元素在列表中 出现的次数，方法语句如下：list.count(obj)

示例如下：a=list(‘hello‘)print("列表中字母l的个数：",a.count(‘l‘))

2、extend()

extend()方法用于在列表末尾 一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

示例如下：a=[‘hello‘,‘world‘]b=[‘a‘,‘b‘]a.extend(b)print(a)

3、index()

index()方法用于从列表中找出某个值第一个匹配项的索引位置。

示例如下：a=[‘hello‘,‘world‘]print(‘hello的索引位置为：‘,a.index(‘hello‘))print(‘world的索引位置为：‘,a.index(‘world‘))

4、insert()

insert()方法用于从列表中找出某个值第一个匹配项的索引位置。方法语句如下：list.insert(index,obj)#list代表列表，index代表对象obj需要插入的索引位置，obj代表要插入列表中的对象。

示例如下：a=[1,2,3]print(‘插入前：‘,a)a.insert(2,2.5)print(‘插入后：‘,a)

5、reverse()

reverse()方法用于反向列表中的元素。

示例如下：a=[1,2,3]print(‘反转前：‘,a)a.reverse()print(‘反转后：‘,a)

6、sort()

sort()方法用于对原列表进行排序，如果指定参数，就使用参数指定的比较方法进行排序。

示例如下：a=[5,4,2,6,9,3,0,7]print(‘调用sort()方法前：‘,a)a.sort()print(‘调用sort()方法后：‘,a)

python列表