Как найти порядковый номер числа в python

Список

Список — это непрерывная динамическая коллекция элементов. Каждому элементу списка присваивается порядковый номер — его индекс. Первый индекс равен нулю, второй — единице и так далее. Основные операции для работы со списками — это индексирование, срезы, добавление и удаление элементов, а также проверка на наличие элемента в последовательности.

Создание пустого списка выглядит так:

Создадим список, состоящий из нескольких чисел:

numbers = [ 40 , 20 , 90 , 11 , 5 ]

Настало время строковых переменных:

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]

Не будем забывать и о дробях:

fractions = [ 3.14 , 2.72 , 1.41 , 1.73 , 17.9 ]

Мы можем создать список, состоящий из различных типов данных:

values = [ 3.14 , 10 , ‘Hello world!’ , False, ‘Python is the best’ ]

И такое возможно (⊙_⊙)

list_of_lists = [[ 2 , 4 , 0 ], [ 11 , 2 , 10 ], [ 0 , 19 , 27 ]]

Индексирование

Что же такое индексирование? Это загадочное слово обозначает операцию обращения к элементу по его порядковому номеру ( ( ･ω･)ア напоминаю, что нумерация начинается с нуля). Проиллюстрируем это на примере:

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ 0 ])
print (fruits[ 1 ])
print (fruits[ 4 ])

Списки в Python являются изме­няемым типом данных. Мы можем изменять содер­жимое каждой из ячеек:

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
fruits[ 0 ] = ‘Watermelon’
fruits[ 3 ] = ‘Lemon’
print (fruits)

>>> [ ‘Watermelon’ , ‘Grape’ , ‘Peach’ , ‘Lemon’ , ‘Orange’ ]

Индексирование работает и в обратную сторону. Как такое возможно? Всё просто, мы обра­щаемся к элементу списка по отрица­тельному индексу. Индекс с номе­ром -1 дает нам доступ к после­днему элементу, -2 к предпоследнему и так далее.

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ -1 ])
print (fruits[ -2 ])
print (fruits[ -3 ])
print (fruits[ -4 ])

Создание списка с помощью list()

Переходим к способам создания списка. Самый простой из них был приведен выше. Еще раз для закрепления:

А есть еще способы? Да, есть. Один из них — создание списка с помощью функции list() В неё мы можем передать любой итерируемый объект (да-да, тот самый по которому можно запустить цикл (• ᵕ •) )

Рассмотрим несколько примеров:

letters = list ( ‘abcdef’ )
numbers = list ( range ( 10 ))
even_numbers = list ( range ( 0 , 10 , 2 ))
print (letters)
print (numbers)
print (even_numbers)

>>> [ ‘a’ , ‘b’ , ‘c’ , ‘d’ , ‘e’ , ‘f’
>>> [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
>>> [ 0 , 2 , 4 , 6 , 8 ]

Длина списка

С созданием списка вроде ра­зобрались. Следующий вопрос: как узнать длину списка? Можно, конечно, просто посчитать количество элементов. (⊙_⊙) Но есть способ получше! Функция len() возвращает длину любой итерируемой переменной, переменной, по которой можно запустить цикл. Рассмотрим пример:

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print ( len (fruits))

numbers = [ 40 , 20 , 90 ]
print ( len (numbers))

«. любой итерируемой», а это значит:

string = ‘Hello world’
print ( len (string))
# 11

print ( len ( range ( 10 ))

Срезы

В начале статьи что-то гово­рилось о «срезах». Давайте разберем подробнее, что это такое. Срезом называется неко­торая подпос­ледователь­ность. Принцип действия срезов очень прост: мы «отре­заем» кусок от исходной последова­тель­ности элемента, не меняя её при этом. Я сказал «последо­вательность», а не «спи­сок», потому что срезы работают и с другими итерируемыми типами данных, например, со строками.

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
part_of_fruits = fruits[ 0 :3]
print (part_of_fruits)

>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ ]

Детально рассмотрим синтаксис срезов:

итерируемая_переменная[начальный_индекс:конечный_индекс — 1 :длина_шага]

Обращаю ваше внимание, что мы делаем срез от начального индекса до конечного индекса — 1. То есть i = начальный_индекс и i = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[ 0 :1])
# Если начальный индекс равен 0, то его можно опустить
print (fruits[: 2 ])
print (fruits[: 3 ])
print (fruits[: 4 ])
print (fruits[: 5 ])
# Если конечный индекс равен длине списка, то его тоже можно опустить
print (fruits[: len (fruits)])
print (fruits[::])

>>> [ ‘Apple’ ]
>>> [ ‘Apple’ , ‘Grape’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]

Самое время понять, что делает третий параметр среза — длина шага!

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
print (fruits[:: 2 ])
print (fruits[:: 3 ])
# Длина шага тоже может быть отрицательной!
print (fruits[:: -1 ])
print (fruits[ 4 :2: -1 ])
print (fruits[ 3 :1: -1 ])

>>> [ ‘Apple’ , ‘Peach’ , ‘Orange’ ]
>>> [ ‘Apple’ , ‘Banan’ ]
>>> [ ‘Orange’ , ‘Banan’ , ‘Peach’ , ‘Grape’ , ‘Apple’ ]
>>> [ ‘Orange’ , ‘Banan’ ]
>>> [ ‘Banan’ , ‘Peach’ ]

А теперь вспоминаем всё, что мы знаем о циклах. В Python их целых два! Цикл for и цикл while Нас интересует цикл for, с его помощью мы можем перебирать зна­чения и индексы наших последовательностей. Начнем с перебора значений:

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
f or fruit in fruits:
print (fruit, end = ‘ ‘ )

>>> Apple Grape Peach Banan Orange

Выглядит несложно, правда? В переменную fruit объявлен­ную в цикле по очереди записываются значения всех элементов списка fruits

А что там с перебором индексов?

f or index in range ( len (fruits)):
print (fruits[index], end = ‘ ‘ )

Этот пример гораздо интереснее предыдущего! Что же здесь происходит? Для начала разбе­ремся, что делает функция range(len(fruits))

Мы с вами знаем, что функция len() возвращает длину списка, а range() генерирует диапазон целых чисел от 0 до len()-1.

Сложив 2+2, мы получим, что переменная index принимает значения в диапазоне от 0 до len()-1. Идем дальше, fruits[index] — это обращение по индексу к элементу с индексом index списка fruits. А так как переменная index принимает значения всех индексов списка fruits, то в цикле мы переберем значения всех элементов нашего списка!

Операция in

С помощью in мы можем проверить наличие элемента в списке, строке и любой другой итерируемой переменной.

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
if ‘Apple’ in fruits:
print ( ‘В списке есть элемент Apple’ )

>>> В списке есть элемент Apple

fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
if ‘Lemon’ in fruits:
print ( ‘В списке есть элемент Lemon’ )
else :’
print ( ‘В списке НЕТ элемента Lemon’ )

>>> В списке НЕТ элемента Lemon

Приведу более сложный пример:

all_fruits = [ ‘Apple’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Orange’ ]
my_favorite_fruits = [ ‘Apple’ , ‘Banan’ , ‘Orange’ ]
f or item in all_fruits:
if item in my_favorite_fruits:
print (item + ‘ is my favorite fruit’ )
else :
print ( ‘I do not like ‘ + item)

>>> Apple is my favorite fruit
>>> I do not like Grape
>>> I do not like Peach
>>> Banan is my favorite fruit
>>> Orange is my favorite fruit

Методы для работы со списками

Начнем с метода append(), который добавляет элемент в конец списка:

# Создаем список, состоящий из четных чисел от 0 до 8 включительно
numbers = list ( range ( 0 ,10, 2 ))
# Добавляем число 200 в конец списка
numbers. append ( 200 )
numbers. append ( 1 )
numbers. append ( 2 )
numbers. append ( 3 )
print (numbers)

>>> [ 0 , 2 , 4 , 6 , 8 , 200 , 1 , 2 , 3 ]

Мы можем передавать методу append() абсолютно любые значения:

all_types = [ 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. append ( 1024 )
all_types. append ( ‘Hello world!’ )
all_types. append ([ 1 , 2 , 3 ])
print (all_types)

>>> [ 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ], 1024 , ‘Hello world!’ , [ 1 , 2 , 3 ]]

Метод append() отлично выпол­няет свою функцию. Но, что делать, если нам нужно добавить элемент в сере­дину списка? Это умеет метод insert(). Он добавляет элемент в список на произ­вольную позицию. insert() принимает в качестве первого аргу­мента позицию, на которую нужно вставить элемент, а вторым — сам элемент.

# Создадим список чисел от 0 до 9
numbers = list ( range ( 10 ))
# Добавление элемента 999 на позицию с индексом 0
numbers. insert ( 0 , 999 )
print (numbers) # первый print
numbers. insert ( 2 , 1024 )
print (numbers) # второй print
numbers. insert ( 5 , ‘Засланная строка-шпион’ )
print (numbers) # третий print

>>> [ 999 , 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # первый print
>>> [ 999 , 0 , 1024 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # второй print
>>> [ 999 , 0 , 1024 , 1 , 2 , ‘Засланная строка-шпион’ , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # третий print

Отлично! Добавлять элементы в список мы научи­лись, осталось понять, как их из него удалять. Метод pop() удаляет эле­мент из списка по его индексу:

numbers = list ( range ( 10 ))
print (numbers) # 1
# Удаляем первый элемент
numbers. pop ( 0 )
print (numbers) # 2
numbers. pop ( 0 )
print (numbers) # 3
numbers. pop ( 2 )
print (numbers) # 4
# Чтобы удалить последний элемент, вызовем метод pop без аргументов
numbers. pop ()
print (numbers) # 5
numbers. pop ()
print (numbers) # 6

>>> [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 1
>>> [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 2
>>> [ 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] # 3
>>> [ 2 , 3 , 5 , 6 , 7 , 8 , 9 ] # 4
>>> [ 2 , 3 , 5 , 6 , 7 , 8 ] # 5
>>> [ 2 , 3 , 5 , 6 , 7 ] # 6

Теперь мы знаем, как удалять элемент из списка по его инде­ксу. Но что, если мы не знаем индекса элемента, но знаем его значение? Для такого случая у нас есть метод remove(), кото­рый удаляет пер­вый найденный по значению элемент в списке.

all_types = [ 10 , ‘Python’ , 10 , 3.14 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]]
all_types. remove ( 3.14 )
print (all_types) # 1
all_types. remove ( 10 )
print (all_types) # 2
all_types. remove ( ‘Python’ )
print (all_types) # 3

>>> [ 10 , ‘Python’ , 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 1
>>> [ ‘Python’ , 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 2
>>> [ 10 , ‘Python’ , [ ‘I’ , ‘am’ , ‘list’ ]] # 3

А сейчас немного посчитаем, посчитаем эле­менты списка с помощью метода count()

numbers = [ 100 , 100 , 100 , 200 , 200 , 500 , 500 , 500 , 500 , 500 , 999 ]
print (numbers. count ( 100 )) # 1
print (numbers. count ( 200 )) # 2
print (numbers. count ( 500 )) # 3
print (numbers. count ( 999 )) # 4

В программировании, как и в жизни, проще работать с упоря­доченными дан­ными, в них легче ори­енти­ро­ваться и что-либо искать. Метод sort() сорти­рует список по воз­раста­нию значений его элементов.

numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. sort ()
print (numbers) # 1
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits) # 2

>>> [ 2 , 3 , 9 , 11 , 78 , 100 , 567 , 1024 ] # 1
>>> [ ‘Apple’ , ‘Banan’ , ‘Grape’ , ‘Orange’ , ‘Peach’ ] # 2

Мы можем изменять порядок сортировки с помощью пара­метра reverse. По умол­чанию этот параметр равен False

fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. sort ()
print (fruits) # 1
fruits. sort (reverse = True)
print (fruits) # 2

>>> [ ‘Apple’ , ‘Banan’ , ‘Grape’ , ‘Orange’ , ‘Peach’ ] # 1
>>> [ ‘Peach’ , ‘Orange’ , ‘Grape’ , ‘Banan’ , ‘Apple’ ] # 2

Иногда нам нужно перевернуть список, не спраши­вайте меня зачем. Для этого в самом лучшем языке прог­рам­миро­вания на этой планете JavaScr..­Python есть метод reverse():

numbers = [ 100 , 2 , 11 , 9 , 3 , 1024 , 567 , 78 ]
numbers. reverse ()
print (numbers) # 1
fruits = [ ‘Orange’ , ‘Grape’ , ‘Peach’ , ‘Banan’ , ‘Apple’ ]
fruits. reverse ()
print (fruits) # 2

>>> [ 78 , 567 , 1024 , 3 , 9 , 11 , 2 , 100 ] # 1
>>> [ ‘Apple’ , ‘Banan’ , ‘Peach’ , ‘Grape’ , ‘Orange’ ] # 2

Допустим, у нас есть два списка и нам нужно их объединить. Програм­мисты на C++ cразу же кинулись писать циклы for, но мы пишем на python, а в python у спис­ков есть полез­ный метод extend(). Этот метод вызы­вается для одного списка, а в качестве аргу­мента ему пере­дается другой список, extend() запи­сывает в конец первого из них начало вто­рого:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. extend (vegetables)
print (fruits)

>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]

В природе существует специ­аль­ный метод для очистки списка — clear()

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
vegetables = [ ‘Tomato’ , ‘Cucumber’ , ‘Potato’ , ‘Carrot’ ]
fruits. clear ()
vegetables. clear ()
print (fruits)
print (vegetables)

Осталось совсем чуть-чуть всего лишь пара мето­дов, так что делаем последний рывок! Метод index() возв­ращает индекс эле­мента. Рабо­тает это так: вы пере­даете в качестве аргу­мента в index() значение элемента, а метод возв­ращает его индекс:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
print (fruits. index ( ‘Apple’ ))
print (fruits. index ( ‘Banana’ ))
print (fruits. index ( ‘Grape’ ))

Финишная прямая! Метод copy(), только не падайте, копирует список и возвра­щает его брата-близнеца. Вообще, копи­ро­вание списков — это тема доста­точно инте­ресная, давай­те рас­смотрим её по-подробнее.

Во-первых, если мы просто прис­воим уже сущест­вующий список новой пере­менной, то на первый взгляд всё выглядит неплохо:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
print (fruits)
print (new_fruits)

>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]

Но есть одно маленькое «НО»:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits
fruits. pop ()
print (fruits)
print (new_fruits)

# Внезапно, из списка new_fruits исчез последний элемент
>>> [ ‘Banana’ , ‘Apple’ ]
>>> [ ‘Banana’ , ‘Apple’ ]

При прямом присваивании спис­ков копи­рования не проис­ходит. Обе пере­менные начи­нают ссылаться на один и тот же список! То есть если мы изме­ним один из них, то изме­нится и другой. Что же тогда делать? Пользоваться методом copy(), конечно:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]
new_fruits = fruits. copy ()
fruits. pop ()
print (fruits)
print (new_fruits)

>>> [ ‘Banana’ , ‘Apple’ ]
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ ]

Отлично! Но что если у нас список в списке? Скопируется ли внутренний список с помощью метода copy() — нет:

fruits = [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ , ‘Peach’ ]]
new_fruits = fruits. copy ()
fruits[ -1 ]. pop ()
print (fruits) # 1
print (new_fruits) # 2

>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ ]] # 1
>>> [ ‘Banana’ , ‘Apple’ , ‘Grape’ , [ ‘Orange’ ]] # 2

Решение задач

1. Создайте список из 10 четных чисел и выведите его с помощью цикла for

2. Создайте список из 5 элементов. Сделайте срез от второго индекса до четвертого

3. Создайте пустой список и добавьте в него 10 случайных чисел и выведите их. В данной задаче нужно использовать функцию randint.

from random import randint
n = randint ( 1 , 10 ) # Случайное число от 1 до 10

4. Удалите все элементы из списка, созданного в задании 3

5. Создайте список из введенной пользователем строки и удалите из него символы ‘a’, ‘e’, ‘o’

6. Даны два списка, удалите все элементы первого списка из второго

a = [ 1 , 3 , 4 , 5 ]
b = [ 4 , 5 , 6 , 7 ]
# Вывод
>>> [ 6 , 7 ]

7. Создайте список из случайных чисел и найдите наибольший элемент в нем.

8. Найдите наименьший элемент в списке из задания 7

9. Найдите сумму элементов списка из задания 7

10. Найдите среднее арифметическое элементов списка из задания 7

Сложные задачи

1. Создайте список из случайных чисел. Найдите номер его последнего локального максимума (локальный максимум — это элемент, который больше любого из своих соседей).

2. Создайте список из случайных чисел. Найдите максимальное количество его одинаковых элементов.

3. Создайте список из случайных чисел. Найдите второй максимум.

a = [ 1 , 2 , 3 ] # Первый максимум == 3, второй == 2

4. Создайте список из случайных чисел. Найдите количество различных элементов в нем.

Как узнать порядковый номер всех конкретных чисел в списке в Python

Теперь я пытаюсь найти номера индексов всех чисел в списке, которые выше 25. Затем я хочу составить список этих индексных чисел.

Теперь проблема состоит в том, что он регистрирует некоторые номера индексов дважды. Например: мы видим первое число выше 25: 28.6. Это число имеет номер индекса 1. Если мы посмотрим дальше, мы снова увидим 28.6, это должно иметь индекс номер 14. Вместо этого он снова получил номер индекса 1.

Найти индекс всех вхождений элемента в списке Python

В этом посте будет обсуждаться, как найти индекс всех вхождений элемента в списке Python.

1. Использование enumerate() функция

Чтобы получить индекс всех вхождений элемента в список, вы можете использовать встроенную функцию enumerate() . Он был введен для решения задачи счетчика циклов и может использоваться следующим образом:

Чтобы получить список всех индексов сразу, используйте понимание списка с функцией перечисления:

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

В качестве альтернативы вы можете использовать range() функция, чтобы получить список всех допустимых индексов, а затем сопоставить соответствующее значение, присутствующее в каждом индексе, с данным элементом.

3. Использование itertools модуль

Другой подход заключается в использовании count() функционировать в itertools , который создает итератор для эффективного цикла, чтобы возвращать равномерно распределенные значения, начиная с заданного числа. Вы можете использовать его с zip() для добавления порядковых номеров следующим образом.

Как найти порядковый номер числа в python

В предыдущем уроке мы научились составлять интерактивный сценарий с вложенными блоками if-else-elif – перейти в урок 28.
В сегодняшнем уроке мы познакомимся с циклом for и списками, узнаем, что это такое и составим несколько таких списков.

Что такое списки?

В Питоне для хранения различных данных можно использовать списки.

Вот пример такого списка:

Список начинается с квадратной скобки, в котором идут перечисления элементов списка в кавычках через запятую, и закрывается также квадратной скобкой. Если элементы списка будут состоять из русских слов, вам также необходимо предварять каждое слово буквой u . Числа можно перечислять без кавычек.

Списки можно присваивать переменным.

Мы можем вывести на экран какой-то элемент из списка. Для этого надо указать его индекс (то есть порядковый номер в списке).

Запомните: индекс элементов списка начинается всегда с 0. То есть в списке ochki первое число 5 имеет индекс 0, второе число 6 — индекс 1, третье число 7 индекс 2 и т.д. Для простоты запоминания: третье число минус 1 равно 2 — это и есть индекс третьего элемента списка.

Как узнать индекс числа 9 с нашем списке? Число 9 — пятое по счету. Значит 5-1=4. Итак, индекс числа 9 — 4.

Таким образом, если мы напишем код:

То Питон выведет на экран число 7.

Попробуйте сделать это, создав файл .py , введите следующий код и посмотрите, что будет в программе PowerShell:

Для того, чтобы узнать общее число элементов в списке, используется функция len()

Пропишите в файл .py код и откройте его в программе PowerShell:

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

Что такое цикл for ?

Для множественного выполнения каких-то одинаковых действий в Питоне существуют циклы.

Например, для всех команд КХЛ в игровой таблице нам надо выполнить одно действие — напечатать на экране название каждой команды. А команд может быть 20. Чтобы не печатать 20 строк текста, можно составить код цикла for и Питон сам все напечатает.

Цикл for как бы говорит — для элементов в списке xxx : и далее следует команда, что надо сделать. Пока в списке есть необработанные элементы, цикл for не заканчивается. Как только обработан последний элемент, цикл заканчивается и Питон переходит к нижележащему после цикла коду. Таким образом цикл — это циклическая работа Питона по обработке того или иного кода. Но иногда, при ошибочном составлении какого-либо цикла, работа Питона зацикливается, и программа зависает навсегда.

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

Кроме цикла for, в питоне есть, например, еще цикл while — перейти в урок про цикл while .

Практический пример

Создаем на рабочем столе файл test24.py Не забываем про кодировку файла. Пишем в него руками следующий программный код.

Краткое пояснение к коду

В принципе, здесь все понятно из комментариев к коду.

Сначала мы создаем три списка.

Затем с помощью цикла for обрабатываем сначала первый список, потом второй, потом третий.

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

Теперь открываем программу PowerShell и прописываем команду: python desktop/test24.py

В итоге у вас должно получиться также, как на картинке.

Домашнее задание

1. Составьте три разных списка на любую тему.
2. Меняйте названия переменных.

В следующем уроке мы разберем более сложные конструкции цикла for — перейти в урок 30.

• Вы здесь:  
• Главная />
• Python 2.7 с нуля />
• Урок 29. Что такое списки и цикл for в Питоне 2.7