For word in list python

В этой статье мы разберем, работу цикла for в Python.

Мы начнем с пары основных примеров и их синтаксиса. Далее обсудим, когда может быть полезен блок else, связанный с циклом for. Затем мы разберем итерактивные объекты (iterable), итераторы (iterator) и протокол итератора. Также узнаем, как создавать собственные итераторы и итерируемые объекты. После этого мы обсудим, как цикл for реализован с использованием итерактивных объектов и итераторов. Потом мы рассмотрим реализацию логики цикла for, используя цикл while и используя протокол итератора.
И наконец, для тех, кому интересно, мы разберем простой цикл for и пройдемся по инструкциям, которые интерпретатор Python выполняет при выполнении цикла for. Это должно помочь понять, что именно происходит внутри, во время работы цикла for.

Оператор for является одним из двух операторов, используемых для создания циклов в Python, другим является оператор while. Если вы совсем не знакомы с итерациями в Python, то рекомендуем почитать статью Итерации в Python: операторы for, while, break и continue которая будет хорошей отправной точкой для изучения циклов и итераций.

Простой цикл for

Давайте начнем с простого цикла for, который перебирает список строк и печатает каждую строку.

>>> for word in ["You", "are", "awesome!"]:
...   print(word)
...
You
are
awesome!

Как видите, цикл перебирает все слова в списке и печатает их. То есть на каждом шаге цикла переменной word присваивается элемент списка, а затем выполняется кодовый блок. Поскольку список – это упорядоченная последовательность элементов, цикл проходит по ним в том же порядке.

Цикл for с условием else

>>> for word in ["You", "are", "awesome!"]:
...   print(word)
... else:
...   print("See you later!")
...
You
are
awesome!
See you later!

Когда полезно условие else?

Как вы могли заметить, блок else выполняется после завершения цикла for. Так какой смысл использовать блок else? Разве не будет выполнен следующий набор операторов после цикла for?

Ну, во многих случаях у нас возникают ситуации, когда нам нужно выйти из цикла for, когда выполняется определенное условие. И если это условие никогда не выполняется, но нам все равно нужно выполнить набор операторов. Для этого мы обычно используем логический флаг. Давайте посмотрим на пример.

def search(search_list, search_item):
  found_item = False

  for word in search_list:
    if word == search_item:
      found_item = True
      print("Found word '{}'".format(search_item))
      break

  if not found_item:
    print("Word '{}' was not found!".format(search_item))

Использование:

>>> search(["You", "are", "awesome!"], "are")
Found word 'are'
>>> search(["You", "are", "awesome!"], "we")
Word 'we' was not found!

С помощью блока else мы можем избежать использования логического флага found_item. Давайте посмотрим, как мы можем переписать вышеуказанный метод с помощью else. Обратите внимание, что блок else будет пропущен, если в цикле for встречается оператор break.

def search(search_list, search_item):
  for word in search_list:
    if word == search_item:
      print("Found word '{}'".format(search_item))
      break
  else:
    print("Word '{}' was not found!".format(search_item))

Таким образом, блок else действительно полезен, только если у нас есть оператор break в цикле for, и нам нужно, чтобы выполнился набор операторов, если условие break никогда не выполнялось.

В противном случае операторы, связанные с else, просто выполняются в конце цикла for. Вы увидите это, когда мы разберем байт-код в последнем разделе этой статьи.

Синтаксис цикла for

Теперь, когда мы рассмотрели несколько основных примеров, давайте завершим этот раздел синтаксисом цикла for.

for <element> in <iterable>:
    <set_of_statements_1>
else:
    <set_of_statements_2>

По сути, для каждого итерируемого элемента выполняется set_of_statements_1. Как только все элементы исчерпаны, управление переходит к блоку else и выполняется set_of_statements_2.

Обратите внимание, что предложение else является необязательным. Если блок else отсутствует, цикл завершается после того, как все элементы будут пройдены, и управление переходит к следующему оператору программы.

Итерируемые объекты (iterables) и итераторы (iterators)

Итерируемые объекты

В предыдущем разделе мы использовали термин «iterables» для обозначения объекта, который итерировался циклом for. Теперь давайте попробуем понять, что такое итерируемый объект в Python.

В Python итерируемый объект – это любой объект, который можно использовать в итерации с использованием цикла for. Это означает, что объект должен возвращать итератор при передаче в метод iter(). Давайте посмотрим примеры некоторых часто используемых встроенных итерируемых объектов в Python.

>>> iter("You are awesome!") # String
<str_iterator object at 0x1041ad2e8>
>>> iter(["You", "are", "awesome!"]) # List
<list_iterator object at 0x1041ad358>
>>> iter(("You", "are", "awesome!")) # Tuple
<tuple_iterator object at 0x1041ad390>
>>> iter({"You", "are", "awesome!"}) # Set
<set_iterator object at 0x1041ac678>
>>> iter({1: "You", 2: "are", 3: "awesome!"}) # Dictionary
<dict_keyiterator object at 0x10400df48>
>>> iter(range(3)) # Range function
<range_iterator object at 0x1041a1450>

Как вы можете видеть, когда мы вызываем iter() для итерируемого объекта, он возвращает объект итератора.

Итераторы

А что такое итератор? В Python итератор определяется как объект, представляющий поток данных. По сути, если мы передаем итератор во встроенный метод next(), он должен вернуть следующее значение из связанного потока данных. Когда все элементы исчерпаны, должно появиться исключение StopIteration. Он должен продолжать вызывать исключение StopIteration для любых последующих вызовов метода next().

Примеры итератора со списком.

>>> my_list = ["You", "are", "awesome!"]
>>>
>>> # Get the iterator.
... list_iterator = iter(my_list)
>>>
>>> # Get next element of iterator.
... next(list_iterator)
'You'
>>> next(list_iterator)
'are'
>>> next(list_iterator)
'awesome!'
>>> next(list_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> next(list_iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Итераторы тоже итеративные объекты! Но..

Следует помнить одну интересную вещь: итераторы сами по себе также поддерживают (обязаны поддерживать согласно протоколу итератора) метод iter(). Это означает, что мы можем вызвать метод iter() для итератора и получить сам объект итератора.

>>> my_list = ["You", "are", "awesome!"]
>>> list_iterator = iter(my_list)
>>> list_iterator
<list_iterator object at 0x1099a6320>
>>> iterator_of_iterator = iter(list_iterator)
>>> iterator_of_iterator
<list_iterator object at 0x1099a6320>

Таким образом, мы можем использовать итераторы везде, где ожидается итерация, например, в цикле for.

Однако обратите внимание, что вызов iter() для объекта-контейнера, такого как list, каждый раз будет возвращать новый итератор. Но вызов iter() для итератора просто возвращает тот же объект.

>>> my_list = [1, 2]
>>> iter(my_list)
<list_iterator object at 0x1099a62b0>
>>> iter(my_list) # This gives a fresh iterator object
<list_iterator object at 0x1099a62e8>

>>> my_list = [1, 2]
>>> list_iter = iter(my_list)
>>> list_iter
<list_iterator object at 0x1099a62b0>
>>> iter(list_iter) # This returns the same iterator object
<list_iterator object at 0x1099a62b0>
>>> iter(list_iter) # This returns the same iterator object
<list_iterator object at 0x1099a62b0>

Итерация по списку дважды

Обратите внимание, что это работает так, как мы ожидали.

>>> my_list = ["You are Awesome!"]
>>>
>>> for word in my_list:
...   print(word)
...
You are Awesome!
>>> for word in my_list:
...   print(word)
...
You are Awesome!

Итерация через list_iterator дважды

Обратите внимание, что итератор будет исчерпан в первом цикле, а во второй раз мы просто видим пустой контейнер.

>>> my_list = ["You are Awesome!"]
>>> list_iterator = iter(my_list)
>>>
>>> for word in list_iterator:
...   print(word)
...
You are Awesome!
>>>
>>> for word in list_iterator:
...   print(word)
...
>>>

Протокол итератора

В предыдущем разделе мы увидели, что:

1. Итерируемый объект при передаче в функцию iter() возвращает итератор.
2. Итератор,
   1. при передаче в функцию next() возвращает следующий элемент или вызывает StopIteration после того, как все элементы будут исчерпаны.
   2. при передаче функции iter() возвращает себя.

Протокол итератора – это не что иное, как стандартный способ определения объектов как итераторов. Мы уже видели протокол в действии в предыдущем разделе. Согласно протоколу, итераторы должны определить следующие два метода:

1. __next()__
   • Этот метод должен возвращать следующий элемент серии каждый раз, когда он вызывается. Как только все элементы исчерпаны, должно появиться исключение StopIteration.
   • Этот метод вызывается изнутри, когда мы вызываем встроенный метод next().
2. __iter()__
   • Этот метод должен возвращать сам объект итератора.
   • Это метод, который вызывается внутри, когда мы вызываем встроенный метод iter().

Создание своего собственного итератора

Теперь, когда мы рассмотрели, как работает протокол итераторов, мы можем создавать свой собственный итератор. Давайте посмотрим на простой пример, где мы создаем наш собственный класс Range, который генерирует числа в данном диапазоне с заданным шагом.

class Range:
  def __init__(self, start, stop, step):
    self.next = start
    self.stop = stop
    self.step = step

  def __next__(self):
    if self.next > self.stop:
      raise StopIteration
    next_item = self.next
    self.next += self.step
    return next_item

  def __iter__(self):
    return self

Теперь посмотрим, как он работает с циклом for.

>>> for num in Range(1, 10, 2):
...   print(num)
...
1
3
5
7
9

Обратите внимание, что экземпляр Range является как итерируемым объектом, так и итератором.

Создание своего собственного итерируемого объекта

Все, что для этого нужно, это возвращать новый итератор всякий раз, когда вызывается метод __iter__() , т. е. в этом случае он должен возвращать новый экземпляр Range.

class RangeIterable:
  def __init__(self, start, stop, step):
    self.start = start
    self.stop = stop
    self.step = step

  def __iter__(self):
    return Range(self.start, self.stop, self.step)

Давайте теперь используем наш RangeIterable с циклом for.

>>> for num in RangeIterable(1, 10, 2):
...   print(num)
...
1
3
5
7
9

Как работает цикл for?

Теперь, когда мы поняли, что такое итератор и итерируемый объект, мы можем глубже понять, как на самом деле работает цикл for.

Давайте снова посмотрим на наш предыдущий пример.

>>> for word in ["You", "are", "awesome!"]:
...   print(word)
... else:
...   print("See you later!")
...
You
are
awesome!
See you later!

Когда мы выполняем вышеуказанный блок кода, происходит следующее:

1. Оператор for внутри себя вызывает iter() для списка [«You», «are», «awesome!»]. Это приводит к получению итератора.
2. Затем вызывается next() для итератора, и возвращаемое им значение присваивается переменной цикла, в данном случае word.
3. После этого выполняется блок оператора, связанный с циклом for. В этом случае print(word).
4. Шаги 2 и 3 повторяются до тех пор, пока next() не вызовет StopIteration.
5. Как только next() вызывает StopIteration, управление переходит к предложению else, если оно присутствует, и выполняется блок операторов, связанных с else.

Примечание. Если в блоке кода, связанном с циклом for, встречается оператор break, то блок else пропускается.

Реализация логики цикла for с помощью оператора while

Мы могли бы реализовать вышеуказанную логику, используя оператор while следующим образом.

my_list = ["You", "are", "awesome!"]
list_iter = iter(my_list)
while True:
  try:
    word = next(list_iter)
    print(word)
  except StopIteration:
    print("See you later!")
    break

Цикл while ведет себя точно так же, как наш цикл for, и выдает следующий результат.

You
are
awesome!
See you later!

Разбор цикла for

В этом разделе мы разберем цикл for и пройдемся по инструкциям, которые интерпретатор исполняет при выполнении цикла for. Мы будем использовать модуль dis для разборки цикла for. Чтобы быть точным, мы будем использовать метод dis.dis, чтобы получить удобочитаемое представление дизассемблированного байт-кода.

Мы будем использовать тот же простой цикл for, который мы рассматривали до сих пор. Запишем следующий цикл for в файл for_loop.py.

for word in ["You", "are", "awesome!"]:
  print(word)
else:
  print("See you later!")

Теперь мы можем получить читаемую форму байт-кода, вызвав dis.dismethod. Запустим следующую команду в терминале.

$ python3 -m dis for_loop.py
  1           0 SETUP_LOOP              28 (to 30)
              2 LOAD_CONST               0 (('You', 'are', 'awesome!'))
              4 GET_ITER
        >>    6 FOR_ITER                12 (to 20)
              8 STORE_NAME               0 (word)

  2          10 LOAD_NAME                1 (print)
             12 LOAD_NAME                0 (word)
             14 CALL_FUNCTION            1
             16 POP_TOP
             18 JUMP_ABSOLUTE            6
        >>   20 POP_BLOCK

  4          22 LOAD_NAME                1 (print)
             24 LOAD_CONST               1 ('See you later!')
             26 CALL_FUNCTION            1
             28 POP_TOP
        >>   30 LOAD_CONST               2 (None)
             32 RETURN_VALUE

Каждый из столбцов в разобранном виде представляет следующее:

1. Колонка 1: номер строки кода.
2. Колонка 2: знак «>>», если инструкция является целью перехода.
3. Колонка 3: смещение байт кода в байтах.
4. Колонка 4: инструкция байт-кода.
5. Колонка 5: аргументы инструкции. В скобках отображается более понятный для человека имя аргументов.

Теперь давайте шаг за шагом пройдемся по нашему разобранному байт-коду и попытаемся понять, что на самом деле происходит.
В этом описание термин TOS означает вершина стека (top of the stack)

1. строка 1, “for word in [“You”, “are”, “awesome!”]:” переводится как:
   • 0 SETUP_LOOP 28 (to 30)
     • Этот оператор помещает блок для цикла for в стек. Блок занимает от этой инструкции до 28 байт, то есть до «30»
     • Это означает, что если в цикле for есть оператор break, управление переместится на «30» байт. Обратите внимание, блок else, будет пропущен если встретится оператор break.
   • 2 LOAD_CONST 0 ((‘You’, ‘are’, ‘awesome!’))
     • Затем список помещается на вершину стека (TOS).
   • 4 GET_ITER
     • Эта инструкция выполняет «TOS = iter (TOS)». Это означает, что итератор получается из списка, который на данный момент является TOS, а затем итератор переносится в TOS.
   • 6 FOR_ITER 12 (to 20)
     • Эта инструкция получает TOS, который на данный момент является нашим итератором, и вызывает для него метод next().
     • Если next() возвращает значение, оно помещается в стек, и будет выполнена следующая инструкция «8 STORE_NAME».
     • Как только функция next() указывает, что итератор исчерпан (т. к. сработал StopItered), TOS (а именно итератор) будет извлечен из стека, а счетчик байтового кода будет увеличен на 12. Это означает, что элемент управления перейдет к инструкция «20 POP_BLOCK».
   • 8 STORE_NAME 0 (word)
     • Эта инструкция преобразуется в word = TOS, то есть значение, возвращаемое функцией next(), будет присвоено переменной word.
2. строка 2, “print(word)” переводится как:
   • 10 LOAD_NAME 1 (print)
     • Эта команда помещает команду print в стек.
   • 12 LOAD_NAME 0 (word)
     • Это команда перемещает аргумент print, то есть word в стек.
   • 14 CALL_FUNCTION 1
     • Это команда вызывает функцию с позиционными аргументами.
     • Аргументы, связанные с функцией, будут присутствовать в TOS, как мы видели в предыдущей инструкции. Все аргументы выталкиваются до тех пор, пока не получит вызываемый объект, то есть print.
     • Как только он получает вызываемый объект, он вызывается путем передачи ему всех аргументов.
     • Как только вызов выполнен, его возвращаемое значение будет передано в TOS. В текущий момент это будет None.
   • 16 POP_TOP
     • TOS, то есть возвращаемое значение из функции удаляется (выталкивается) из стека.
   • 18 JUMP_ABSOLUTE 6
     • Счетчик байт-кода теперь установлен на «6». Это означает, что следующая выполняемая инструкция будет «6 FOR_ITER». Вот так цикл проходит по элементам итератора.
     • Обратите внимание, что инструкция «6 FOR_ITER» заставит программу выйти из этого цикла и перейти к «20 POP_BLOCK», как только все элементы итератора будут исчерпаны.
   • 20 POP_BLOCK
     • POP_BLOCK приведет к удалению блока, установленного в «0 SETUP_LOOP», из стека блоков.
3. Обратите внимание, что номер строки 3, т.е., else, не имеет каких-либо конкретных инструкций, связанных с этим. Управление программой естественным образом переходит к следующей инструкции, которая в основном состоит из операторов, связанных с else.
4. строка 4, “print(“See you later!”)” переводится как:
   • 22 LOAD_NAME 1 (print)
     • Вызываемый объект, связанный с print, помещается в стек.
   • 24 LOAD_CONST 1 (‘See you later!’)
     • Аргументы для вызываемого объекта помещаются в стек.
   • 26 CALL_FUNCTION 1
     • Аргументы для print и команда print извлекаются из стека. Затем выполняется вызываемая функция, и ее возвращаемое значение передается в TOS.
   • 28 POP_TOP
     • TOS, то есть возвращаемое значение функции (в данном случае None) удаляется из стека.
5. Следующие две инструкции в основном загружают возвращаемое значение нашего скрипта (None) в стек и возвращают его.
   • 30 LOAD_CONST 2 (None)
   • 32 RETURN_VALUE

Вув! Итак, мы закончили с разборкой инструкций для цикла for. Я надеюсь, что это поможет немного лучше понять работу цикла for.

Заключение

В этом посте мы рассмотрели следующее:

1. Как написать цикл for в Python?
2. Как использовать else, связанное с циклом for?
3. Что такое итераторы и итерируемые объекты?
4. Что такое протокол итератора?
5. Как создать итератор и итерируемый объект?
6. Как работает цикл for?
7. Как используя цикл while имитировать цикл for?
8. Как разобрать цикл for с помощью модуля dis и увидеть понятные человеку инструкции, выполняемые интерпретатором Python? Как читать и понимать разобранные инструкции?

Оригинальная статья Shyama Sankar Understanding for-loops in Python

Цикл for в Python – это итеративная функция. Если у вас есть объект последовательности, например список, вы можете использовать цикл for для перебора элементов, содержащихся в списке.

Функциональность цикла for не сильно отличается от того, что вы видите во многих других языках программирования.

Базовый синтаксис

Мы можем использовать цикл for для перебора списка, кортежа или строк. Синтаксис:

for itarator_variable in sequence_name:
	Statements
	. . .
	Statements

Как вывести отдельные буквы строки?

Строка Python – это последовательность символов. Мы можем использовать цикл for для перебора символов и их печати.

word="anaconda"
for letter in word:
	print (letter)

Вывод:

a
n
a
c
o
n
d
a

Список и кортеж – повторяемые объекты. Мы можем использовать цикл для перебора их элементов.

words= ["Apple", "Banana", "Car", "Dolphin" ]
for word in words:
	print (word)

Вывод:

Apple
Banana
Car
Dolphin

Давайте посмотрим на пример, чтобы найти сумму чисел в кортеже:

nums = (1, 2, 3, 4)

sum_nums = 0

for num in nums:
    sum_nums = sum_nums + num

print(f'Sum of numbers is {sum_nums}')

# Output
# Sum of numbers is 10

Вложенный цикл

Когда у нас есть цикл for внутри другого цикла for, он называется вложенным циклом for. В следующем коде показаны вложенные циклы:

words= ["Apple", "Banana", "Car", "Dolphin" ]
for word in words:
        #This loop is fetching word from the list
        print ("The following lines will print each letters of "+word)
        for letter in word:
                #This loop is fetching letter for the word
                print (letter)
        print("") #This print is used to print a blank line

Вывод

Использование с функцией range()

Python range() – одна из встроенных функций. Она используется с циклом for для выполнения блока кода определенное количество раз.

for x in range(3):
    print("Printing:", x)
	
# Output

# Printing: 0
# Printing: 1
# Printing: 2

Мы также можем указать параметры запуска, остановки и шага для функции диапазона.

for n in range(1, 10, 3):
    print("Printing with step:", n)
	
# Output

# Printing with step: 1
# Printing with step: 4
# Printing with step: 7

Оператор break

Оператор break используется для преждевременного выхода из цикла for. Он используется для прерывания цикла при выполнении определенного условия.

Допустим, у нас есть список чисел, и мы хотим проверить, присутствует ли число. Мы можем перебрать список чисел и, если число найдено, выйти из цикла, потому что нам не нужно продолжать перебирать оставшиеся элементы.

В этом случае мы будем использовать условие if else.

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

n = 2

found = False
for num in nums:
    if n == num:
        found = True
        break

print(f'List contains {n}: {found}')

# Output
# List contains 2: True

Оператор continue

Мы можем использовать операторы continue внутри цикла, чтобы пропустить выполнение тела цикла for для определенного условия.

Допустим, у нас есть список чисел, и мы хотим вывести сумму положительных чисел. Мы можем использовать операторы continue, чтобы пропустить цикл для отрицательных чисел.

nums = [1, 2, -3, 4, -5, 6]

sum_positives = 0

for num in nums:
    if num < 0:
        continue
    sum_positives += num

print(f'Sum of Positive Numbers: {sum_positives}')

С (необязательным) блоком else

Блок else выполняется только в том случае, если цикл не завершается оператором break.

Допустим, у нас есть функция для вывода суммы чисел, когда все числа четные. Мы можем использовать оператор break, чтобы завершить цикл for, если присутствует нечетное число. Мы можем вывести сумму в части else, чтобы она выводилась, когда цикл выполняется нормально.

def print_sum_even_nums(even_nums):
    total = 0

    for x in even_nums:
        if x % 2 != 0:
            break

        total += x
    else:
        print("For loop executed normally")
        print(f'Sum of numbers {total}')


# this will print the sum
print_sum_even_nums([2, 4, 6, 8])

# this won't print the sum because of an odd number in the sequence
print_sum_even_nums([2, 4, 5, 8])

# Output

# For loop executed normally
# Sum of numbers 20

( 3 оценки, среднее 5 из 5 )

In Python, finding a specific word or element within a list is a familiar task developers often search for. This tutorial will teach us four effective methods to find a word in a list.

Method 1: Using the ‘in’ Keyword

We can use the in keyword to find a word in a list. The in keyword is a membership operator that returns True if the word is present in the list and False if it is not. 

Find a word in a list

For example, let’s say you have a list called «my_list» that contains the following elements:

my_list = ["java", "python", "jquery", "php"]

And you want to find the python word in this list.

# Define a list of items
my_list = ["java", "python", "jquery", "php"]

# Check if the word "python" is present in the list
if "python" in my_list:
    # If "python" is present, print this message
    print("The word 'python' is present in the list.")
else:
    # If "python" is not present, print this message
    print("The word 'python' is not present in the list.")

Output:

The word 'python' is present in the list.

As you can see, the program finds the word python in the my_list and returns The word ‘python’ is present in the list.

Find multi-words in a list

To find multi-words in the list, we need to set another list that contains words to find.

# Define a list of words
my_list = ["java", "python", "jquery", "php"]

# Define a list of words to find
words_to_find = ["python","php"]

# Iterate through words_to_find
for word in words_to_find:
    
  # Check if word is present in my_list
  if word in my_list:
    # If word is present, print this message
    print(f"'{word}' is present in the list")
    
  else:
    # If word is not present, print this message
    print(f"'{word}' is not present in the list")

Output:

'python' is present in the list
'php' is present in the list

In the above code we:

1. defined a list called my_list which contains the elements «java», «python», «jquery», and «php».
2. defined another list called words_to_find which contains the elements to find.
3. used a for loop to iterate through the words_to_find list.
4. used the in keyword to check if the word is present in the my_list.

Method 2: Using the index() method

By using the index() method, we can find a word in a list. However, this method returns the index of the first occurrence of the specified word in the list.

Here is the syntax of the index()

list_or_tuple.index(item, start, end)

• item is the item that you want to find the index of.
• start (optional) parameter the starting index from where the search should begin.
• end (optional) the ending index where the search should end.

In our situation, we will use the item parameter. In the following example, we’ll find the word python.

# List
my_list = ["java", "python", "jquery", "php"]

# finds the index of "python" in the list
index = my_list.index("python")

# prints the index of "python" in the list
print("The word 'python' is present at index", index)

Output:

The word 'python' is present at index 1

As we can see, the program found the word python in my_list and returned the index of the word. As we know, every list starts with an index of 0

The index() method is more powerful than the in keyword because it provides the index of the word in the list. If the word is not present will raise a ValueError, as in the following example.

# List
my_list = ["java", "python", "jquery", "php"]

# finds the index of "ruby" in the list
index = my_list.index("ruby")

# prints result
print("The word 'python' is present at index", index)

Output:

ValueError: 'ruby' is not in list

So you will need to add a try-except syntax to handle this case. Let’s see how we can do that.

try:
    # List
    my_list = ["java", "python", "jquery", "php"]
    
    # finds the index of "ruby" in the list
    index = my_list.index("ruby")
    
    # prints result
    print("The word 'ruby' is present at index", index)
    
except:
    print("The word 'ruby' is not present at list")

Output:

The word 'ruby' is not present at list

Method 3: Using the count() method

The count() is a method to count a specific word in a list. But it can also be used to check if a word is present in the list.

Here is count() syntax:

list.count(element)

Now, let’s see an example:

# List
my_list = ["java", "python", "jquery", "php"]

# Word to Find
word_to_find = "python"

# Count word in the list
count = my_list.count(word_to_find)

# IF Count returns greater than 1
if count:
    print(f"word {word_to_find} is in my_list")
    
else:
    print(f"word {word_to_find} is not in my_list")

Output:

word python is in my_list

Our code above counts the number of occurrences of word_to_find in the my_list. The word is found in the list if the count is greater than 0.

Further, you can also use the count to find multiple words in a list. Let us see an example.

# List
my_list = ["java", "python", "jquery", "php"]

# Word to Find
list_to_find = ["python", "php"]

for w in list_to_find:
    
    # Count word in the list
    count = my_list.count(w)
    
    # IF Count return more than 1
    if count:
        print(f"word {w} is in my_list")
        
    else:
        print(f"word {w} is not in my_list")

Output:

word python is in my_list
word php is in my_list

From the above example, you can see that we have set another list of words to find and iterate over it.

Method 4: Using List Comprehension

The last method of this tutorial is List Comprehension. List comprehension is a concise way of creating a new list in Python. It consists of an expression followed by a for clause, and zero or more if clauses.

Let us see how we can use it to find a word in a list with the help of an example.

my_list = ["java", "python", "jquery", "php"]

# word to find in the list
word_to_find = "php"

# using list comprehension to find all indexes of word_to_find
result = [i for i, x in enumerate(my_list) if x == word_to_find]

# print the result
print("The word 'php' appears at indexes:", result)

Output:

The word 'python' appears at indexes: [3]

This method finds the word in the list and gives you the index of that word because we use the enumerate() built function to add a counter to an iterable.

Conclusion

All right, In this article, we have discussed four different methods for finding a word in a list in Python. We have also discussed how to find multiple words.

Each method has its advantages and disadvantages. And the best way for a particular situation will depend on the specific requirements of the task. 

Finally, I hope this article helps you find your response.
Happy Coding

1. Use the for Loop to Find Elements From a List That Contain a Specific Substring in Python
2. Use the filter() Function to Find Elements From a Python List Which Contain a Specific Substring
3. Use the Regular Expressions to Find Elements From a Python List Which Contain a Specific Substring

This tutorial will introduce how to find elements from a Python list that have a specific substring in them.

We will work with the following list and extract strings that have ack in them.

my_list = ['Jack', 'Mack', 'Jay', 'Mark']

Use the for Loop to Find Elements From a List That Contain a Specific Substring in Python

In this method, we iterate through the list and check whether the substring is present in a particular element or not. If the substring is present in the element, then we store it in the string. The following code shows how:

str_match = [s for s in my_list if "ack" in s]
print(str_match)

Output:

The in keyword checks whether the given string, "ack" in this example, is present in the string or not. It can also be replaced by the __contains__ method, which is a magic method of the string class. For example:

str_match = [s for s in my_list if s.__contains__("ack")]
print(str_match)

Output:

Use the filter() Function to Find Elements From a Python List Which Contain a Specific Substring

The filter() function retrieves a subset of the data from a given object with the help of a function. This method will use the lambda keyword to define the condition for filtering data. The lambda keyword creates a one-line lambda function in Python. See the following code snippet.

str_match = list(filter(lambda x: 'ack' in x, my_list))
print(str_match)

Output:

Use the Regular Expressions to Find Elements From a Python List Which Contain a Specific Substring

A regular expression is a sequence of characters that can act as a matching pattern to search for elements. To use regular expressions, we have to import the re module. In this method, we will use the for loop and the re.search() method, which is used to return an element that matches a specific pattern. The following code will explain how:

import re
pattern=re.compile(r'ack') 
str_match = [x for x in my_list if re.search('ack', x)]
print(str_match)

Output: