Как работать со списками в Python
Учимся добавлять и изменять элементы, объединять и копировать списки.
Анастасия Хамидулина
Автор статьи
2 мая 2022 в 11:01
В современных языках программирования есть предустановленные типы: символы, числа или классы. Есть и коллекции — массивы, списки и прочие структуры данных — множества элементов фиксированной или динамической размерности.
При объявлении переменной под объект выделяется оперативная память. Например, для строки в четыре символа — восемь байт. Каждый символ занимает адрес в оперативной памяти, а строка представляет собой массив этих адресов. В C-подобных языках массивы создаются определенного размера, под тип объектов. В Python же нет ограничений ни по типу элементов множества, ни по его размерности. То есть список в Python — это динамическая коллекция указателей.
Как решать типовые задачи
https://sky.pro/media/pep8/
�� Объявить список
Синтаксическая конструкция для создания списка Python:
mylst = [1, 2, 3, 4, 5]
Mylst — название переменной. В скобках указали элементы.
В Python есть ключевое слово list(). Это функция, которая либо создает пустой список, либо приводит к списку итерируемый объект. Чтобы создать пустой объект списка с помощью функции, напишите:
mylst = list()
�� Обратиться к элементу
Списки — это множества элементов. Чтобы обратиться к ним, указывают индекс — порядковый номер. В отличие, например, от словаря, который позволяет получать значение по ключу. Индекс первого элемента — 0, второго — 1, третьего — 2.
Так обратитесь к пятому элементу списка:
mylst = [1, 2, 3, 4, 5] print(mylst[4]) 5
Python-разработчик: новая работа через 9 месяцев
Получится, даже если у вас нет опыта в IT
�� Добавить элемент
Сделайте это с помощью встроенной функции append():
mylst = [1, 2, 3, 4, 5] mylst.append(6) print(mylst) [1, 2, 3, 4, 5, 6]
Либо с помощью метода insert(), который принимает два аргумента — индекс и значение:
mylst = [1, 2, 3, 4, 5] mylst.insert(1, 25) print(mylst) [1, 25, 2, 3, 4, 5]
❗ Если добавить элемент с помощью этого метода, произойдет смещение, а не его замена.
�� Изменить элемент
Для этого установите новое значение по его индексу:
mylst = [1, 2, 3, 4, 5] mylst[1] = None print(mylst) [1, None, 3, 4, 5]
В Python необязательно, чтобы элементы коллекции были одного типа.
�� Удалить элемент
Для этого воспользуйтесь встроенной функцией del():
mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1] del mylst[2] print(mylst) [1, 2, 4, 5, 4, 3, 2, 1]
Либо примените метод удаления remove():
mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1] mylst.remove(2) print(mylst) [1, 3, 4, 5, 4, 3, 2, 1]
�� Проверить на вхождение
Чтобы проверить, есть ли указанный элемент в списке, воспользуйтесь ключевым словом in:
mylst = [1, 2, 3, 4, 5] print(None in mylst) False print(3 in mylst) True
�� Объединить списки
Вызовите метод extend():
mylst = [1, 2] mylst1 = [3, 4] mylst2 = [5] mylst.extend(mylst1) print(mylst) [1, 2, 3, 4] mylst.extend(mylst2) print(mylst) [1, 2, 3, 4, 5]
Или оператор сложения с присваиванием:
mylst = [1, 2] mylst1 = [3, 4] mylst2 = [5] mylst += mylst1 print(mylst) [1, 2, 3, 4] mylst += mylst2 print(mylst) [1, 2, 3, 4, 5]
�� Копировать список
Воспользуйтесь методом списков copy():
mylst = [1, 2, 3, 4, 5] mylst_copy = mylst.copy() print(mylst) [1, 2, 3, 4, 5] print(mylst_copy) [1, 2, 3, 4, 5]
Либо создайте полный срез:
mylst = [1, 2, 3, 4, 5] mylst_copy = mylst[::] print(mylst) [1, 2, 3, 4, 5] print(mylst_copy) [1, 2, 3, 4, 5]
�� Выполнить итерацию по списку
mylst = [1, 2, 3, 4, 5] for item in mylst: print(item) 1 2 3 4 5
Итерацию еще выполняют с помощью цикла while:
mylst = [1, 2, 3, 4, 5] i = 0 while True: try: print(mylst[i]) except IndexError: print("Done!") break i += 1 1 2 3 4 5 Done!
«Если вы думаете, что хорошо разбираетесь в списках, подумайте еще раз. Дело в том, что списки в Python больше похожи на то, что мы привыкли называть массивами в других языках программирования, а не на связанные списки, которые обычно приходят на ум при слове „список“».
«Изучаем программирование на Python»
По-настоящему хорошо изучить язык можно на курсе Skypro «Python-разработчик». Программа выстроена от простого к сложному: сначала необходимый минимум теории, а потом много практики, чтобы усвоить знания и отработать навыки. Всё это — с поддержкой опытных наставников и кураторов.
Методы списков
✔️ index
Позволяет узнать индекс элемента, возвращает его при первом совпадении:
mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1] print(mylst.index(3)) 2
✔️ count
Позволяет получить количество элементов списка:
mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1] count_for_one = mylst.count(1) print(count_for_one) 2 count_for_five = mylst.count(5) print(count_for_five) 1
✔️ clear
Полностью очищает список:
mylst = [1, 2, 3, 4, 5] mylst.clear() print(mylst) []
✔️ sort
Сортирует список по указанному ключу. Принимает два необязательных аргумента: key — ключ, по которому производят сортировку, булевый флаг reverse — сортирует объекты в обратном порядке. По умолчанию в качестве ключа используют значение переменной:
mylst = [1, 3, 2, 4, 5] mylst.sort() # reverse=False print(mylst) [1, 2, 3, 4, 5]
✔️ reverse
Инвертирует последовательность элементов:
mylst = [1, 2, 3, 4, 5] mylst.reverse() print(mylst) [5, 4, 3, 2, 1]
✔️ pop
Позволяет получить элемент и удаляет его из списка. Принимает индекс в качестве необязательного аргумента. По умолчанию это последний элемент:
mylst = [1, 2, 3, 4, 5] x = mylst.pop() print(x) 5 print(mylst) [1, 2, 3, 4] y = mylst.pop(2) print(y) 3 print(mylst) [1, 2, 4]
Встроенные функции
✅ Получение длины любой коллекции
Используйте функцию len():
mylst = [1, 2, 3, 4, 5] list_length = len(mylst) print(list_length) 5
✅ Возврат элемента с максимальным значением
Используйте функцию max():
mylst = [1, 2, 3, 4, 5, 4, 3, 2, 1] max_value = max(mylst) print(max_value) 5
✅ Возврат элемента с минимальным значением
Используйте функцию min():
mylst = [1, 2, 3, 4, 5] min_value = min(mylst) print(min_value) 1
✅ Приведение к типу
Из любого итерируемого объекта можно получить список. Для этого передайте итерируемый объект функции list(). Этим объектом может быть строка, множество, кортеж или генератор:
myset = mytuple = (5, 6) mystring = "Test string" lst1 = list(myset) lst2 = list(mytuple) lst3 = list(mystring) print(lst1) [1, 2, 3, 4] print(lst2) [5, 6] print(lst3) ['T', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g']
Работа со срезами
Срезы позволяют создавать новые списки на основе существующего. Можно получить полную копию списка или некоторые элементы. Для этого используют шаг или указывают начальный и крайний индексы:
mylst = [1, 2, 3, 4, 5] mylst_slice_0 = mylst[::] # полная копия print(mylst_slice_0) [1, 2, 3, 4, 5] mylst_slice_1 = mylst[0:2] # крайний индекс (не включается в срез) print(mylst_slice_1) [1, 2] mylst_slice_2 = mylst[::2] # указание шага print(mylst_slice_2) [1, 3, 5]
Синтаксис работы со срезами:
# имя переменной[стартовый индекс:конечный индекс:шаг] variable_name[start_index:end_index:step]
Срезы часто используют в своей работе аналитики данных. Это позволяет им автоматизировать и ускорить решение некоторых задач. Основы Python для анализа данных можно освоить на курсе Skypro «Аналитик данных».
Генератор списков
Эта конструкция позволяет легко создавать списки:
mylst = [_ for _ in range(6)] print(mylst) [0, 1, 2, 3, 4, 5]
Вы можете указать условия для генерации элементов:
mylst = [x if x % 2 == 0 else "odd" for x in range(20)] print(mylst) [0, 'odd', 2, 'odd', 4, 'odd', 6, 'odd', 8, 'odd', 10, 'odd', 12, 'odd', 14, 'odd', 16, 'odd', 18, 'odd']
Python: List (Списки)
Список – это структура данных, которая содержит упорядоченный набор элементов, т.е. хранит последовательность элементов. Изменяемые списки создаются через квадратные скобки. Элементы могут повторяться и меняться. Доступ к отдельному элементу тоже через квадратные скобки. Отсчёт с 0.
Узнать все методы списка можно через команду.
help(list)
Рассмотрим некоторые примеры.
cats = ["Барсик", "Мурзик", "Васька"] print(cats) # все элементы списка print(cats[1]) # один указанный элемент numbers = [0, 1, 2, 3, 4, 5] print(numbers) print(numbers[4]) // список из строки mylist = list('Барсик') print(mylist)
В списке могут быть разные типы. Поместим в список числа и строки.
mix = ["one", 3, "two", "three", 9, 3] print(mix[1]) print(mix[2])
Можно создать пустой список.
empty = [] print(empty) # []
В качестве индекса можно указать отрицательные значения. Так индекс -1 вернёт последний элемент списка, -2 предпоследний и т.д.
numbers = [0, 1, 2, 3, 4, 5] print(numbers[-1]) #5 print(numbers[-2]) #4 print(numbers[-3]) #3
Развернуть список можно через reverse().
reversed = [1, 2, 3, 4, 4] reversed.reverse() print (reversed) # [4, 4, 3, 2, 1] kitten = list("Барсик") kitten.reverse() print(kitten) # ['к', 'и', 'с', 'р', 'а', 'Б']
Сортировать можно через sort().
mylist = [8, 2, 11, 4, 3] mylist.sort() print (mylist)
Можем заменить существующие элементы списка.
numbers = [0, 1, 2, 3, 4, 5] numbers[0] = 10 numbers[5] = 22 print(numbers[-1]) print(numbers[0])
Добавить новый элемент в конец списка можно через append().
numbers = [0, 1, 2, 3, 4, 5] numbers.append(99) print(numbers[-1])
Можно вставить элемент в нужную позицию через insert(), указав индекс.
numbers = [0, 1, 2, 3, 4, 5] numbers = [0, 1, 2, 3, 4, 5] numbers.insert(1, 33) print(numbers[1]) print(numbers) # [0, 33, 1, 2, 3, 4, 5]
Удалить элемент по указанному индексу можно через remove().
numbers = [0, 1, 2, 3, 4, 5] numbers.remove(5) print(numbers) # [0, 1, 2, 3, 4]
Метод pop() также позволяет удалить элемент по индексу, но при этом возвращает значение удалённого элемента. Если индекс не указан, то удаляется последний элемент.
numbers = [6, 3, 9, 5, 1, 5] poped = numbers.pop(2) print(poped) # 9 poped = numbers.pop() print(poped) # 5
Есть ещё способ удаления по индексу через инструкцию del.
Когда удаляется элемент с индексом 1, элемент, имевший индекс 2, становится элементом с индексом 1, элемент, имевший индекс 3, приобретает индекс 2 и так далее. Соответственно, количество индексов при удалении элемента уменьшается.
Можно запускать команду del numbers[1] снова и снова, удаляя по одному элементу списка. Главное, это вовремя остановиться, чтобы не получить ошибку при удалении несуществующего индекса.
Длину списка можно узнать через len().
numbers = [6, 8, 2, 5, 1, 5] print(len(numbers)) # 6
Узнать количество одинаковых элементов в списке можно через count().
kitten = list('котёнок') print(kitten.count('к')) # 2
Список можно расширить другим списком через extend(). Новые элементы добавляются в конец первого списка.
oneList = [6, 8, 2, 5, 1, 5] secondList = [0, 1, 4] oneList.extend(secondList) print(oneList) # [6, 8, 2, 5, 1, 5, 0, 1, 4]
Два списка можно сложить и получить третий список.
firstList = [6, 8, 2, 5, 1, 5] secondList = [0, 1, 4] bigList = firstList + secondList print(bigList) # [6, 8, 2, 5, 1, 5, 0, 1, 4]
Пройтись по всем элементам списка можно через цикл for.
numbers = [1, 2, 3] for element in numbers: print(element)
Фильтрация списка через filter() с лямбдой
Мы можем фильтровать элементы списка по заданному условию, используя класс filter и лямбда-выражения.
Допустим, у нас есть список чисел от 1 до 10 и мы хотим оставить числа меньше 5. Применяем к списку функцию filter(), в котором указываем лямбда-выражение — берётся каждый элемент списка и проверяется условие. Если число меньше 5, то условие выполняется и число попадает в объект класса filter. Затем мы создаём новый список, куда помещаем созданный объект и на выходе получаем финальный результат — отфильтрованный список.
sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] filterObj = filter(lambda x: x < 5, sourceList) print(type(filterObj)) # filteredList = list(filterObj) print(filteredList) # [1, 2, 3, 4]
Существует другой громоздкий вариант через цикл for, который не стал приводить здесь.
Вместо лямбда-выражения можно использовать именную функцию. Создадим именную функцию под именем isGreater и зададим условие - числа должны быть больше 5.
def isGreater(x): return x > 5 sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] filteredList = list(filter(isGreater, sourceList)) print(str(filteredList))
Проекция на список через map() с лямбдой
Если нужно пройтись по всем элементам списка и что-то с ним сделать, то подойдёт функция map(). Допустим, мы хотим увеличить значение каждого элемента на заданную величину.
sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] mapObj = map(lambda x: x + 9, sourceList) print(type(mapObj)) # mappedList = list(mapObj) print(mappedList) # [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
Вырезка последовательности
Вырезка последовательности (получение фрагмента) применима к спискам, кортежам и строкам. Иногда используется термин "срез".
item[START:STOP:STEP]
Операция вырезки производится при помощи указания имени последовательности, за которым идёт пара чисел в квадратных скобках, разделённых двоеточием. Третий аргумент отвечает за шаг и используется реже (см. ниже).
Первое число перед двоеточием указывает позицию начала вырезки, а второе число после двоеточия указывает, где вырезка заканчивается. Если первое число не указано, вырезка начинается с начала последовательности. Если пропущено второе число, Python закончит вырезку у конца последовательности. Обратите внимание, что полученная вырезка будет начинаться с указанной начальной позиции, а заканчиваться прямо перед указанной конечной позицией, т.е. начальная позиция входит в вырезку, а конечная – нет.
sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(sourceList[1:4]) # со второго до четвёртого print(sourceList[5:]) # с шестого элемента до конца print(sourceList[1:-1]) # со второго до предпоследнего print(sourceList[:]) # все элементы
[2, 3, 4] [6, 7, 8, 9, 10] [2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Можно указать шаг вырезки в третьем аргументе (по умолчанию шаг вырезки равен 1):
sourceList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(sourceList[1:8:2]) # [2, 4, 6, 8]
с помощью срезов можно не только извлекать элементы, но и добавлять и удалять элементы (только для изменяемых списков).
sourceList = [1, 2, 3, 4, 5] sourceList[1:3] = [7, 7, 7] # добавим три новых элемента вместо второго и третьего элемента print(sourceList) # [1, 7, 7, 7, 4, 5] del sourceList[:-3] # удаляем первые элементы списка до третьего элемента с конца print(sourceList) # [7, 4, 5]
Списки, кортежи и словари
Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.
Список (list) представляет тип данных, который хранит набор или последовательность элементов. Во многих языках программирования есть аналогичная структура данных, которая называется массив.
Создание списка
Для создания списка применяются квадратные скобки [] , внутри которых через запятую перечисляются элементы списка. Например, определим список чисел:
numbers = [1, 2, 3, 4, 5]
Подобным образом можно определять списки с данными других типов, например, определим список строк:
people = ["Tom", "Sam", "Bob"]
Также для создания списка можно использовать функцию-конструктор list() :
numbers1 = [] numbers2 = list()
Оба этих определения списка аналогичны - они создают пустой список.
Список необязательно должен содержать только однотипные объекты. Мы можем поместить в один и тот же список одновременно строки, числа, объекты других типов данных:
objects = [1, 2.6, "Hello", True]
Для проверки элементов списка можно использовать стандартную функцию print, которая выводит содержимое списка в удобочитаемом виде:
numbers = [1, 2, 3, 4, 5] people = ["Tom", "Sam", "Bob"] print(numbers) # [1, 2, 3, 4, 5] print(people) # ["Tom", "Sam", "Bob"]
Конструктор list может принимать набор значений, на основе которых создается список:
numbers1 = [1, 2, 3, 4, 5] numbers2 = list(numbers1) print(numbers2) # [1, 2, 3, 4, 5] letters = list("Hello") print(letters) # ['H', 'e', 'l', 'l', 'o']
Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *, то есть фактически применить операцию умножения к уже существующему списку:
numbers = [5] * 6 # 6 раз повторяем 5 print(numbers) # [5, 5, 5, 5, 5, 5] people = ["Tom"] * 3 # 3 раза повторяем "Tom" print(people) # ["Tom", "Tom", "Tom"] students = ["Bob", "Sam"] * 2 # 2 раза повторяем "Bob", "Sam" print(students) # ["Bob", "Sam", "Bob", "Sam"]
Обращение к элементам списка
Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент - индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего - -2 и так далее.
people = ["Tom", "Sam", "Bob"] # получение элементов с начала списка print(people[0]) # Tom print(people[1]) # Sam print(people[2]) # Bob # получение элементов с конца списка print(people[-2]) # Sam print(people[-1]) # Bob print(people[-3]) # Tom
Для изменения элемента списка достаточно присвоить ему новое значение:
people = ["Tom", "Sam", "Bob"] people[1] = "Mike" # изменение второго элемента print(people[1]) # Mike print(people) # ["Tom", "Mike", "Bob"]
Разложение списка
Python позволяет разложить список на отдельные элементы:
people = ["Tom", "Bob", "Sam"] tom, bob, sam = people print(tom) # Tom print(bob) # Bob print(sam) # Sam
В данном случае переменным tom, bob и sam последовательно присваиваются элементы из списка people. Однако следует учитывать, что количество переменных должно быть равно числу элементов присваиваемого списка.
Перебор элементов
Для перебора элементов можно использовать как цикл for, так и цикл while.
Перебор с помощью цикла for :
people = ["Tom", "Sam", "Bob"] for person in people: print(person)
Здесь будет производиться перебор списка people, и каждый его элемент будет помещаться в переменную person.
Перебор также можно сделать с помощью цикла while :
people = ["Tom", "Sam", "Bob"] i = 0 while i < len(people): print(people[i]) # применяем индекс для получения элемента i += 1
Для перебора с помощью функции len() получаем длину списка. С помощью счетчика i выводит по элементу, пока значение счетчика не станет равно длине списка.
Сравнение списков
Два списка считаются равными, если они содержат один и тот же набор элементов:
numbers1 = [1, 2, 3, 4, 5] numbers2 = list([1, 2, 3, 4, 5]) if numbers1 == numbers2: print("numbers1 equal to numbers2") else: print("numbers1 is not equal to numbers2")
В данном случае оба списка будут равны.
Получение части списка
Если необходимо получить какую-то определенную часть списка, то мы можем применять специальный синтаксис, который может принимать следующие формы:
- list[:end] : через параметр end передается индекс элемента, до которого нужно копировать список
- list[start:end] : параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы
- list[start:end:step] : параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.
people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:3] # с 0 по 3 print(slice_people1) # ["Tom", "Bob", "Alice"] slice_people2 = people[1:3] # с 1 по 3 print(slice_people2) # ["Bob", "Alice"] slice_people3 = people[1:6:2] # с 1 по 6 с шагом 2 print(slice_people3) # ["Bob", "Sam", "Bill"]
Можно использовать отрицательные индексы, тогда отсчет будет идти с конца, например, -1 - предпоследний, -2 - третий сконца и так далее.
people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:-1] # с предпоследнего по нулевой print(slice_people1) # ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people2 = people[-3:-1] # с третьего с конца по предпоследний print(slice_people2) # [ "Sam", "Tim"]
Методы и функции по работе со списками
Для управления элементами списки имеют целый ряд методов. Некоторые из них:
- append(item) : добавляет элемент item в конец списка
- insert(index, item) : добавляет элемент item в список по индексу index
- extend(items) : добавляет набор элементов items в конец списка
- remove(item) : удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError
- clear() : удаление всех элементов из списка
- index(item) : возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError
- pop([index]) : удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.
- count(item) : возвращает количество вхождений элемента item в список
- sort([key]) : сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.
- reverse() : расставляет все элементы в списке в обратном порядке
- copy() : копирует список
Кроме того, Python предоставляет ряд встроенных функций для работы со списками:
- len(list) : возвращает длину списка
- sorted(list, [key]) : возвращает отсортированный список
- min(list) : возвращает наименьший элемент списка
- max(list) : возвращает наибольший элемент списка
Добавление и удаление элементов
Для добавления элемента применяются методы append() , extend и insert , а для удаления - методы remove() , pop() и clear() .
people = ["Tom", "Bob"] # добавляем в конец списка people.append("Alice") # ["Tom", "Bob", "Alice"] # добавляем на вторую позицию people.insert(1, "Bill") # ["Tom", "Bill", "Bob", "Alice"] # добавляем набор элементов ["Mike", "Sam"] people.extend(["Mike", "Sam"]) # ["Tom", "Bill", "Bob", "Alice", "Mike", "Sam"] # получаем индекс элемента index_of_tom = people.index("Tom") # удаляем по этому индексу removed_item = people.pop(index_of_tom) # ["Bill", "Bob", "Alice", "Mike", "Sam"] # удаляем последний элемент last_item = people.pop() # ["Bill", "Bob", "Alice", "Mike"] # удаляем элемент "Alice" people.remove("Alice") # ["Bill", "Bob", "Mike"] print(people) # ["Bill", "Bob", "Mike"] # удаляем все элементы people.clear() print(people) # []
Проверка наличия элемента
Если определенный элемент не найден, то методы remove и index генерируют исключение. Чтобы избежать подобной ситуации, перед операцией с элементом можно проверять его наличие с помощью ключевого слова in :
people = ["Tom", "Bob", "Alice", "Sam"] if "Alice" in people: people.remove("Alice") print(people) # ["Tom", "Bob", "Sam"]
Выражение if "Alice" in people возвращает True, если элемент "Alice" имеется в списке people. Поэтому конструкция if "Alice" in people может выполнить последующий блок инструкций в зависимости от наличия элемента в списке.
Удаление с помощью del
Python также поддерживает еще один способ удаления элементов списка - с помощью оператора del . В качестве параметра этому оператору передается удаляемый элемент или набор элементов:
people = ["Tom", "Bob", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[1] # удаляем второй элемент print(people) # ["Tom", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[:3] # удаляем по четвертый элемент не включая print(people) # ["Bill", "Kate", "Mike"] del people[1:] # удаляем со второго элемента print(people) # ["Bill"]
Изменение подсписка
Для изменения подсписка - набора элементов в списке можно использовать вышерассмотренный синтаксис [start:end] :
nums = [10, 20, 30, 40, 50] nums[1:4]=[11, 22] print(nums) # [10, 11, 22, 50]
Здесь выражение nums[1:4] фактически обращается к подсписку [20, 30, 40] . Присвоение этому подсписку списка [11, 22] позволяет заменить элемента с 1 по 4 индекс не включая на элементы [11, 22] . И после изменения получим список [10, 11, 22, 50]
Подсчет вхождений
Если необходимо узнать, сколько раз в списке присутствует тот или иной элемент, то можно применить метод count() :
people = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"] people_count = people.count("Tom") print(people_count) # 3
Сортировка
Для сортировки по возрастанию применяется метод sort() :
people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() print(people) # ["Alice", "Bill", "Bob", "Sam", "Tom"]
Если необходимо отсортировать данные в обратном порядке, то мы можем после сортировки применить метод reverse() :
people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() people.reverse() print(people) # ["Tom", "Sam", "Bob", "Bill", "Alice"]
При сортировке фактически сравниваются два объекта, и который из них "меньше", ставится перед тем, который "больше". Понятия "больше" и "меньше" довольно условны. И если для чисел все просто - числа расставляются в порядке возрастания, то для строк и других объектов ситуация сложнее. В частности, строки оцениваются по первым символам. Если первые символы равны, оцениваются вторые символы и так далее. При чем цифровой символ считается "меньше", чем алфавитный заглавный символ, а заглавный символ считается меньше, чем строчный.
Таким образом, если в списке сочетаются строки с верхним и нижним регистром, то мы можем получить не совсем корректные результаты, так как для нас строка "bob" должна стоять до строки "Tom". И чтобы изменить стандартное поведение сортировки, мы можем передать в метод sort() в качестве параметра функцию:
people = ["Tom", "bob", "alice", "Sam", "Bill"] people.sort() # стандартная сортировка print(people) # ["Bill", "Sam", "Tom", "alice", "bob"] people.sort(key=str.lower) # сортировка без учета регистра print(people) # ["alice", "Bill", "bob", "Sam", "Tom"]
Кроме метода sort мы можем использовать встроенную функцию sorted , которая имеет две формы:
- sorted(list) : сортирует список list
- sorted(list, key) : сортирует список list, применяя к элементам функцию key
people = ["Tom", "bob", "alice", "Sam", "Bill"] sorted_people = sorted(people, key=str.lower) print(sorted_people) # ["alice", "Bill", "bob", "Sam", "Tom"]
При использовании этой функции следует учитывать, что эта функция не изменяет сортируемый список, а все отсортированные элементы она помещает в новый список, который возвращается в качестве результата.
Минимальное и максимальное значения
Встроенный функции Python min() и max() позволяют найти минимальное и максимальное значения соответственно:
numbers = [9, 21, 12, 1, 3, 15, 18] print(min(numbers)) # 1 print(max(numbers)) # 21
Копирование списков
При копировании списков следует учитывать, что списки представляют изменяемый (mutable) тип, поэтому если обе переменных будут указывать на один и тот же список, то изменение одной переменной, затронет и другую переменную:
people1 = ["Tom", "Bob", "Alice"] people2 = people1 people2.append("Sam") # добавляем элемент во второй список # people1 и people2 указывают на один и тот же список print(people1) # ["Tom", "Bob", "Alice", "Sam"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]
Это так называемое "поверхностное копирование" (shallow copy). И, как правило, такое поведение нежелательное. И чтобы происходило копирование элементов, но при этом переменные указывали на разные списки, необходимо выполнить глубокое копирование (deep copy). Для этого можно использовать метод copy() :
people1 = ["Tom", "Bob", "Alice"] people2 = people1.copy() # копируем элементы из people1 в people2 people2.append("Sam") # добавляем элемент ТОЛЬКО во второй список # people1 и people2 указывают на разные списки print(people1) # ["Tom", "Bob", "Alice"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]
Соединение списков
Для объединения списков применяется операция сложения (+):
people1 = ["Tom", "Bob", "Alice"] people2 = ["Tom", "Sam", "Tim", "Bill"] people3 = people1 + people2 print(people3) # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]
Списки списков
Списки кроме стандартных данных типа строк, чисел, также могут содержать другие списки. Подобные списки можно ассоциировать с таблицами, где вложенные списки выполняют роль строк. Например:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] print(people[0]) # ["Tom", 29] print(people[0][0]) # Tom print(people[0][1]) # 29
Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: people[0][1] - обращение ко второму элементу первого вложенного списка.
Добавление, удаление и изменение общего списка, а также вложенных списков аналогично тому, как это делается с обычными (одномерными) списками:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] # создание вложенного списка person = list() person.append("Bill") person.append(41) # добавление вложенного списка people.append(person) print(people[-1]) # ["Bill", 41] # добавление во вложенный список people[-1].append("+79876543210") print(people[-1]) # ["Bill", 41, "+79876543210"] # удаление последнего элемента из вложенного списка people[-1].pop() print(people[-1]) # ["Bill", 41] # удаление всего последнего вложенного списка people.pop(-1) # изменение первого элемента people[0] = ["Sam", 18] print(people) # [ ["Sam", 18], ["Alice", 33], ["Bob", 27]]
Перебор вложенных списков:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] for person in people: for item in person: print(item, end=" | ")
Tom | 29 | Alice | 33 | Bob | 27 |
Список
Список - это непрерывная динамическая коллекция элементов. Каждому элементу списка присваивается порядковый номер - его индекс. Первый индекс равен нулю, второй - единице и так далее. Основные операции для работы со списками - это индексирование, срезы, добавление и удаление элементов, а также проверка на наличие элемента в последовательности.
Создание пустого списка выглядит так:
Создадим список, состоящий из нескольких чисел:
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. Создайте список из случайных чисел. Найдите количество различных элементов в нем.