Содержание

Списки (list). Функции и методы списков

Сегодня я расскажу о таком типе данных, как списки, операциях над ними и методах, о генераторах списков и о применении списков.

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

Списки в Python — упорядоченные изменяемые коллекции объектов произвольных типов (почти как массив, но типы могут отличаться).

Чтобы использовать списки, их нужно создать. Создать список можно несколькими способами. Например, можно обработать любой итерируемый объект (например, строку) встроенной функцией list:

>>> list('список')
['с', 'п', 'и', 'с', 'о', 'к']

Список можно создать и при помощи литерала:

>>> s = []  # Пустой список
>>> l = ['s', 'p', ['isok'], 2]
>>> s
[]
>>> l
['s', 'p', ['isok'], 2]

Как видно из примера, список может содержать любое количество любых объектов (в том числе и вложенные списки), или не содержать ничего.

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

>>> c = [c * 3 for c in 'list']
>>> c
['lll', 'iii', 'sss', 'ttt']

Возможна и более сложная конструкция генератора списков:

>>> c = [c * 3 for c in 'list' if c != 'i']
>>> c
['lll', 'sss', 'ttt']
>>> c = [c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a']
>>> c
['ls', 'lp', 'lm', 'ss', 'sp', 'sm', 'ts', 'tp', 'tm']

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

Функции и методы списков

Создать создали, теперь нужно со списком что-то делать. Для списков доступны основные встроенные функции, а также методы списков.

Таблица «методы списков»

МетодЧто делает
list.append(x)Добавляет элемент в конец списка
list.extend(L)Расширяет список list, добавляя в конец все элементы списка L
list.insert(i, x)Вставляет на i-ый элемент значение x
list.remove(x)Удаляет первый элемент в списке, имеющий значение x. ValueError, если такого элемента не существует
list.pop([i])Удаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент
list.index(x, [start [, end]])Возвращает положение первого элемента со значением x (при этом поиск ведется от start до end)
list.count(x)Возвращает количество элементов со значением x
list.sort([key=функция])Сортирует список на основе функции
list.reverse()Разворачивает список
list.copy()Поверхностная копия списка
list.clear()Очищает список

Нужно отметить, что методы списков, в отличие от строковых методов, изменяют сам список, а потому результат выполнения не нужно записывать в эту переменную.

>>> l = [1, 2, 3, 5, 7]
>>> l.sort()
>>> l
[1, 2, 3, 5, 7]
>>> l = l.sort()
>>> print(l)
None

И, напоследок, примеры работы со списками:

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

Изредка, для увеличения производительности, списки заменяют гораздо менее гибкими массивами (хотя в таких случаях обычно используют сторонние библиотеки, например NumPy).

Python. Урок 7. Работа со списками (list)

Одна из ключевых особенностей Python, благодаря которой он является таким популярным – это простота. Особенно подкупает простота работы с различными структурами данных – списками, кортежами, словарями и множествами. Сегодня мы рассмотрим работу со списками.

Что такое список (list) в Python?

Список (list) – это структура данных для хранения объектов различных типов. Если вы использовали другие языки программирования, то вам должно быть знакомо понятие массива. Так вот, список очень похож на массив, только, как было уже сказано выше, в нем можно хранить объекты различных типов. Размер списка не статичен, его можно изменять. Список по своей природе является изменяемым типом данных. Про типы данных можно подробно прочитать здесь. Переменная, определяемая как список, содержит ссылку на структуру в памяти, которая в свою очередь хранит ссылки на какие-либо другие объекты или структуры.

Как списки хранятся в памяти?

Как уже было сказано выше, список является изменяемым типом данных. При его создании в памяти резервируется область, которую можно условно назвать некоторым “контейнером”, в котором хранятся ссылки на другие элементы данных в памяти. В отличии от таких типов данных как число или строка, содержимое “контейнера” списка можно менять. Для того, чтобы лучше визуально представлять себе этот процесс взгляните на картинку ниже. Изначально был создан список содержащий ссылки на объекты 1 и 2, после операции a[1] = 3, вторая ссылка в списке стала указывать на объект 3.

Пример изменяемого объекта

Более подробно эти вопросы обсуждались в уроке 3 (Типы и модель данных).

Создание, изменение, удаление списков и работа с его элементами

Создать список можно одним из следующих способов.

>>> a = [] 
>>> type(a) 
<class 'list'> 
>>> b = list() 
>>> type(b) 
<class 'list'>

Также можно создать список с заранее заданным набором данных.

>>> a = [1, 2, 3] 
>>> type(a) 
<class 'list'>

Если у вас уже есть список и вы хотите создать его копию, то можно воспользоваться следующим способом:

>>> a = [1, 3, 5, 7] 
>>> b = a[:] 
>>> print(a) 
[1, 3, 5, 7] 
>>> print(b) 
[1, 3, 5, 7]

или сделать это так:

>>> a = [1, 3, 5, 7] 
>>> b = list(a) 
>>> print(a) 
[1, 3, 5, 7] 
>>> print(b) 
[1, 3, 5, 7]

В случае, если вы выполните простое присвоение списков друг другу, то переменной b будет присвоена ссылка на тот же элемент данных в памяти, на который ссылается a, а не копия списка а. Т.е. если вы будете изменять список a, то и b тоже будет меняться.

>>> a = [1, 3, 5, 7] 
>>> b = a 
>>> print(a) 
[1, 3, 5, 7] 
>>> print(b) 
[1, 3, 5, 7] 
>>> a[1] = 10 
>>> print(a) 
[1, 10, 5, 7] 
>>> print(b) 
[1, 10, 5, 7]

Добавление элемента в список осуществляется с помощью метода append().

>>> a = [] >>> a.append(3) >>> a.append("hello") >>> print(a) [3, 'hello']

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

>>> b = [2, 3, 5] 
>>> print(b) 
[2, 3, 5] 
>>> b.remove(3) 
>>> print(b) 
[2, 5]

Если необходимо удалить элемент по его индексу, воспользуйтесь командой del имя_списка[индекс].

>>> c = [3, 5, 1, 9, 6] 
>>> print(c) 
[3, 5, 1, 9, 6] 
>>> del c[2] 
>>> print(c) 
[3, 5, 9, 6]

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

>>> d = [2, 4, 9] 
>>> print(d) 
[2, 4, 9] 
>>> d[1] = 17 
>>> print(d) 
[2, 17, 9]

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

>>> a = [3, 5, 7, 10, 3, 2, 6, 0] 
>>> a[2] 
7

Можно использовать отрицательные индексы, в таком случае счет будет идти с конца, например для доступа к последнему элементу списка можно использовать вот такую команду:

>>> a[-1] 
0

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

>>> a[1:4] 
[5, 7, 10]

Методы списков

list.append(x)

Добавляет элемент в конец списка. Ту же операцию можно сделать так a[len(a):] = [x].

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

list.extend(L)

Расширяет существующий список за счет добавления всех элементов из списка L. Эквивалентно команде a[len(a):] = L.

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

list.insert(i, x)

Вставить элемент x в позицию i.  Первый аргумент – индекс элемента после которого будет вставлен элемент x.

>>> a = [1, 2] 
>>> a.insert(0, 5) 
>>> print(a) 
[5, 1, 2] 
>>> a.insert(len(a), 9) 
>>> print(a) 
[5, 1, 2, 9]

list.remove(x)

Удаляет первое вхождение элемента x из списка.

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

list.pop([i])

Удаляет элемент из позиции i и возвращает его. Если использовать метод без аргумента, то будет удален последний элемент из списка.

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

list.clear()

Удаляет все элементы из списка. Эквивалентно del a[:].

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

list.index(x[, start[, end]])

Возвращает индекс элемента.

>>> a = [1, 2, 3, 4, 5] 
>>> a.index(4) 
3

list.count(x)

Возвращает количество вхождений элемента x в список.

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

list.sort(key=None, reverse=False)

Сортирует элементы в списке по возрастанию. Для сортировки в обратном порядке используйте флаг reverse=True. Дополнительные возможности открывает параметр key, за более подробной информацией обратитесь к документации.

>>> a = [1, 4, 2, 8, 1] 
>>> a.sort() 
>>> print(a) 
[1, 1, 2, 4, 8]

list.reverse()

Изменяет порядок расположения элементов в списке на обратный.

>>> a = [1, 3, 5, 7] 
>>> a.reverse() 
>>> print(a) 
[7, 5, 3, 1]

list.copy()

Возвращает копию списка. Эквивалентно a[:].

>>> a = [1, 7, 9] 
>>> b = a.copy() 
>>> print(a) 
[1, 7, 9] 
>>> print(b) 
[1, 7, 9] 
>>> b[0] = 8 
>>> print(a) 
[1, 7, 9] 
>>> print(b) 
[8, 7, 9]

List Comprehensions

List Comprehensions чаще всего на русский язык переводят как  абстракция списков или списковое включение, является частью синтаксиса языка, которая предоставляет простой способ построения списков. Проще всего работу list comprehensions показать на примере. Допустим вам необходимо создать список целых чисел от 0 до n, где n предварительно задается. Классический способ решения данной задачи выглядел бы так:

>>> n = int(input())
7
>>> a=[]
>>> for i in range(n):
        a.append(i)

>>> print(a)
[0, 1, 2, 3, 4, 5, 6]

Использование list comprehensions позволяет сделать это значительно проще:

>>> n = int(input())
7
>>> a = [i for i in range(n)]
>>> print(a)
[0, 1, 2, 3, 4, 5, 6]

или вообще вот так, в случае если вам не нужно больше использовать n:

>>> a = [i for i in range(int(input()))]
7
>>> print(a)
[0, 1, 2, 3, 4, 5, 6]

List Comprehensions как обработчик списков

В языке Python есть две очень мощные функции для работы с коллекциями: map и filter. Они позволяют использовать функциональный стиль программирования, не прибегая к помощи циклов, для работы с такими типами как list, tuple, set, dict и т.п. Списковое включение позволяет обойтись без этих функций. Приведем несколько примеров для того, чтобы понять о чем идет речь.

Пример с заменой функции map.

Пусть у нас есть список и нужно получить на базе него новый, который содержит элементы первого, возведенные в квадрат. Решим эту задачу с использованием циклов:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = []
>>> for i in a:
        b.append(i**2)

>>> print('a = {}\nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [1, 4, 9, 16, 25, 36, 49]

Та же задача, решенная с использованием map, будет выглядеть так:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = list(map(lambda x: x**2, a))
>>> print('a = {}\nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [1, 4, 9, 16, 25, 36, 49]

В данном случае применена lambda-функция, о том, что это такое и как ее использовать можете прочитать здесь.

Через списковое включение эта задача будет решена так:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = [i**2 for i in a]
>>> print('a = {}\nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [1, 4, 9, 16, 25, 36, 49]

Пример с заменой функции filter.

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

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = []
>>> for i in a:
        if i%2 == 0:
            b.append(i)

>>> print('a = {}\nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [2, 4, 6]

Решим эту задачу с использованием filter:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = list(filter(lambda x: x % 2 == 0, a))
>>> print('a = {}\nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [2, 4, 6]

Решение через списковое включение:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = [i for i in a if i % 2 == 0]
>>> print('a = {}\nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [2, 4, 6]

Слайсы / Срезы

Слайсы (срезы) являются очень мощной составляющей Python, которая позволяет быстро и лаконично решать задачи выборки элементов из списка. Выше уже был пример использования слайсов, здесь разберем более подробно работу с ними. Создадим список для экспериментов:

>>> a = [i for i in range(10)]

Слайс задается тройкой чисел, разделенных запятой: start:stop:step. Start – позиция с которой нужно начать выборку, stop – конечная позиция, step – шаг. При этом необходимо помнить, что выборка не включает элемент определяемый stop.

Рассмотрим примеры:

>>> # Получить копию списка
>>> a[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> # Получить первые пять элементов списка
>>> a[0:5]
[0, 1, 2, 3, 4]

>>> # Получить элементы с 3-го по 7-ой
>>> a[2:7]
[2, 3, 4, 5, 6]

>>> # Взять из списка элементы с шагом 2
>>> a[::2]
[0, 2, 4, 6, 8]

>>> # Взять из списка элементы со 2-го по 8-ой с шагом 2
>>> a[1:8:2]
[1, 3, 5, 7]

Слайсы можно сконструировать заранее, а потом уже использовать по мере необходимости. Это возможно сделать, в виду того, что слайс – это объект класса slice. Ниже приведен пример, демонстрирующий эту функциональность:

>>> s = slice(0, 5, 1)
>>> a[s]
[0, 1, 2, 3, 4]

>>> s = slice(1, 8, 2)
>>> a[s]
[1, 3, 5, 7]

Типо “List Comprehensions”… в генераторном режиме

Есть ещё одни способ создания списков, который похож на списковое включение, но результатом работы является не объект класса list, а генератор. Подробно про генераторы написано в “Уроке 15. Итераторы и генераторы“.

Предварительно импортируем модуль sys, он нам понадобится:

>>> import sys

Создадим список, используя списковое включение :

>>> a = [i for i in range(10)]

проверим тип переменной a:

>>> type(a)
<class 'list'>

и посмотрим сколько она занимает памяти в байтах:

>>> sys.getsizeof(a)
192

Для создания объекта-генератора, используется синтаксис такой же как и для спискового включения, только вместо квадратных скобок используются круглые:

>>> b = (i for i in range(10))

>>> type(b)
<class 'generator'>

>>> sys.getsizeof(b)
120

Обратите внимание, что тип этого объекта ‘generator’, и в памяти он занимает места меньше, чем список, это объясняется тем, что в первом случае в памяти хранится весь набор чисел от 0 до 9, а во втором функция, которая будет нам генерировать числа от 0 до 9. Для наших примеров разница в размере не существенна, рассмотрим вариант с 10000 элементами:

>>> c = [i for i in range(10000)]

>>> sys.getsizeof(c)
87624

>>> d = (i for i in range(10000))

>>> sys.getsizeof(d)
120

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

Если вы решаете задачу обхода списка, то  принципиальной разницы между списком и генератором не будет:

>>> for val in a:
        print(val, end=' ')

0 1 2 3 4 5 6 7 8 9 

>>> for val in b:
        print(val, end=' ')

0 1 2 3 4 5 6 7 8 9

Но с генератором нельзя работать также как и со списком: нельзя обратиться к элементу по индексу и т.п.

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
Книга: Pandas. Работа с данными

<<< Python. Урок 6. Работа с IPython и Jupyter Notebook   Python. Урок 8. Кортежи (tuple) >>>

Списки в Python — Программирование с нуля

Списки в Python

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

Как создать список?

В программировании на Python список создается путем помещения всех элементов в квадратные скобки [], при этом каждый элемент отделяется от другого запятой.

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

# пустой список
my_list = []

# сипсок чисел
my_list = [1, 2, 3]

# список элементов имеющих разный тип данных
my_list = [1, "Hello", 3.4]

Кроме того, список может содержать в себе другой список как элемент. Это называется вложенным (многоуровневым) списком.

# пример вложенного списка
my_list = ["mouse", [8, 4, 6], ['a']]

Как получить доступ к элементам из списка?

Существуют различные способы доступа к элементам списка.

Доступ по индексу

Для доступа к элементу списка можно использовать оператор индекса []. Индекс начинается с 0. Итак, список из 5 элементов будет иметь индексы от 0 до 4.

Попытка получить доступ к элементу, который не существует, вызовет ошибку IndexError. Индекс должен быть целым числом. Нельзя использовать float или другие типы данных в качестве индекса, это приведет к ошибке TypeError.

Доступ к вложенному списку осуществляется с помощью дополнительных индексов.

my_list = ['p','r','o','b','e']

# Вывод первого элемента: p
print(my_list[0])

# Вывод третьего элемента: o
print(my_list[2])

# Вывод последнего (пятого) элемента: e
print(my_list[4])

# Ошибка, индексом может быть только целое число
# my_list[4.0]

# Пример вложенного списка
n_list = ["Happy", [2,0,1,5]]

# Индексы вложенных списков
# Вывод второго символа первого элемента списка: a
print(n_list[0][1])

# вывод четвертого элемента второго вложенного списка: 5
print(n_list[1][3])

Отрицательные индексы списка

Python допускает отрицательную индексацию для элементов списка. Индекс -1 выведет последний элемент, -2 — второй элемент с конца и т.д.

my_list = ['p','r','o','b','e']

# Вывод последнего элемента: e
print(my_list[-1])

# Вывод последнего элемента с конца (первого): p
print(my_list[-5])

Срезы списков в Python

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

my_list = ['p','r','o','g','r','a','m','f','i', 'l', 'e', 's']

# Элементы с 3го по 5й
print(my_list[2:5])

# Элементы с начала до 4го
print(my_list[:4])

# Элементы с 6го до последнего
print(my_list[5:])

# Элементы с первого до последнего
print(my_list[:])

Как изменить или добавить элементы в список?

Список в питоне является изменяемым типом, то есть его элементы могут быть изменены в отличие от строки или кортежа.

Мы можем использовать оператор присваивания (=), чтобы изменить элемент или диапазон элементов.

odd = [2, 4, 6, 8]

# Изменение первого элемента 
odd[0] = 1
# Результат: [1, 4, 6, 8]
print(odd)

# Изменение элементов со 2го по 4й
odd[1:4] = [3, 5, 7] 
# Результат: [1, 3, 5, 7]
print(odd)

Мы можем добавить один элемент в список с помощью метода append() или несколько элементов с помощью метода extended().

odd = [1, 3, 5]

odd.append(7)
# Результат: [1, 3, 5, 7]
print(odd)

odd.extend([9, 11, 13])
# Результат: [1, 3, 5, 7, 9, 11, 13]
print(odd)

Мы также можем использовать оператор + для объединения двух списков. Это называется конкатенацией списка.

Оператор * повторяет список заданное количество раз.

odd = [1, 3, 5]

# Результат: [1, 3, 5, 9, 7, 5]
print(odd + [9, 7, 5])

# Результат: ["re", "re", "re"]
print(["re"] * 3)

Кроме того, мы можем вставить один или несколько элементов в нужное место с помощью метода insert().

odd = [1, 9]

odd.insert(1,3)
# Результат: [1, 3, 9] 
print(odd)

odd[2:2] = [5, 7]
# Результат: [1, 3, 5, 7, 9]
print(odd)

Как удалить элементы из списка

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

my_list = ['p','r','o','b','l','e','m']

# Удалить один элемент
del my_list[2]
# Результат: ['p', 'r', 'b', 'l', 'e', 'm'] 
print(my_list)

# Удалить несколько элементов
del my_list[1:5] 
# Результат: ['p', 'm']
print(my_list)

# Удалить весь список
del my_list 
# Результат: Error: List not defined
print(my_list)

Мы можем использовать метод remove() для удаления элемента или метод pop() для удаления элемента по указанному индексу.

Метод pop() удаляет последний элемент, если индекс не указан. Это помогает нам реализовывать списки в виде стеков «first come, last go» («первый вошел, последний вышел»).

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

my_list = ['p','r','o','b','l','e','m']
my_list.remove('p')
# Результат: ['r', 'o', 'b', 'l', 'e', 'm']
print(my_list)

# Результат: 'o'
print(my_list.pop(1))

# Результат: ['r', 'b', 'l', 'e', 'm']
print(my_list)
# Результат: 'm'
print(my_list.pop())

# Результат: ['r', 'b', 'l', 'e']
print(my_list)
my_list.clear()
# Результат: []
print(my_list)

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

>>> my_list = ['p','r','o','b','l','e','m']
>>> my_list[2:3] = []
>>> my_list
['p', 'r', 'b', 'l', 'e', 'm']
>>> my_list[2:5] = []
>>> my_list
['p', 'r', 'm']

Методы списков Python

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

  • append() — добавляет элемент в конец списка
  • extend() — добавляет все элементы списка в другой список
  • insert() — вставляет элемент по указанному индексу
  • remove() — удаляет элемент из списка
  • pop() — удаляет и возвращает элемент по указанному индексу
  • clear() — удаляет все элементы из списка (очищает список)
  • index() — возвращает индекс первого соответствующего элемента
  • count() — возвращает количество элементов, переданных в качестве аргумента
  • sort() — сортировка элементов в списке в порядке возрастания
  • reverse() — обратный порядок элементов в списке
  • copy() — возвращает поверхностную копию списка

Генератор списков: иной способ создания нового списка в Python

Генератор списка — это лаконичный способ создания нового списка из существующего списка в Python.

Генератор списка состоит из выражения, за которым следует оператор for в квадратных скобках.

В примере ниже, создается список, в котором каждый следующий элемент умножается на 2:

pow_new = [2 ** x for x in range(10)]
# Результат: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
print(pow_new)

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

pow_new = []
for x in range(10):
    pow_new.append(2 ** x)

Проверка существования элемента в списке

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

my_list = ['p','r','o','b','l','e','m']
# Результат: True
print('p' in my_list)
# Результат: False
print('a' in my_list)
# Результат: True
print('c' not in my_list)

Итерация по списку (перебор списка)

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

for fruit in ['apple','banana','mango']:
    print("I like",fruit)

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

Python | Списки

Список

Последнее обновление: 20.06.2017

Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.

Список (list) представляет тип данных, который хранит набор или последовательность элементов. Для создания списка в квадратных скобках ([]) через запятую перечисляются все его элементы. Во многих языках программирования есть аналогичная структура данных, которая называется массив. Например, определим список чисел:


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

Также для создания списка можно использовать конструктор list():


numbers1 = []
numbers2 = list()

Оба этих определения списка аналогичны — они создают пустой список.

Конструктор list для создания списока может принимать другой список:


numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers2 = list(numbers)

Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть второй элемент будет иметь индекс 1. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего — -2 и так далее.


numbers = [1, 2, 3, 4, 5]
print(numbers[0])   # 1
print(numbers[2])   # 3
print(numbers[-3])  # 3

numbers[0] = 125  # изменяем первый элемент списка
print(numbers[0])   # 125

Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *. Например, определим список из шести пятерок:


numbers = [5] * 6  # [5, 5, 5, 5, 5, 5]
print(numbers)

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

  • range(end): создается набор чисел от 0 до числа end

  • range(start, end): создается набор чисел от числа start до числа end

  • range(start, end, step): создается набор чисел от числа start до числа end с шагом step


numbers = list(range(10))
print(numbers)      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers = list(range(2, 10))
print(numbers)      # [2, 3, 4, 5, 6, 7, 8, 9]
numbers = list(range(10, 2, -2))
print(numbers)      # [10, 8, 6, 4]

Например, следующие два определения списка будут аналогичны, но за счет функции range мы сокращаем объем кода:


numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers2 = list(range(1, 10))

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

objects = [1, 2.6, "Hello", True]

Перебор элементов

Для перебора элементов можно использовать как цикл for, так и цикл while.

Перебор с помощью цикла for:


companies = ["Microsoft", "Google", "Oracle", "Apple"]
for item in companies:
    print(item)

Здесь вместо функции range мы сразу можем подставить имеющийся список companies.

Перебор с помощью цикла while:


companies = ["Microsoft", "Google", "Oracle", "Apple"]
i = 0
while i < len(companies):
    print(companies[i])
    i += 1

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

Сравнение списков

Два списка считаются равными, если они содержат один и тот же набор элементов:


numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers2 = list(range(1,10))
if numbers == numbers2:
    print("numbers equal to numbers2")
else:
    print("numbers is not equal to numbers2")

В данном случае оба списка будут равны.

Методы и функции по работе со списками

Для управления элементами списки имеют целый ряд методов. Некоторые из них:

  • append(item): добавляет элемент item в конец списка

  • insert(index, item): добавляет элемент item в список по индексу index

  • remove(item): удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError

  • clear(): удаление всех элементов из списка

  • index(item): возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError

  • pop([index]): удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.

  • count(item): возвращает количество вхождений элемента item в список

  • sort([key]): сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.

  • reverse(): расставляет все элементы в списке в обратном порядке

Кроме того, Python предоставляет ряд встроенных функций для работы со списками:

  • len(list): возвращает длину списка

  • sorted(list, [key]): возвращает отсортированный список

  • min(list): возвращает наименьший элемент списка

  • max(list): возвращает наибольший элемент списка

Добавление и удаление элементов

Для добавления элемента применяются методы append() и insert, а для удаления — методы remove(), pop() и clear().

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


users = ["Tom", "Bob"]

# добавляем в конец списка
users.append("Alice")  # ["Tom", "Bob", "Alice"]
# добавляем на вторую позицию
users.insert(1, "Bill")          # ["Tom", "Bill", "Bob", "Alice"]

# получаем индекс элемента
i = users.index("Tom")
# удаляем по этому индексу
removed_item = users.pop(i)            # ["Bill", "Bob", "Alice"]

last_user = users[-1]
# удаляем последний элемент
users.remove(last_user)           # ["Bill", "Bob"]

print(users)

# удаляем все элементы
users.clear()

Проверка наличия элемента

Если определенный элемент не найден, то методы remove и index генерируют исключение. Чтобы избежать подобной ситуации, перед операцией с элементом можно проверять его наличие с помощью ключевого слова in:


companies = ["Microsoft", "Google", "Oracle", "Apple"]
item = "Oracle"  # элемент для удаления
if item in companies:
    companies.remove(item)

print(companies)

Выражение item in companies возвращает True, если элемент item имеется в списке companies. Поэтому конструкция if item in companies может выполнить последующий блок инструкций в зависимости от наличия элемента в списке.

Подсчет вхождений

Если необходимо узнать, сколько раз в списке присутствует тот или иной элемент, то можно применить метод count():


users = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"]

users_count = users.count("Tom")
print(users_count)      # 3

Сортировка

Для сортировки по возрастанию применяется метод sort():


users = ["Tom", "Bob", "Alice", "Sam", "Bill"]

users.sort()
print(users)      # ["Alice", "Bill", "Bob", "Sam", "Tom"]

Если необходимо отсортировать данные в обратном порядке, то мы можем после сортировки применить метод reverse():


users = ["Tom", "Bob", "Alice", "Sam", "Bill"]

users.sort()
users.reverse()
print(users)      # ["Tom", "Sam", "Bob", "Bill", "Alice"]

При сортировке фактически сравниваются два объекта, и который из них «меньше», ставится перед тем, который «больше». Понятия «больше» и «меньше» довольно условны. И если для чисел все просто — числа расставляются в порядке возрастания, то для строк и других объектов ситуация сложнее. В частности, строки оцениваются по первым символам. Если первые символы равны, оцениваются вторые символы и так далее. При чем цифровой символ считается «меньше», чем алфавитный заглавный символ, а заглавный символ считается меньше, чем строчный. Подробнее про сравнение строк описывалось в статье Операции со строками.

Таким образом, если в списке сочетаются строки с верхним и нижним регистром, то мы можем получить не совсем корректные результаты, так как для нас строка «bob» должна стоять до строки «Tom». И чтобы изменить стандартное поведение сортировки, мы можем передать в метод sort() в качестве параметра функцию:


users = ["Tom", "bob", "alice", "Sam", "Bill"]

users.sort(key=str.lower)
print(users)      # ["alice", "Bill", "bob", "Sam", "Tom"]

Кроме метода sort мы можем использовать встроенную функцию sorted, которая имеет две формы:

  • sorted(list): сортирует список list

  • sorted(list, key): сортирует список list, применяя к элементам функцию key


users = ["Tom", "bob", "alice", "Sam", "Bill"]

sorted_users = sorted(users, key=str.lower)
print(sorted_users)      # ["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) тип, поэтому если обе переменных будут указывать на один и тот же список, то изменение одной переменной, затронет и другую переменную:


users1 = ["Tom", "Bob", "Alice"]
users2 = users1
users2.append("Sam")
# users1 и users2 указывают на один и тот же список
print(users1)   # ["Tom", "Bob", "Alice", "Sam"]
print(users2)   # ["Tom", "Bob", "Alice", "Sam"]

Это так называемое «поверхностное копирование» (shallow copy). И, как правило, такое поведение нежелательное. И чтобы происходило копирование элементов, но при этом переменные указывали на разные списки, необходимо выполнить глубокое копирование (deep copy). Для этого можно использовать метод deepcopy(), который определен во встроенном модуле copy:


import copy

users1 = ["Tom", "Bob", "Alice"]
users2 = copy.deepcopy(users1)
users2.append("Sam")
# пееменные users1 и users2 указывают на разные списки
print(users1)   # ["Tom", "Bob", "Alice"]
print(users2)   # ["Tom", "Bob", "Alice", "Sam"]

Копирование части списка

Если необходимо скопировать не весь список, а только его какую-то определенную часть, то мы можем применять специальный синтаксис. который может принимать следующие формы:

  • list[:end]: через параметр end передается индекс элемента, до которого нужно копировать список

  • list[start:end]: параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы

  • list[start:end:step]: параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.


users = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"]

slice_users1 = users[:3]   # с 0 по 3
print(slice_users1)   # ["Tom", "Bob", "Alice"]

slice_users2 = users[1:3]   # с 1 по 3
print(slice_users2)   # ["Bob", "Alice"]

slice_users3 = users[1:6:2]   # с 1 по 6 с шагом 2
print(slice_users3)   # ["Bob", "Sam", "Bill"]

Соединение списков

Для объединения списков применяется операция сложения (+):


users1 = ["Tom", "Bob", "Alice"]
users2 = ["Tom", "Sam", "Tim", "Bill"]
users3 = users1 + users2
print(users3)   # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]

Списки списков

Списки кроме стандартных данных типа строк, чисел, также могут содержать другие списки. Подобные списки можно ассоциировать с таблицами, где вложенные списки выполняют роль строк. Например:


users = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

print(users[0])         # ["Tom", 29]
print(users[0][0])      # Tom
print(users[0][1])      # 29

Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: users[0][1] — обращение ко второму элементу первого вложенного списка.

Добавление, удаление и исменение общего списка, а также вложенных списков аналогично тому, как это делается с обычными (одномерными) списками:


users = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

# создание вложенного списка
user = list()
user.append("Bill")
user.append(41)
# добавление вложенного списка
users.append(user)

print(users[-1])         # ["Bill", 41]

# добавление во вложенный список
users[-1].append("+79876543210")

print(users[-1])         # ["Bill", 41, "+79876543210"]

# удаление последнего элемента из вложенного списка
users[-1].pop()
print(users[-1])         # ["Bill", 41]

# удаление всего последнего вложенного списка
users.pop(-1)

# изменение первого элемента
users[0] = ["Sam", 18]
print(users)            # [ ["Sam", 18], ["Alice", 33], ["Bob", 27]]

Перебор вложенных списков:


users = [
    ["Tom", 29],
    ["Alice", 33],
    ["Bob", 27]
]

for user in users:
    for item in user:
        print(item, end=" | ")

Консольный вывод:


Tom | 29 | Alice | 33 | Bob | 27 | 
Базовые знания о списках в Python. Создание и наполнение списков
списки в Python, Списки в Python: Len, Pop, Index и List Comprehension

Списки Python похожи на массивы в JavaScript. Это один из встроенных типов данных, использующийся для хранения наборов данных.

В этой статье:

Базовое использование

Как создать список

Пустой список создается при помощи пары квадратных скобок:

empty_list = []
print(type(empty_list)) # <class 'list'>
print(len(empty_list)) # 0

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

homogeneous_list = [1, 1, 2, 3, 5, 8]
print(homogeneous_list) # [1, 1, 2, 3, 5, 8]
print(len(homogeneous_list)) # 6

heterogeneous_list = [1, "Hello, Pythonist!"]
print(heterogeneous_list) # [1, 'Hello, Pythonist!']
print(len(heterogeneous_list)) # 2

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

empty_list = list()  # Создаем пустой список
print(empty_list)  # []
new_list = list("Hello, Pythonist!")  # Новый список создается путем перебора заданного итерируемого объекта.
print(new_list)  # ['H', 'e', 'l', 'l', 'o', ',', ' ', 'P', 'y', 't', 'h', 'o', 'n', 'i', 's', 't', '!']

Также при создании списков используется List Comprehension, к которому мы еще вернемся.

Обращение к элементам списка

Вывод всего списка:

my_list = [1, 2, 9, 16, 25]
print(my_list)  # [1, 2, 9, 16, 25]

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

print(my_list[0])  # 1
print(my_list[1])  # 2
print(my_list[2])  # 9

В Python для обращения к элементам можно использовать и отрицательные индексы. При этом последний элемент в списке будет иметь индекс -1, предпоследний — -2 и так далее.

print(my_list[-1])  # 25
print(my_list[-2])  # 16
print(my_list[-3])  # 9

Распаковка списков (для python-3). Если поставить перед именем списка звездочку, все элементы этого списка будут переданы функции в качестве отдельных аргументов.

my_list = [1, 2, 9, 16, 25]
print(my_list)  # [1, 2, 9, 16, 25]
print(*my_list)  # 1 2 9 16 25

words = ["I", "love", "Python", "I", "love"]
print(words)  # ['I', 'love', 'Python', 'I', 'love']
print(*words)  # I love Python I love

Списки мутабельны

Списки — это изменяемые контейнеры. То есть, вы можете изменять содержимое списка, добавляя и удаляя элементы.

Элементы списка можно перегруппировать, используя для индексирования другой список.

Создадим новый список из элементов списка my_list, а индексы нужных элементов возьмем из списка my_index:

my_list = [1, 2, 9, 16, 25, 34, 53, 21]
my_index = [5, 2, 0]
my_new_list = [my_list[i] for i in my_index]
print(my_new_list)  # [34, 9, 1]

Методы списков

len()

Метод len() возвращает длину объекта (списка, строки, кортежа или словаря).

len() принимает один аргумент, который может быть или последовательностью (например, строка, байты, кортеж, список, диапазон), или коллекцией (например, словарь, множество, frozenset).

list1 = [123, 'abc', 'apple']  # список
print(len(list1)) # в списке 3 элемента, в выводе команды будет "3"

str1 = 'basketball'  # строка
print(len(str1))  # в строке 9 букв, в выводе команды будет "9"

tuple1 = (2, 3, 4, 5)  # кортеж
print(len(tuple1))  # в кортеже 4 элемента, в выводе команды будет "4"

dict1 = {'name': 'John', 'age': 4, 'score': 45} # словарь
print(len(dict1))  # в словаре 3 пары ключ-значение, в выводе команды будет "3"

index()

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

numbers = [1, 2, 2, 3, 9, 5, 6, 10]
words = ["I", "love", "Python", "I", "love"]

print(numbers.index(9)) # 4
print(numbers.index(2)) # 1
print(words.index("I")) # 0
print(words.index("JavaScript")) # возвращает ValueError, поскольку 'JavaScript' в списке 'words' нет

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

Цифра «2» встречается в списке дважды, первое ее вхождение имеет индекс 1, второе — 2. Метод index() возвращает индекс 1.

Аналогично возвращается индекс 0 для элемента «I».

Если элемент, переданный в качестве аргумента, вообще не встречается в списке, вернется ValueError. Так получилось с попыткой выяснить индекс «JavaScript» в списке words.

Опциональные аргументы

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

words = ["I", "am", "a", "I", "am", "Pythonista"]
print(words.index("am", 2, 5)) # 4

Метод index() будет искать элемент «am» в диапазоне от элемента с индексом 2 (включительно) до элемента с индексом 5 (этот последний элемент не входит в диапазон).

При этом возвращаемый индекс — индекс элемента в целом списке, а не в указанном диапазоне.

pop()

Метод pop() удаляет и возвращает последний элемент списка.

Этому методу можно передавать в качестве параметра индекс элемента, который вы хотите удалить (это опционально). Если конкретный индекс не указан, метод pop() удаляет и возвращает последний элемент списка.

Если в списке нет указанного вами индекса, метод выбросит exception IndexError: pop index out of range.

cities = ['New York', 'Dallas', 'San Antonio', 'Houston', 'San Francisco']

print "City popped is: ", cities.pop() # City popped is: San Francisco
print "City at index 2 is  : ", cities.pop(2) # City at index 2 is: San Antonio

Базовый функционал стека

Для реализации базового функционала стека в программах на Python часто используется связка метода pop() и метода append():

stack = []

for i in range(5):
    stack.append(i)

while len(stack):
    print(stack.pop())

List Comprehension

List Comprehension это создание списка путем итерации в цикле уже существующего списка (с соблюдением указанных условий). Поначалу такой подход может казаться сложным, но когда разберетесь, вы поймете, насколько это просто и быстро.

Чтобы разобраться в list comprehension, нужно для начала обратиться к обычной итерации списка. В следующем простом примере показано, как вернуть новый список, состоящий только из четных чисел старого.

# просто любой список чисел
some_list = [1, 2, 5, 7, 8, 10]

# пустой список, который будет заполняться четными числами из первого списка
even_list = []

for number in some_list:
  if number % 2 == 0:
    even_list.append(number)

print(even_list) # [2, 8, 10]

Давайте разберем этот пример. Сначала мы создаем список с числами. Затем создаем пустой список, в котором будут сохраняться результаты, полученные в цикле. Дальше идет сам цикл, в котором мы перебираем числа из первого списка и проверяем, являются ли они четными. Если число делится на 2 без остатка, мы добавляем его в список четных чисел. Для получения нужного результата нам потребуется 5 строк кода (без учета комментариев), да еще пробелы.

А теперь давайте посмотрим пример, в котором мы делаем все то же самое, но с помощью list comprehension.

# просто любой список чисел
some_list = [1, 2, 5, 7, 8, 10]

# List Comprehension
even_list = [number for number in some_list if number % 2 == 0]
print(even_list) # [2, 8, 10]

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

my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = []

for item in my_starting_list:
    my_new_list.append(item * 7)
print(my_new_list)  # [7, 14, 21, 28, 35, 42, 49, 56]

С помощью list comprehension можно достичь того же результата:

my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
my_new_list = [item * 7 for item in my_starting_list]

print(my_new_list)  # [7, 14, 21, 28, 35, 42, 49, 56]

Вообще list comprehension пишется в соответствии со следующей формулой:

my_list = [{operation with input n} for n in {python iterable}]

В блоке {operation with input n} вы указываете, что конкретно нужно сделать с элементом, который возвращает итерация объекта. В нашем примере это n * 7, но операция может быть любой, как очень простой, так и очень сложной.

В блок {python iterable} нужно вставить имя объекта, который вы будете перебирать в цикле. В нашем примере это был список, но мог быть кортеж или диапазон.

List comprehension добавляет элемент из существующего списка в новый, если соблюдается какое-то условие. Этот способ лаконичнее, а в большинстве случаев еще и намного быстрее. Иногда применение list comprehension может ухудшить читаемость кода, поэтому разработчику нужно действовать по ситуации.

Примеры использования list comprehension с условиями

Вносим в новый список только четные числа:

only_even_list = [i for i in range(13) if i%2==0]
print(only_even_list)  # [0, 2, 4, 6, 8, 10, 12]

Это эквивалентно следующему циклу:

only_even_list = list()
for i in range(13):
  if i%2 == 0:
    only_even_list.append(i)
print(only_even_list)  # [0, 2, 4, 6, 8, 10, 12]

List comprehension может также содержать вложенные if-условия. Обратите внимание на следующий пример:

divisible = list()
for i in range(50):
  if i % 2 == 0:
    if i % 3 == 0:
      divisible.append(i)
print(divisible)  # [0, 6, 12, 18, 24, 30, 36, 42, 48]

С применением list comprehension этот код можно переписать следующим образом:

divisible = [i for i in range(50) if i % 2 == 0 if i % 3 == 0]
print(divisible)  # [0, 6, 12, 18, 24, 30, 36, 42, 48]

С list comprehension также может использоваться if-else. В следующем примере мы берем диапазон чисел от 0 до 10 и добавляем в наш список все четные числа из этого диапазона, а нечетные добавляем после умножения на -1.

list_1 = [i if i % 2 == 0 else i * -1 for i in range(10)]
print(list_1)  # [0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

Списки в Python

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

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

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

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

Создание списков в Python. Объединение списков в Python. Функция list() в Python

list2-20219-fc28e3.jpg

Популярность Python обуславливается его относительной простотой и широкими функциональными возможностями. Среди них — успешная работа со структурами данных — это списки, кортежи, словари и множества. В нашей сегодняшней статье мы разберёмся со списками, поговорим про добавление и поиск элементов, а напоследок подробно расскажем об особенностях сортировки в Python.

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

Список (list) представляет собой структуру данных, предназначенную для хранения объектов. При этом не стоит путать список с массивом.

Некоторые особенности списка в Python: — в списке можно хранить элементы разных типов; — размер списка можно изменять.

Как хранятся списки в памяти?

Во время создания списка в Python происходит резервирование пустой области в памяти. Условно можно сказать, что это некий контейнер, где содержатся ссылки на другие элементы данных. Однако в отличие от таких данных, как строка либо число, содержимое контейнера списка может меняться.

Чтобы лучше представлять вышеописанный процесс, посмотрим на картинку. Мы увидим список, который содержит ссылки на объекты 1 и 2. При этом после выполнения операции a[1] = 3, вторая ссылка станет указывать на объект № 3 (в Питоне элементы списка нумеруются, начиная с нуля).

list1-20219-29deeb.jpg

Создание, удаление и изменение списков, а также работа с его элементами

Создать список в Python можно следующим способом:

>>> a = []
>>> type(a)
<class 'list'>
>>> b = list()
>>> type(b)
<class 'list'>

Кроме того, возможно создание списка с заранее известным набором данных:

>>> a = [1, 2, 3]
>>> type(a)
<class 'list'>

Если список уже есть и нужно создать копию, это тоже не проблема:

>>> a = [1, 3, 5, 7]
>>> b = list(a)
>>> print(a)
[1, 3, 5, 7]
>>> print(b)
[1, 3, 5, 7]

Обратите внимание, что если вы делаете простое присваивание списков друг другу, то переменной (в нашем примере это b) присваивается ссылка на тот же самый элемент данных в памяти, как и в списке a (не на копию списка a). Таким образом, если захотите изменить список a, b тоже будет меняться.

>>> a = [1, 3, 5, 7]
>>> b = a
>>> print(a)
[1, 3, 5, 7]
>>> print(b)
[1, 3, 5, 7]
>>> a[1] = 10
>>> print(a)
[1, 10, 5, 7]
>>> print(b)
[1, 10, 5, 7]

Если нужно добавить элемент в список, используем метод append():

>>> a = []
>>> a.append(3)
>>> a.append("hello")
>>> print(a)
[3, 'hello']

А если требуется удалить элемент из списка в том случае, когда его значение известно, рекомендуется применение метода remove(x), который удалит первую ссылку на этот элемент:

>>> b = [2, 3, 5]
>>> print(b)
[2, 3, 5]
>>> b.remove(3)
>>> print(b)
[2, 5]

Для удаления элемента по индексу подходит команда del имя_списка[индекс]:

>>> c = [3, 5, 1, 9, 6]
>>> print(c)
[3, 5, 1, 9, 6]
>>> del c[2]
>>> print(c)
[3, 5, 9, 6]

Кроме того, можно изменить элемент списка в Python (его значение), напрямую к нему обратившись. Но для этого надо знать индекс элемента:

>>> d = [2, 4, 9]
>>> print(d)
[2, 4, 9]
>>> d[1] = 17
>>> print(d)
[2, 17, 9]

А что нужно сделать, если требуется очистить список в Python? Для этого можно заново его проинициализировать, как будто вновь его создаёте. А чтобы получить доступ к элементу списка, поместите индекс данного элемента в квадратные скобки:

>>> a = [3, 5, 7, 10, 3, 2, 6, 0]
>>> a[2]
7

Можно применять и отрицательные индексы (счёт пойдёт с конца). Например, чтобы получить доступ к последнему элементу списка в Python, используют следующую команду:


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


Объединить списки в Python тоже несложно. Объединение легко сделать с помощью метода extend:

combo_list = [1]
one_list = [4, 5]
a = combo_list.extend(one_list)
print(a) # [1, 4, 5]

Также в Python можно объединить список с другим, просто добавив их вместе. Это довольно простой способ объединения:

my_list = [1, 2, 3]
my_list2 = ["a", "b", "c"]
combo_list = my_list + my_list2
print(combo_list) # [1, 2, 3, 'a', 'b', 'c']

Как видите, объединить списки достаточно легко.

Закрепляем методы списков в Python

Знание соответствующих методов и функций в Python позволит выполнить поиск, добавить нужный элемент, сделать сортировку и т. д. Итак, давайте перечислим основные методы списков и их функции (вспомним те, что уже упоминали, плюс добавим новые): 1.list.append(x) — обеспечивает добавление элемента в конец списка:

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

2.list.extend(L) — расширяет имеющийся список путем добавления элементов из списка L.

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

3.list.insert(i, x) — добавляет, а точнее, вставляет элемент х в позицию i. В качестве первого аргумента выступает индекс элемента, после которого вставляется элемент х.

>>> a = [1, 2]
>>> a.insert(0, 5)
>>> print(a)
[5, 1, 2]
>>> a.insert(len(a), 9)
>>> print(a)
[5, 1, 2, 9]

4.list.remove(x) — служит для удаления первого вхождения элемента х, включённого в наш список.

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

5.list.pop([i]) — обеспечивает удаление элемента из позиции i. Если применять метод без аргумента, удаляется последний элемент, находящийся в списке.

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

6.list.clear() — просто удаляет все элементы:

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

7.list.index(x[, start[, end]]) — позволяет вернуть индекс элемента:

>>> a = [1, 2, 3, 4, 5]
>>> a.index(4)
3

8.list.count(x) — возвращает число вхождений элемента х:

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

9.list.sort(key=None, reverse=False) — сортирует элементы списков по возрастанию. Чтобы выполнить сортировку в обратном порядке используют флаг reverse=True. Кроме того, дополнительные возможности открываются параметром key.

>>> a = [1, 4, 2, 8, 1]
>>> a.sort()
>>> print(a)
[1, 1, 2, 4, 8]

10.list.reverse() — порядок расположения элементов меняется на обратный:

>>> a = [1, 3, 5, 7]
>>> a.reverse()
>>> print(a)
[7, 5, 3, 1]

11.list.copy() — копирует списки:

>>> a = [1, 7, 9]
>>> b = a.copy()
>>> print(a)
[1, 7, 9]
>>> print(b)
[1, 7, 9]
>>> b[0] = 8
>>> print(a)
[1, 7, 9]
>>> print(b)
[8, 7, 9]

Сортировка с помощью функции sorted()

Давайте ещё раз вернёмся к вопросу сортировки в Python. Чтобы отсортировать данные и найти нужные значения, используют простую встроенную функцию sorted(), принимающую итерируемый тип и возвращающую отсортированный список.

Стандартная сортировка:

a = [3, 2, 5 ,4, 7, 1]
a = sorted(a)
 print(a) # [1, 2, 3, 4, 5, 7]

Сортировка кортежа:

t = ('Zane', 'Bob', 'Janet')
t = sorted(t)
 print(t) # ['Bob', 'Janet', 'Zane']

Сортировка словаря:

d = {1:'a', 2:'b', 3:'c'}
d = sorted(d)
print(d) # [1, 2, 3]

Помните, что функция sorted() возвратит список каждый раз вне зависимости от того, какой тип будет передан.

Идём дальше. Мы уже упоминали ранее метод list.sort(). Так вот, он определён только для списков, зато функция sorted() позволит отсортировать любые итерируемые объекты:

>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

Сортировка по убыванию и возрастанию в Python

Ранее упомянутый параметр reverse есть не только у метода list.sort(), но и у функции sorted(). Он принимает boolean-значение и нужен для сортировки по убыванию либо возрастанию. Ниже мы сортируем учеников по убыванию их возраста:

>>> sorted(student_tuples, key=itemgetter(2), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(student_objects, key=attrgetter('age'), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

Стабильность сортировки, сложная сортировка

Начиная с Python версии 2.2, сортировки гарантированно стабильны. Речь о том, что если у записей одинаковые ключи, их порядок не меняется.

>>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
>>> sorted(data, key=itemgetter(0))
[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]

Здесь 2 записи с ‘blue’ сохранили изначальный порядок. Данное свойство позволяет сортировать сложные данные путём постепенных сортировок. Например, надо найти и отсортировать данные учеников как по возрасту в возрастающем порядке, так и по оценкам в порядке убывания. Сортировка буде выглядеть так:

>>> s = sorted(student_objects, key=attrgetter('age'))     # по вторичному ключу
>>> sorted(s, key=attrgetter('grade'), reverse=True)       # по первичному
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Остались вопросы? Хотите поделиться своим личным опытом работы со списками? Нашли ошибку в тексте? Пишите комментарий!

python — как создать список списков

Переполнение стека
  1. Товары
  2. Клиенты
  3. Случаи использования
  1. Переполнение стека Публичные вопросы и ответы
  2. Команды Частные вопросы и ответы для вашей команды
  3. предприятие Частные вопросы и ответы для вашего предприятия
  4. работы Программирование и связанные с ним технические возможности карьерного роста
  5. Талант Нанимать технический талант
  6. реклама Связаться с разработчиками по всему миру

Загрузка…

,

Введение в списки Python

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

    стек = []
    stack.append (объект)
    object = stack.pop () 
    очередь = []
    queue.append (объект)
    object = queue.pop (0) 

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

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

    lru.remove (пункт)
    lru.append (item) 

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

Поиск в списках #

Оператор в можно использовать для проверки наличия элемента в списке:

    если значение в L:
        напечатать «список содержит», значение 

Чтобы получить индекс первого соответствующего элемента, используйте индекс :

    i = L.index (значение) 

Метод index выполняет линейный поиск и останавливается на первый соответствующий элемент. Если не найдено ни одного подходящего элемента, возникает ValueError исключение.

    пытаться:
        я = L.index (значение)
    кроме ValueError:
        я = -1 

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

    я = -1
    пытаться:
        пока 1:
            i = L.index (значение, i + 1)
            выведите «match at», я
    кроме ValueError:
        pass 

Перемещение цикла в вспомогательную функцию упрощает использование:

    def findall (L, значение, начало = 0):
        
        я = начало - 1
        пытаться:
            я = L.индекс (значение, я + 1)
            уступить я
        кроме ValueError:
            проходить

    для индекса в findall (L, значение):
        выведите «match at», i 

Для подсчета подходящих предметов используйте метод count :

    n = L.count (значение) 

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

Чтобы получить самый маленький или самый большой элемент в списке, используйте встроенный Функции мин и макс :

    lo = мин (л)
    hi = max (L) 

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

    lo = min (L, ключ = int)
    hi = max (L, key = int) 
Сортировка списков

#

Метод сортировки сортирует список по месту.

    L.sort () 

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

    out = sorted (L) 

Сортировка на месте немного более эффективна, так как Python делает не нужно выделять новый список для хранения результата.

По умолчанию алгоритм сортировки Python определяет порядок по сравнивая объекты в списке друг с другом. Ты можешь переопределить это, передав вызываемый объект, который принимает два элемента, и возвращает -1 для «меньше чем», 0 для «равно» и 1 для «больше» чем».Для этого часто используется встроенная функция cmp :

    def сравнить (a, b):
        вернуть cmp (int (a), int (b))

    L.sort (ср)

    def Compare_columns (a, b):
        
        вернуть cmp (a [0], b [0]) или cmp (b [2], a [2])

    out = sorted (L, compare_columns) 

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

    L.sort (ключ = целое)

    out = sorted (L, key = int) 

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

Сортировка Python стабильна; порядок предметов, которые сравниваются равным будет быть сохраненным.

Печать списков #

По умолчанию тип списка делает repr для всех элементов и добавляет скобки и запятые при необходимости. Другими словами, для встроенных типов напечатанный список выглядит как соответствующий список:

    print [1, 2, 3] 

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

    печать ""

    печать "," .join (карта (ул., L))

    выведите «|» .join (str (v) для v в L, если v> 0) 

Чтобы напечатать список фрагментов строки в файл, вы можете использовать writelines вместо напишите :

    sys.stdout.writelines (L) 

Замечания по производительности #

Объект списка состоит из двух внутренних частей; один заголовок объекта, и один отдельно выделенный массив ссылок на объекты. Последний является перераспределяется по мере необходимости.

Список имеет следующие характеристики производительности:

  • Объект списка хранит указатели на объекты, а не на реальные объекты самих себя. Размер списка в памяти зависит от количества объекты в списке, а не размер объектов.
  • Время, необходимое для получения или установки отдельного элемента, постоянно, нет независимо от того, какой размер списка (также известный как «O (1)» поведение).
  • Время, необходимое для добавления элемента в список, — «постоянная амортизации»; всякий раз, когда список должен выделить больше памяти, он выделяет место для на несколько пунктов больше, чем нужно, чтобы избежать перераспределять при каждом вызове (это предполагает, что распределитель памяти быстрый; для огромных списков издержки выделения могут подтолкнуть поведение к O (n * n)).
  • Время, необходимое для вставки предмета, зависит от размера список, а точнее, сколько предметов, которые находятся справа от вставленный элемент (O (n)). Другими словами, вставка элементов в конец быстрый, но вставка элементов в начале может быть относительно медленно, если список большой.
  • Время, необходимое для удаления предмета, примерно равно времени необходимо вставить элемент в том же месте; удаление предметов в конец быстрый, удаление предметов в начале медленное.
  • Время, необходимое для обращения к списку, пропорционально размеру списка (На)).
  • Время, необходимое для сортировки списка, варьируется; наихудший случай O (n log n), но типичные случаи часто намного лучше, чем это.

Последнее обновление: ноябрь 2006 г.

.
Как создать список и инициализировать с теми же значениями — thispointer.com

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

Создание списка одинаковых значений с помощью [] и умножение

Предположим, что мы хотим создать список строк, который содержит 20 одинаковых строк, т.е. «Hi»

 [«Hi», «Hi», «Hi», «Hi», «Hi», «Hi», «Hi» ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ',' Привет ', «Привет»] 

Давайте посмотрим, как это сделать.е.
 '' 'создать список с помощью [] и умножить на количество повторений' ''
listOfStrings1 = ['Hi'] * 20
 

[‘Hi’] создаст список с одним значением, затем мы умножим этот список на 20. Он будет повторять содержимое списка 20 раз.
Итак, содержимое списков теперь будет
 [«Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет»] 

Создание списка одинаковых значений с помощью понимания списка с помощью range ()

Это еще один способ создать список с тем же значением, используя range () i.е.

 '' '
    Использовать понимание списка с помощью range (), чтобы инициализировать список 20 элементами. 0
    Он будет перебирать танге от 0 до 20 и для
    каждая запись, он добавит «Привет» в список и в конце
    возвращает список в listOfNums
«»»
listOfStrings2 = ['Привет' для i в диапазоне (20)] 

В этом понимании списка цикл for будет перебирать объект диапазона 20 раз, и на каждой итерации он будет добавлять «Hi» в список.
Итак, список будет содержать 20 элементов «Привет» i.е.
 [«Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет»]
 

Полный пример выглядит следующим образом:
 def main ():
    
    '' 'создать список с помощью [] и умножить на количество повторений' ''
    listOfStrings1 = ['Hi'] * 20

    печать (listOfStrings1)
    

    «»»
    Использовать понимание списка с помощью range (), чтобы инициализировать список 20 элементами. 0
    Он будет перебирать танге от 0 до 20 и для
    каждая запись, он добавит «Привет» в список и в конце
    возвращает список в listOfNums
    «»»
    listOfStrings2 = ['Привет' для i в диапазоне (20)]
    
    печать (listOfStrings2)
    
    
если __name__ == '__main__':
    основной()
 

Выход:
 [«Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет»]
[«Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», «Привет», « Привет »,« Привет »,« Привет »,« Привет »,« Привет »,« Привет »,« Привет »,« Привет »]
 

,

Python — создать список с начальной емкостью

Переполнение стека
  1. Товары
  2. Клиенты
  3. Случаи использования
  1. Переполнение стека Публичные вопросы и ответы
  2. Команды Частные вопросы и ответы для вашей команды
  3. предприятие Частные вопросы и ответы для вашего предприятия
  4. работы Программирование и связанные с ним технические возможности карьерного роста
  5. Талант Нанимать технический талант
  6. реклама Связаться с разработчиками по всему миру
,