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

Why not just use .index()?

In [1]: l = [ a, b, [c,d], e, f]
In [2]: l.index([c,d])
Out[2]: 2
In [4]: l.index(e)
Out[4]: 3

If you really need a recursive function, use the following:

def order(item, l, n=0):
    if l:
        if l[0] == item:
            return n
        elif len(l) >= 2: # for python 2, use "else:"
            return order(item, l[1:], n+1)

And if recursion is not a must but you can’t use .index(), use a for loop:

def order(item, l):
    for i,v in enumrate(l):
        if v == item:
            return i

With both methods, just call order([c,d], lst)

Список

Назад в начало

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

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

empty_list = []

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

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])

>>> Apple

>>> Grape

>>> Orange

Списки в 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])

>>> Orange

>>> Banan

>>> Peach

>>> Grape

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

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

smiles = [‘(ಠ_ಠ)’, ‘(￣﹃￣)’, ‘( ͡° ͜ʖ ͡°)’, ‘(╮°-°)╮’]

А есть еще способы? Да, есть. Один из них — создание списка с помощью функции 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))

>>> 5

numbers = [40, 20, 90]

print(len(numbers))

>>> 3

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

string = ‘Hello world’

print(len(string))

# 11

>>> 11

print(len(range(10))

>>> 10

Срезы

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

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

part_of_fruits = fruits[0:3]

print(part_of_fruits)

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

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

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

Обращаю ваше внимание, что мы делаем срез от начального индекса до конечного индекса — 1. То есть i = начальный_индекс и i < конечный индекс

Больше примеров!

fruits = [‘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’]

for fruit in fruits:

    print(fruit, end=‘ ‘)

>>> Apple Grape Peach Banan Orange

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

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

for 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’]

for 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

>>> 3 # 1

>>> 2 # 2

>>> 5 # 3

>>> 1 # 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’))

>>> 1

>>> 0

>>> 2

Финишная прямая! Метод 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 – упорядоченный изменяемый набор объектов произвольных типов, пронумерованных от 0. Они используются для хранения и работы с данными.

Список можно задать так:

Num = [9, 8, 7, 6, 5, 4, 3, 2, 1]

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

Num = [9, 8, 7, 6, 5, 4, 3, 2, 1]

print(Num[0]) ##Выведет 9

print(Num[3]) ##Выведет 6

print(Num[8]) ##Выведет 1

Также можно вывести тот или иной элемент списка с помощью его индекса с конца счета:

Num = [9, 8, 7, 6, 5, 4, 3, 2, 1]

print(Num[-1]) ##Выведет 1

print(Num[-3]) ##Выведет 3

print(Num[-7]) ##Выведет 7

Можно вывести и весь массив с помощью того же метода print:

Num = [9, 8, 7, 6, 5, 4, 3, 2, 1]

print(Num) ##Выведет [9, 8, 7, 6, 5, 4, 3, 2, 1]

Списки можно создавать с помощью генераторов списков. Такой способ схож с использованием цикла for, но этот гораздо компактнее в исполнении:

GenList = [ for GenList in ‘hello world’]

print(GenList) ##Выведет ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

Рассмотрим конкатенацию списков (добавление одного списка в конец другого):

a = ['a', 'b']

b = [1, 2]

c = a+b

print(c) ##Выведет ['a', 'b', 1, 2]

Сами списки можно умножать на любые числа:

a = [1, 2]

a = a*2

print(a) ##Выведет [1, 2, 1, 2]

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

list.append(x) – добавляет элемент x в конец списка. Пример:

a = [1, 2]

a.append(1)

print(a) ##Выведет [1, 2, 1]

list.extend(x) – делает то же самое, что и операция с суммой списков, то есть добавляет в конец списка list элементы списка x. Пример:

a = [1, 2]

a.extend(a)

print(a) ##Выведет [1, 2, 1, 2]

list.insert(y, x) – вставляет элемент x в список list порядковым номером y. Пример:

a = [1, 2]

a.insert(0, 2)

print(a) ##Выведет [2, 1, 2]

list.remove(x) – удаляет первый элемент в списке list, который равен значению x. Пример: 

a = [1, 2, 1]

a.remove(1)

print(a) ##Выведет [2, 1]

list.pop(y) – удаляет элемент списка list по порядковому номеру y. Если порядковый номер не задан, то удаляется последний элемент списка. Пример:

a = [1, 2, 1]

a.pop(0)

print(a) ##Выведет: [2, 1]

list.index(g, x, y) – возвращает порядковый номер первого элемента со значением g в списке list в диапазоне от x до y (диапазон можно не указывать, при этом поиск будет вестись по всему списку). Пример:

a = [1, 2, 1, 3]

b = a.index(1, 1, 3)

print(b) ##Выведет 2

list.count(x) – возвращает количество элементов со значением x в списке list. Пример:

a = [1, 2, 1, 3]

b = a.count(1)

print(b) ##Выведет 2

list.sort() – сортировка списка. По умолчанию сортировка идет по возрастанию. Также в виде параметра в метод можно передать функцию сортировки. Пример: 

a = [2, 1, 3]

a.sort()

print(a) ##Выведет [1, 2, 3]

list.reverse() – переворачивает (реверсирует список). Пример:

a = [2, 1, 3]

a.reverse()

print(a) ##Выведет [3, 1, 2]

list.copy() – копирует список. Пример:

a = [2, 1, 3]

newList = a.copy()

a = a*2

print(newList) ##Выведет [2, 1, 3]

print(a) ##Выведет [2, 1, 3, 2, 1, 3]

list.clear() – очищает список. Пример:

a = [2, 1, 3]

a.clear()

print(a) ##Выведет []

Итог

Мы узнали, что такое списки в Python и как с ними работать. Надеюсь, что статья была для вас полезной. Удачи!