Как найти элемент списка по индексу python

Given two lists with elements and indices, write a Python program to find elements of list 1 at indices present in list 2. 

Examples:

Input : lst1 = [10, 20, 30, 40, 50]
        lst2 = [0, 2, 4]
Output : [10, 30, 50]
Explanation: 
Output elements at indices 0, 2 and 4 i.e 10, 30 and 50 respectively. 

Input : lst1 = ['Hello', 'geeks', 'for', 'geeks']
        lst2 = [1, 2, 3]
Output : ['geeks', 'for', 'geeks']

Below are some Pythonic approaches to do the above task. 

Approach #1 : Naive(List comprehension) The first approach to find the desired elements is to use list comprehension. We traverse through ‘lst2’ and for each i^th element, we output lst1[i]. 

Time complexity: O(n), where n is the length of lst2
Auxiliary space: O(m), where m is the length of the returned list.

Approach #2 : Using Python map() We can also use Python map() method where we apply lst1.__getitem__ function on lst2 which return lst1[i] for each element ‘i’ of lst2. 

Time complexity: O(n), where n is the length of lst2.
Auxiliary space: O(m), where m is the length of lst2.

Approach #3 : Using itemgetter() 

Time complexity: O(m), where m is the length of the lst2 list. 
Auxiliary space: O(m+k), where k is the length of the returned list. 

Approach #4: Using numpy 

The time complexity of this program is O(n), where n is the length of lst2. 

The space complexity of this program is O(n), where n is the length of lst2.

Approach #6: Using a dictionary

This approach involves creating a dictionary that maps the indices in lst2 to their corresponding elements in lst1. Then, we can uselist comprehension to extract the values from the dictionary.

In this code, we first create a dictionary called index_map that maps the indices of lst1 to their corresponding elements. Then, we use a list comprehension to extract the values from index_map for the indices in lst2. Finally, we return the list of extracted values as the result.

Time complexity: O(n)
Auxiliary space: O(n)

Method#7: Using Recursive method.

Algorithm:

1. Define a function findElements that takes in two lists lst1 and lst2, and an index idx (optional, default=0) and a list res (optional, default=[]).
2. If idx is equal to the length of lst2, return res (base case).
3. Get the element at the index lst2[idx] in lst1 and append it to res.
4. Recursively call findElements with the updated idx (idx+1) and res.
5. Return the final value of res after all recursive calls have finished.

Time Complexity: O(n), where n is the length of lst2. We visit each element of lst2 exactly once, and the time taken to get the element at each index in lst1 is constant time. So the time complexity is proportional to the length of the input list lst2.

Auxiliary Space: O(n), where n is the length of lst2. This is because we need to store the list of elements in res, which can have a maximum length of n if all indices in lst2 are valid. Additionally, the recursive calls use up memory on the call stack, which can go up to a depth of n if all indices in lst2 are valid.

Last Updated :
18 Mar, 2023

Like Article

Save Article

Here’s the Pythonic way to do it:

data = [['a','b'], ['a','c'], ['b','d']]
search = 'c'
any(e[1] == search for e in data)

Or… well, I’m not going to claim this is the “one true Pythonic way” to do it because at some point it becomes a little subjective what is Pythonic and what isn’t, or which method is more Pythonic than another. But using any() is definitely more typical Python style than a for loop as in e.g. RichieHindle’s answer,

Of course there is a hidden loop in the implementation of any, although it breaks out of the loop as soon as it finds a match.

Since I was bored I made a timing script to compare performance of the different suggestions, modifying some of them as necessary to make the API the same. Now, we should bear in mind that fastest is not always best, and being fast is definitely not the same thing as being Pythonic. That being said, the results are… strange. Apparently for loops are very fast, which is not what I expected, so I’d take these with a grain of salt without understanding why they’ve come out the way they do.

Anyway, when I used the list defined in the question with three sublists of two elements each, from fastest to slowest I get these results:

1. RichieHindle’s answer with the for loop, clocking in at 0.22 μs
2. Terence Honles’ first suggestion which creates a list, at 0.36 μs
3. Pierre-Luc Bedard’s answer (last code block), at 0.43 μs
4. Essentially tied between Markus’s answer and the for loop from the original question, at 0.48 μs
5. Coady’s answer using operator.itemgetter(), at 0.53 μs
6. Close enough to count as a tie between Alex Martelli’s answer with ifilter() and Anon’s answer, at 0.67 μs (Alex’s is consistently about half a microsecond faster)
7. Another close-enough tie between jojo’s answer, mine, Brandon E Taylor’s (which is identical to mine), and Terence Honles’ second suggestion using any(), all coming in at 0.81-0.82 μs
8. And then user27221’s answer using nested list comprehensions, at 0.95 μs

Obviously the actual timings are not meaningful on anyone else’s hardware, but the differences between them should give some idea of how close the different methods are.

When I use a longer list, things change a bit. I started with the list in the question, with three sublists, and appended another 197 sublists, for a total of 200 sublists each of length two. Using this longer list, here are the results:

1. RichieHindle’s answer, at the same 0.22 μs as with the shorter list
2. Coady’s answer using operator.itemgetter(), again at 0.53 μs
3. Terence Honles’ first suggestion which creates a list, at 0.36 μs
4. Another virtual tie between Alex Martelli’s answer with ifilter() and Anon’s answer, at 0.67 μs
5. Again a close-enough tie between my answer, Brandon E Taylor’s identical method, and Terence Honles’ second suggestion using any(), all coming in at 0.81-0.82 μs

Those are the ones that keep their original timing when the list is extended. The rest, which don’t, are

1. The for loop from the original question, at 1.24 μs
2. Terence Honles’ first suggestion which creates a list, at 7.49 μs
3. Pierre-Luc Bedard’s answer (last code block), at 8.12 μs
4. Markus’s answer, at 10.27 μs
5. jojo’s answer, at 19.87 μs
6. And finally user27221’s answer using nested list comprehensions, at 60.59 μs

Существует несколько способов проверки наличия элемента в списке в Python:

1. Использование метода index() для поиска индекса элемента в списке.
2. Использование оператора in для проверки наличия элемента в списке.
3. Использование метода count() для подсчета количества вхождений элемента.
4. Использование функции any().
5. Функция filter() создает новый список элементов на основе условий.
6. Применение цикла for.

Способ 1: Использование метода index()

Чтобы найти элемент в списке Python, вы можете использовать метод list index(). Список index() — это встроенный метод, который ищет элемент в списке и возвращает его индекс.

Если один и тот же элемент присутствует более одного раза, метод возвращает индекс первого вхождения элемента.

Индекс в Python начинается с 0, а не с 1. Таким образом, через индекс мы можем найти позицию элемента в списке.

Выход

Метод list.index() принимает единственный аргумент, элемент, и возвращает его позицию в списке.

Способ 2: Использование «оператора in»

Используйте оператор in, чтобы проверить, есть ли элемент в списке.

Выход

Вы можете видеть, что элемент «19» находится в списке. Вот почему оператор in возвращает True.

Если вы проверите элемент «50», то оператор in вернет False и выполнит оператор else.

Способ 3: Использование функции count()

Метод list.count() возвращает количество вхождений данного элемента в списке.

Синтаксис

Метод count() принимает единственный элемент аргумента: элемент, который будет подсчитан.

Пример

Выход

Мы подсчитываем элемент «21», используя список в этой функции example.count(), и если он больше 0, это означает, что элемент существует; в противном случае это не так.

Способ 4: использование понимания списка с any()

Any() — это встроенная функция Python, которая возвращает True, если какой-либо элемент в итерируемом объекте имеет значение True. В противном случае возвращается False.

Выход

Вы можете видеть, что в списке нет «22». Таким образом, нахождение «22» в списке вернет False функцией any(). Если функция any() возвращает True, элемент в списке существует.

Способ 5: Использование метода filter()

Метод filter() перебирает элементы списка, применяя функцию к каждому из них.

Функция filter() возвращает итератор, который перебирает элементы, когда функция возвращает значение True.

Выход

В этом примере мы используем функцию filter(), которая принимает функцию и перечисляет ее в качестве аргумента.

Мы использовали лямбда-функцию, чтобы проверить, совпадает ли входной элемент с любым элементом из списка, и если это так, он вернет итератор. Чтобы преобразовать итератор в список в Python, используйте функцию list().

Мы использовали функцию list() для преобразования итератора, возвращаемого функцией filter(), в список.

Способ 6: Использование цикла for

Вы можете узнать, находится ли элемент в списке, используя цикл for в Python.

Выход

В этом примере мы прошли список элемент за элементом, используя цикл for, и если элемент списка совпадает с входным элементом, он напечатает «Element exists».

Введение

В ходе статьи рассмотрим 5 способов поиска элемента в списке Python.

Поиск методом count

Метод count() возвращает вхождение указанного элемента в последовательность. Создадим список разных цветов, чтобы в нём производить поиск:

colors = ['black', 'yellow', 'grey', 'brown']

Зададим условие, что если в списке colors присутствует элемент ‘yellow’, то в консоль будет выведено сообщение, что элемент присутствует. Если же условие не сработало, то сработает else, и будет выведена надпись, что элемента отсутствует в списке:

colors = ['black', 'yellow', 'grey', 'brown']

if colors.count('yellow'):
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск при помощи цикла for

Создадим цикл, в котором будем перебирать элементы из списка colors. Внутри цикла зададим условие, что если во время итерации color приняла значение ‘yellow’, то элемент присутствует:

colors = ['black', 'yellow', 'grey', 'brown']

for color in colors:
    if color == 'yellow':
         print('Элемент присутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск с использованием оператора in

Оператор in предназначен для проверки наличия элемента в последовательности, и возвращает либо True, либо False.

Зададим условие, в котором если ‘yellow’ присутствует в списке, то выводится соответствующее сообщение:

colors = ['black', 'yellow', 'grey', 'brown']

if 'yellow' in colors:
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

В одну строку

Также можно найти элемент в списке при помощи оператора in всего в одну строку:

colors = ['black', 'yellow', 'grey', 'brown']

print('Элемент присутствует в списке!') if 'yellow' in colors else print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Или можно ещё вот так:

colors = ['black', 'yellow', 'grey', 'brown']

if 'yellow' in colors: print('Элемент присутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск с помощью лямбда функции

В переменную filtering будет сохранён итоговый результат. Обернём результат в список (list()), т.к. метода filter() возвращает объект filter. Отфильтруем все элементы списка, и оставим только искомый, если он конечно присутствует:

colors = ['black', 'yellow', 'grey', 'brown']

filtering = list(filter(lambda x: 'yellow' in x, colors))

Итак, если искомый элемент находился в списке, то он сохранился в переменную filtering. Создадим условие, что если переменная filtering не пустая, то выведем сообщение о присутствии элемента в списке. Иначе – отсутствии:

colors = ['black', 'yellow', 'grey', 'brown']

filtering = list(filter(lambda x: 'yellow' in x, colors))

if filtering:
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Поиск с помощью функции any()

Функция any принимает в качестве аргумента итерабельный объект, и возвращает True, если хотя бы один элемент равен True, иначе будет возвращено False.

Создадим условие, что если функция any() вернёт True, то элемент присутствует:

colors = ['black', 'yellow', 'grey', 'brown']

if any(color in 'yellow' for color in colors):
    print('Элемент присутствует в списке!')
else:
    print('Элемент отсутствует в списке!')

# Вывод: Элемент присутствует в списке!

Внутри функции any() при помощи цикла производится проверка присутствия элемента в списке.

Заключение

В ходе статьи мы с Вами разобрали целых 5 способов поиска элемента в списке Python. Надеюсь Вам понравилась статья, желаю удачи и успехов! 🙂

a = [1, 2, 3]

print(a)

>>> [1, 2, 3]

b = ['cat', 123, True]

print(b)

>>> ['cat', 123, True]

c = [1, 2, [3, 4]]

print(c)

>>> [1, 2, [3, 4]]

a = [1, 2, 3]

print(a[1])

>>> 2

a = [1, 2, 3, 4]

a[0] # Обратится к 1
a[2] # Обратится к 3
a[3] # Обратится к 4
a[4] # Выведет ошибку

a = [1, 2, 3, 4]

a[0:2] # Получим [1, 2]

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

a[1:6:2] # Получим [2, 4]

a = [1, 2, 3]
a[1] = 4

print(a)
 
>>> [1, 4, 3]

a = [1, 2]
b = a
a[0] = 5

print(a)
print(b)

>> [5, 2]
>> [5, 2]

a = [1, 2]
b = [3, 4]
с = a + b

print(с)

>>> [1, 2, 3, 4]

a = [1, 2, 3]
d1, d2, d3 = a

print(d1)
print(d2)
print(d3)

>>> 1
>>> 2
>>> 3

animals = ['cat', 'dog', 'bat']
for animal in animals:
  print(animal)

>>> cat
>>> dog
>>> bat

animals = ['cat', 'dog', 'bat']
i = 0
while i < len(animals):
  print(animals[i])
  i += 1

>>> cat
>>> dog
>>> bat

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)

>>> True

a = [1, 2, 3]
b = a
print(a is b)

>>> True

a = [5, 3, 1]
len(a) # 3

a = [8, 1, 3, 2]
sorted(a) # [1, 2, 3, 8]

a = [1, 9, -2, 3]
min(a) # -2
max(a) # 9

a = [1, 2, 3]
a.append(4)
print(a) 

>>> [1, 2, 3, 4]

a = [1, 2, 3]
a.insert(0, 4)
print(a)

>>> [4, 1, 2, 3]

a = [1, 2, 3]
a.extend([4, 5])
print(a) 

>>> [1, 2, 3, 4, 5]

a = ['cat', 'dog', 'bat']
a.extend('mouse')
print(a)

>>> ['cat', 'dog', 'bat', 'm', 'o', 'u', 's', 'e']

a = [1, 2, 3, 1]
a.remove(1)
print(a) 

>>> [2, 3, 1]

a = [1, 2, 3, 1]
a.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

a = [1, 2, 3]
a.clear()
print(a) 

>>> []

a = [1, 2, 3]
print(a.index(2)) 

>>> 1

a = [1, 2, 3]
print(a.index(4))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 4 is not in list

a = [1, 2, 3]
print(a.pop())
print(a)

>>> 3
>>> [1, 2]

a = [1, 2, 3]
print(a.pop(1)) 
print(a) 

>>> 2
>>> [1, 3]

a = [1, 1, 1, 2]
print(a.count(1)) 

>>> 3

a = [4, 1, 5, 2]
a.sort() # [1, 2, 4, 5]

a = [4, 1, 5, 2]
a.sort(reverse=True) # [5, 4, 2, 1]

a = [1, 3, 2, 4]
a.reverse() # [4, 2, 3, 1]

a = [1, 2, 3]
b = a.copy()

print(b)

>>> [1, 2, 3]

Научитесь: Профессия Python-разработчик
Узнать больше