Список для. Список списков

Список списков в Python – это список, содержащий элементы, которые являются списками.

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

Список списков похож на двумерный массив. Внутренние списки могут иметь разные размеры.

Как определить?

В следующей программе мы определяем список, содержащий списки как элементы.

list_of_lists = [['a', 25, 69, 'Apple'],
[5, 'doll', 854, 41.2],
[8, 6, 'car', True]]

print(list_of_lists)

Вывод:

[['a', 25, 69, 'Apple'], [5, 'doll', 854, 41.2], [8, 6, 'car', True]]

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

Как перебрать?

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

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

list_of_lists = [['a', 25, 69, 'Apple'],
[5, 'doll', 854, 41.2],
[8, 6, 'car', True]]

i = 0
while i < len(list_of_lists): print(list_of_lists[i]) i += 1

Вывод:

['a', 25, 69, 'Apple']
[5, 'doll', 854, 41.2]
[8, 6, 'car', True]

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

list_of_lists = [['a', 25, 69, 'Apple'],
[5, 'doll', 854, 41.2],
[8, 6, 'car', True]]

for list_i in list_of_lists:
print(list_i)

Вывод:

['a', 25, 69, 'Apple']
[5, 'doll', 854, 41.2]
[8, 6, 'car', True]

Как удалить список?

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

В следующем примере мы будем использовать ключевое слово del для удаления списка с индексом 1.

list_of_lists = [['a', 25, 69, 'Apple'],
[5, 'doll', 854, 41.2],
[8, 6, 'car', True]]

del list_of_lists[1]

print(list_of_lists)

Вывод:

[['a', 25, 69, 'Apple'], [8, 6, 'car', True]]

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

Списки (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).

6 способов слияния списка списков

Зашел тут у нас в офисе разговор как наиболее «красиво» и быстро склеить список списков в Питоне. Действительно как? Даже такую казалось бы тривиальную задачу можно решить несколькими способами, существенно отличающимися по скорости и выразительности.

ВАРИАНТ1

Все знают, что элементы списка можно перебирать в цикле и, то что можно добавлять элементы в конец. Это приводит нас к первому варианту решения:def listmerge1(lstlst):     all=[]     for lst in lstlst:         for el in lst:             all.append(el)     return all Мало того, что функция растянулось аж на 6 строк, так вдобавок она еще и не эффективная. Попробуем её улучшить в обоих смыслах: скорости и красоты («pythonic way»). ВАРИАНТ2 Тут мы вспоминаем, что в Питоне есть оператор «+» для строк и получаем:def listmerge2(lstlst):     all=[]     for lst in lstlst:       all=all+lst     return all Это самая медленная реализация. Прокол в том что в таком виде оператор «+» в каждом шаге создает новый объект-список, который на следующем шаге выкидывается и т.д.

ВАРИАНТ3

Исправить легко, надо заменить «+» на форму которая не создает новый список, а добавляет к старому. Это оператор «+=», но я предпочитаю писать в явном виде метод «extend». Так мы получили самый быстрый вариант, но не самый короткий.def listmerge3(lstlst):     all=[]     for lst in lstlst:       all.extend(lst)     return all Все последующие решения я буду писать через лямбда-выражения, тк они состоят из одного выражения. Имя аргумента сокращено до ll, тк в коде в одну строку это не уменьшает читабельности.# через анонимную функцию  listmerge=lambda ll : simple-statement # эквивалентно def listmerge(ll):   return simple-statement ВАРИАНТ4 Используя встроенные функции работы со списками, можно переписать вариант2 в стиле функционального программирования:listmerge4a=lambda ll: reduce(lambda a,b: a+b, ll, []) listmerge4b=lambda ll: sum(ll, []) Он чуть чуть быстрее, но все еще тормозной по той же причине, что и его итеративный родственник. Здесь «lambda a,b: a+b» — анонимная функция двух аргументов, которая просто возвращает их сумму. Вариант B это просто шорткат, встроенный в Питон для удобста вычисления суммы элементов. Этот вариант самый короткий. Лично меня не устраивает ни самый короткий (скорость), ни самый быстрый (красота). Попробуем найти компромисс.

ВАРИАНТ5

С помощью списковых выражений:listmerge5=lambda ll: [el for lst in ll for el in lst] Не сильно длиннее предыдущего, но радикально быстрее. Вариант несомненно красив, хотя вложенные списковые выражения не всегда понятны с первого взгляда.

ВАРИАНТ6

А что если попробовать переписать самый быстрый вариант в функцональном стиле? Легко:listmerge6=lambda s: reduce(lambda d,el: d.extend(el) or d, s, []) Заметьте «d.extend(el) or d» нам пришлось добавить оператор «or» тк метод extend возвращает None. По скорости он практически не уступает самому быстрому методу №3 (разница в скорости буквально единицы процентов и на мой взгляд не существенна).

По моему мнению «выбор редакции» стоит присудить варианту №6)

Для замеров скорости маленьких кусков кода в Питоне есть библиотека timeit. Вот пример кода, тестирующего варианты 3, 5 и 6 (самые быстрые и красивые).

import timeit  

variants = {

 'Reduce' :  'listmerge=lambda s: reduce(lambda d,el: d.extend(el) or d, s, [])',  'Iterate' : «»» def listmerge(lstlst):   all=[]   for lst in lstlst:     all.extend(lst)   return all

«»»

,   'Comprehension' :   'listmerge=lambda ll: [x for lst in ll for x in lst]', }  

initstr='lstlst=[range(i) for i in range(1000)]
gc.enable()'

 

def test(variants, initstr,n=100):

  print «Test repeats n =»,n,» times
INITSTR:»,initstr,»

»   for k,v in variants.iteritems():     print k, » — «, timeit.Timer(«listmerge(lstlst)», initstr+»
«+v).timeit(n)   print  

test(variants,initstr,100)

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

Test repeats n = 100 times
INITSTR: lstlst=[range(i) for i in range(1000)]
gc.enable()

Iterate — 1.56133103371
Reduce — 1.57647109032
Comprehension — 7.5749669075

ДОМАШНЕЕ ЗАДАНИЕ

Предлагаю решить/обсудить более сложную задачу развертывание вложенных списков в линейный. Пример: # Исходный список: [7,[[[[2]]],[[[]],[4]],[4,5,[6,7]]],8] # Результат: [7, 2, 4, 4, 5, 6, 7, 8]

UPD: Ответ habrahabr.ru/blogs/python/63539/#comment_1764419

UPD2:

ВАРИАНТ 6Б

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

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

Создать списки Python

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

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

Список может выглядеть так:

my_list = ['один', 'два', 'три', 'четыре', 'пять']

Можно смешивать типы содержимого:

Читайте также:  Как играть в вызов духов с помощью монеты: по шагам

my_list = ['один', 10, 2.25, [5, 15], 'пять']

Поддерживаются вложенные списки как в примере выше.

Получать доступ к любому элементу списка можно через его индекс. В Python используется система индексации, начиная с нуля.

third_elem = my_list[2]

Принцип похож на строки.

Изменение списка

Списки — это изменяемые объекты, поэтому их элементы могут изменяться, или же может меняться их порядок.

Если есть такой список:

my_list = ['один', 'два', 'три', 'четыре', 'пять']

То его третий элемент можно изменить следующим образом:

my_list[2] = 'ноль'

Если сейчас вывести его на экран, то он будет выглядеть вот так:

['один', 'два', 'ноль', 'четыре', 'пять']

Если индекс — отрицательное число, то он будет считаться с последнего элемента.

my_list = ['один', 'два', 'три', 'четыре', 'пять'] elem = my_list[-1] print(elem)

Вывод этого кода — ‘пять’.

Проход (итерация) по списку

Читать элементы списка можно с помощью следующего цикла:

my_list = ['один', 'два', 'три', 'четыре', 'пять'] for elem in my_list: print(elem)

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

my_list = [1, 2, 3, 4, 5] for i in range(len(my_list)): my_list[i]+=5 print(my_list)

Результат будет следующим:

[6, 7, 8, 9, 10]

Функция len() используется для возврата количества элементов, а range() — списка индексов.

Стоит запомнить, что вложенный список — это всегда один элемент вне зависимости от количества его элементов.

my_list = ['один', 10, 2.25, [5, 15], 'пять'] print(len(my_list))

Результат кода выше — 5.

Срез списка

Можно получить срез списка с помощью оператора (:):

my_list = ['один', 'два', 'три', 'четыре', 'пять'] print(my_list[1:3])

  • Результат кода выше — ['два', 'три']
  • Если убрать первое число, от срез будет начинаться с первого элемента, а если второе — с последнего.
  • Если убрать числа и оставить только двоеточие, то скопируется весь список.

my_list = ['один', 'два', 'три', 'четыре', 'пять'] print(my_list[1:3]) print(my_list[1:]) print(my_list[:3]) print(my_list[:])

Результат этого года:

['два', 'три']
['два', 'три', 'четыре', 'пять']
['один', 'два', 'три']
['один', 'два', 'три', 'четыре', 'пять']

Поскольку списки изменяемые, менять элементы можно с помощью оператора среза:

my_list = ['один', 'два', 'три', 'четыре', 'пять'] my_list[1:3] = ['Привет', 'Мир'] print(my_list)

Результат:

['один', 'Привет', 'Мир', 'четыре', 'пять']

Вставить в список

Метод insert можно использовать, чтобы вставить элемент в список:

my_list = [1, 2, 3, 4, 5] my_list.insert(1,'Привет') print(my_list)

Результат:

[1, 'Привет', 2, 3, 4, 5]

Индексы для вставляемых элементов также начинаются с нуля.

Добавить в список

Метод append можно использовать для добавления элемента в список:

my_list = ['один', 'два', 'три', 'четыре', 'пять'] my_list.append('ещё один') print(my_list)

Результат:

['один', 'два', 'три', 'четыре', 'пять', 'ещё один']

Можно добавить и больше одного элемента таким способом:

my_list = ['один', 'два', 'три', 'четыре', 'пять'] list_2 = ['шесть', 'семь'] my_list.extend(list_2) print(my_list)

Результат:

['один', 'два', 'три', 'четыре', 'пять', 'шесть', 'семь']

При этом list_2 не поменяется.

Отсортировать список

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

my_list = ['cde', 'fgh', 'abc', 'klm', 'opq'] list_2 = [3, 5, 2, 4, 1] my_list.sort() list_2.sort() print(my_list) print(list_2)

Вывод:

['abc', 'cde', 'fgh', 'klm', 'opq']
[1, 2, 3, 4, 5]

Перевернуть список

Можно развернуть порядок элементов в списке с помощью метода reverse:

my_list = [1, 2, 3, 4, 5] my_list.reverse() print(my_list)

Результат:

[5, 4, 3, 2, 1]

Индекс элемента

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

my_list = ['один', 'два', 'три', 'четыре', 'пять'] print(my_list.index('два'))

Результат 1.

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

Удалить элемент

Удалить элемент можно, написав его индекс в методе pop:

my_list = ['один', 'два', 'три', 'четыре', 'пять'] removed = my_list.pop(2) print(my_list) print(removed)

Результат:

['один', 'два', 'четыре', 'пять']
три

Если не указывать индекс, то функция удалит последний элемент.

my_list = ['один', 'два', 'три', 'четыре', 'пять'] removed = my_list.pop() print(my_list) print(removed)

Результат:

['один', 'два', 'три', 'четыре']
пять

Элемент можно удалить с помощью метода remove.

my_list = ['один', 'два', 'три', 'четыре', 'пять'] my_list.remove('два') print(my_list)

Результат:

['один', 'три', 'четыре', 'пять']

Оператор del можно использовать для тех же целей:

my_list = ['один', 'два', 'три', 'четыре', 'пять'] del my_list[2] print(my_list)

Результат:

['один', 'два', 'четыре', 'пять']

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

my_list = ['один', 'два', 'три', 'четыре', 'пять'] del my_list[1:3] print(my_list)

Результат:

['один', 'четыре', 'пять']

Функции агрегации

В Python есть некоторые агрегатные функции:

my_list = [5, 3, 2, 4, 1] print(len(my_list)) print(min(my_list)) print(max(my_list)) print(sum(my_list))

sum() работает только с числовыми значениями.

А max(), len() и другие можно использовать и со строками.

Сравнить списки

В Python 2 сравнить элементы двух списком можно с помощью функции cmp:

my_list = ['один', 'два', 'три', 'четыре', 'пять'] list_2 = ['три', 'один', 'пять', 'два', 'четыре'] print(cmp(my_list,list_2))

Она вернет -1, если списки не совпадают, и 1 в противном случае.

В Python 3 для этого используется оператор (==):

my_list = ['один', 'два', 'три', 'четыре', 'пять'] list_2 = ['три', 'один', 'пять', 'два', 'четыре'] if (my_list == list_2): print('cовпадают') else: print('не совпадают')

Результат не совпадают.

Математические операции на списках:

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

list_1 = [1, 2, 3] list_2 = [4, 5, 6] print(list_1 + list_2)

Результат:

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

Список можно повторить с помощью оператора умножения:

list_1 = [1, 2, 3] print(list_1 * 2)

Результат:

[1, 2, 3, 1, 2, 3]

Списки и строки

Для конвертации строки в набор символов, можно использовать функцию list:

my_str = 'Monty Python' my_list = list(my_str) print(my_list)

Результат:

['M', 'o', 'n', 't', 'y', ' ', 'P', 'y', 't', 'h', 'o', 'n']

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

Можно использовать метод split для разбития строки на слова:

my_str = 'Monty Python' my_list = my_str.split() print(my_list)

Результат:

['Monty', 'Python']

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

Символом разбития может служить любой знак, а не только пробел.

my_str = 'Monty-Python' my_list = my_str.split('-') print(my_list)

Результат будет аналогичен:

['Monty', 'Python']

Объединить список в строку

Обратный процесс — объединение элементов списка в строку.

Это делается с помощью метода join:

my_list = ['Monty', 'Python']
delimiter = ' '
output = delimiter.join(my_list)
print(output)

Результат Monty Python.

Алиасинг (псевдонимы)

Когда две переменные ссылаются на один и тот же объект:

my_list = ['Monty', 'Python'] list_2 = my_list

Алиасинг значит, что на объект ссылается больше одного имени.

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

my_list = ['Monty', 'Python'] list_2 = my_list list_2[1] = 'Java:)' print(my_list)

Результат:

['Monty', 'Java:)']

Изменился список list_2, но поскольку он ссылается на один и тот же объект, то оригинальный список тоже поменялся.
Использовать “псевдонимы” при работе со списками не рекомендуется.

В целом, работать со списками в Python очень просто.

Интерактивный учебник языка Python

1. Списки

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

https://www.youtube.com/watch?v=CEQZYZMPJSU\u0026t=202s

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

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

Для хранения таких данных можно использовать структуру данных,
называемую в Питоне список (в большинстве же языков
программирования используется другой термин “массив”).
Список представляет собой последовательность элементов, пронумерованных
от 0, как символы в строке. Список можно задать перечислением элементов
списка в квадратных скобках, например, список можно задать так:

Primes = [2, 3, 5, 7, 11, 13]
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']

В списке Primes — 6 элементов, а именно:
Primes[0] == 2, Primes[1] == 3, Primes[2] == 5, Primes[3] == 7, Primes[4] == 11, Primes[5] == 13.
Список Rainbow состоит из 7 элементов, каждый из которых
является строкой.

  • Также как и символы в строке, элементы списка можно индексировать отрицательными
    числами с конца, например, Primes[-1] == 13, Primes[-6] == 2.
  • Длину списка, то есть количество элементов в нем, можно узнать при помощи функции
    len, например, len(Primes) == 6.
  • В отличие от строк, элементы списка можно изменять, присваивая им новые значения.

Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']
print(Rainbow[0])
Rainbow[0] = 'красный'
print('Выведем радугу')
for i in range(len(Rainbow)):
print(Rainbow[i])

Рассмотрим несколько способов создания и считывания списков. Прежде всего, можно создать
пустой список (не содержащий элементов, длины 0), а в конец списка можно добавлять элементы
при помощи метода append. Например, пусть программа получает на вход
количество элементов в списке n, а потом n элементов
списка по одному в отдельной строке. Вот пример входных данных в таком формате:

5
1809
1854
1860
1891
1925
В этом случае организовать считывание списка можно так: 5
1809
1854
1860
1891
1925 a = [] # заводим пустой список
n = int(input()) # считываем количество элемент в списке
for i in range(n):
new_element = int(input()) # считываем очередной элемент
a.append(new_element) # добавляем его в список
# последние две строки можно было заменить одной:
# a.append(int(input()))
print(a)

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

5
1809
1854
1860
1891
1925 a = []
for i in range(int(input())):
a.append(int(input()))
print(a)

Для списков целиком определены следующие операции: конкатенация списков
(сложение списков, т. е. приписывание к одному списку другого) и повторение списков (умножение списка
на число). Например:

a = [1, 2, 3]
b = [4, 5]
c = a + b
d = b * 3
print([7, 8] + [9])
print([0, 1] * 3)

В результате список c будет равен [1, 2, 3, 4, 5], а список
d будет равен [4, 5, 4, 5, 4, 5]. Это позволяет по-другому
организовать процесс считывания списков: сначала считать размер списка и создать список
из нужного числа элементов, затем организовать цикл по переменной i начиная
с числа 0 и внутри цикла считывается i-й элемент списка:

5
1809
1854
1860
1891
1925 a = [0] * int(input())
for i in range(len(a)):
a[i] = int(input())

Вывести элементы списка a можно одной инструкцией print(a),
при этом будут выведены квадратные скобки вокруг элементов списка и запятые между
элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы
списка в одну строку или по одному элементу в строке. Приведем два примера, также
отличающиеся организацией цикла:

a = [1, 2, 3, 4, 5]
for i in range(len(a)):
print(a[i])

Здесь в цикле меняется индекс элемента i, затем выводится элемент
списка с индексом i.

a = [1, 2, 3, 4, 5]
for elem in a:
print(elem, end=' ')

  1. В этом примере элементы списка выводятся в одну строку, разделенные пробелом,
    при этом в цикле меняется не индекс элемента списка, а само значение переменной
    (например, в цикле for elem in ['red', 'green', 'blue'] переменная
    elem будет последовательно принимать значения 'red',
    'green', 'blue'.

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

Последовательностями в Питоне являются строки, списки, значения функции range() (это не списки), и ещё кое-какие другие объекты.

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

# дано: s = 'ab12c59p7dq'
# надо: извлечь цифры в список digits,
# чтобы стало так:
# digits == [1, 2, 5, 9, 7]

s = 'ab12c59p7dq'
digits = []
for symbol in s:
if '1234567890'.find(symbol) != -1:
digits.append(int(symbol))
print(digits)

Работа со списками (list) в Python

02.05.2020

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

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

Список (list) – тип данных, предназначенный для хранения набора или последовательности разных элементов.[1, 33, 6, 9] # литерал списка в Python

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

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

Базовая C-структура списков в Python (CPython) выглядит следующим образом:

typedef struct {
PyObject_VAR_HEAD
PyObject **ob_item;
Py_ssize_t allocated;
} PyListObject;

Когда мы создаём список, в памяти под него резервируется объект, состоящий из 3-х частей:

  • PyObject_VAR_HEAD – заголовок;
  • ob_item – массив указателей на элементы списка;
  • allocated – количество выделенной памяти под элементы списка;

Объект списка хранит указатели на объекты, а не на сами объекты

Python размещает элементы списка в памяти, затем размещает указатели на эти элементы. Таким образом, список в Python – это массив указателей.

Список в Python – это массив указателей на элементы, размещенные в памяти

Базовая работа со списками

Объявление списка

Объявление списка – самый первый и главный этап его создания. Для объявления списка в Python существует несколько способов.

Вариант №1: Через литерал (выражение, создающее объект):

>>> elements = [1, 3, 5, 6]

>>> type(elements)

>>> print(elements)
[1, 3, 5, 6]

В данном примере мы создали список с заранее известными данными. Если нужен пустой список, в квадратных скобках ничего не указывается – elements = [] .

Вариант №2: Через функцию list():

>>> elements = list()

>>> type(elements)

>>> print(elements)
[]

В этом примере создается пустой список.

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

Некоторые операции, рассмотренные выше, имеют два варианта выбора элемента: либо выбор непосредственно его по имени, либо обращение по индексу. Индексом называют его порядковый номер, начиная с нуля.

Существует также отрицательный индекс, рассмотрим на примере:

elements = [1, 2, 3, 'word']

  • Индексы (позиции в списке) соответственно будут: 0, 1, 2, 3.
  • Нумерация элементов списка в Python начиная с нуля
  • Отрицательными индексами называют расположение элементов в списке справа налево, то есть индекс значения «1» будет -4, а отрицательный индекс 'word' будет -1.

>>> elements[-4]
1
>>> elements[-1]
'word'

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

Добавление в список

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

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

>>> elements = [1, 2, 3, 'word']
>>> elements.append('meow')

>>> print(elements)
[1, 2, 3, 'word', 'meow']

Для простого примера, рассмотрим создание списка с нуля с помощью метода append() :

>>> elements = []
>>> elements.append(1)
>>> elements.append('word')
>>> elements.append('meow')

>>> print(elements)
[1, 'word', 'meow']

Добавление в список на указанную позицию

Немаловажно обратить внимание на метод list.insert(i, x) , где list – список, i – позиция, x – нужное значение.

>>> elements = [1, 2, 4]
>>> print(elements)
[1, 2, 4]

>>> elements.insert(2, 3)
>>> print(elements)
[1, 2, 3, 4]

Изменение элементов списка

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

>>> elements = [2, 4, 6]
>>> elements[2] = 8

>>> print(elements)
[2, 4, 8]

В примере выше мы заменили 6 на 8.

Не забывайте, что счёт начинается с нуля, и в данном списке цифра 6 это 2-й элемент

Удаление элемента из списка

Для удаление из списка используют инструкцию del list[i] , где list – список, i – индекс (позиция) элемента в списке:

>>> elements = [1, «test», 5, 7]
>>> del elements[1]
>>> print(elements)
[1, 5, 7]

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

>>> my_list = [«hello», «world», «!»]
>>> elements = [1, my_list, «ok»]
>>> del elements[1][2]

>>> print(elements)
[1, ['hello', 'world'], 'ok']

Можно удалять целыми диапазонами:

>>> elements = [2, 4, 6, 8, 12]
>>> del elements[2:] # удаляем все элементы после 2-го элемента (включительно)
>>> print(elements)
[2, 4]

>>> elements = [2, 4, 6, 8, 12]
>>> del elements[:3] # удаляем все элементы до 3-го элемента
>>> print(elements)
[8, 12]

>>> elements = [2, 4, 6, 8, 12]
>>> del elements[1:3] # удаляем от 1-го элемента включительно до 3-го элемента
>>> print(elements)
[2, 8, 12]

Еще один способ удаления из списка – list.remove(x) , где list – список, x – значение, которое нужно удалить:

>>> elements = [2, «test», 4]
>>> elements.remove(«test»)
>>> print(elements)
[2, 4]

Как проверить наличие элемента в списке

Для того, чтобы проверить существование какого-либо элемента в списке, нужно воспользоваться оператором in . Рассмотрим на примере:

>>> elements = ['слон', 'кот', 'лошадь', 'змея', 'рыба']
>>> if 'кот' in elements:
print('meow')

meow

Объединение списков

Списки в Python можно объединят с помощью оператора + или метода extend . Выглядит это так:

>>> a = [1, 3, 5]
>>> b = [1, 2, 4, 6]
>>> print(a + b)
[1, 3, 5, 1, 2, 4, 6]

>>> hello = [«h», «e», «l», «l», «o»]
>>> world = [«w», «o», «r», «l», «d»]
>>> hello.extend(world) # extends не возвращает новый список, а дополняет текущий
>>> print(hello)
['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

Копирование списка Python

Если вы захотите скопировать список оператором = , вы скопируете не сам список, а только его ссылку.

>>> a = [1, 2, 3]
>>> b = a # переменно b присваивается не значение списка a, а его адрес

>>> print(id(a), id(b))
56466376 56466376 # a и b ссылаются на один и тот же список

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

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

  • elements.copy() – встроенный метод copy (доступен с Python 3.3);
  • list(elements) – через встроенную функцию list() ;
  • copy.copy(elements) – функция copy() из пакета copy;
  • elements[:] – через создание среза (устаревший синтаксис);

Рассмотрим на примере каждый из этих способов:

>>> a = [«кот», «слон», «змея»]

>>> b = a.copy()
>>> print(id(a), id(b), a, b)
56467336 56467016 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

>>> d = list(a)
>>> print(id(a), id(d), a, d)
56467336 60493768 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

>>> import copy
>>> e = copy.copy(a) #
>>> print(id(a), id(e), a, e)
56467336 60491304 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

>>> f = copy.deepcopy(a)
>>> print(id(a), id(f), a, f)
56467336 56467400 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

>>> c = a[:] # устаревший синтаксис
>>> print(id(a), id(c), a, c)
56467336 60458408 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

Важно: copy.copy(a) делает поверхностное копирование. Объекты внутри списка будут скопированы как ссылки на них (как в случае с оператором = ). Если необходимо рекурсивно копировать всех элементов в списке, используйте copy.deepcopy(a)

Скопировать часть списка можно с помощью срезов. Есть несколько вариантов использования:

>>> a = [«кот», «слон», «змея»]

>>> b = a[2:] # с 2-го элемента (включительно) до конца списка
>>> print(b)
['змея']

>>> c = a[:2] # с начала списка по 2-й элемент
>>> print(c)
['кот', 'слон']

>>> d = a[1:2] # с 1-го элемента (включительно) по 2-й элемент
>>> print(d)
['слон']

>>> a = [1, 2, 3, 4, 5, 6, 7, 8]
>>> e = a[0:8:2] # c 0-го элемента по 8-й элемент с шагом 2
>>> print(e)
[1, 3, 5, 7]

Цикл по списку

Для перебора списков в Python есть два цикла: for и while .

elements = [1, 2, 3, «meow»]
for el in elements:
print(el)

Результат выполнения:

1
2
3
meow

Попробуем построить цикл while . Он выполняется, когда есть какое-либо определённое условие:

elements = [1, 2, 3, «meow»]
elements_len = len(elements)
i = 0
while i < elements_len: print(elements[i]) i += 1

Результат выполнения:

1
2
3
meow

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

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

  • list.append(x) – позволяет добавлять элемент в конец списка;
  • list1.extend(list2) – предназначен для сложения списков;
  • list.insert(i, x) – служит для добавления элемента на указанную позицию( i – позиция, x – элемент);
  • list.remove(x) – удаляет элемент из списка (только первое вхождение);
  • list.clear() – предназначен для удаления всех элементов (после этой операции список становится пустым []);
  • list.copy() – служит для копирования списков.
  • list.count(x) – посчитает количество элементов x в списке;
  • list.index(x) – вернет позицию первого найденного элемента x в списке;
  • list.pop(i) — удалит элемент из позиции i ;
  • list.reverse() – меняет порядок элементов в списке на противоположный;
  • list.sort() – сортирует список;

Пример использования методов:

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

# extend
>>> elements = [1, 2, 3, «meow»]
>>> elements.extend([4, 5, «gaf»])
>>> print(elements)
[1, 2, 3, 'meow', 4, 5, 'gaf']

# insert
>>> a = [1, 3, 4]
>>> a.insert(1, 2)
>>> print(a)
[1, 2, 3, 4]

# remove
>>> elements = [1, «meow», 3, «meow»]
>>> elements.remove(«meow»)
>>> print(elements)
[1, 3, 'meow'] # remove удаляет только первое вхождение

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

# copy
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> print(id(a), id(b), a, b)
60458408 60491880 [1, 2, 3] [1, 2, 3]

# count
>>> elements = [«one», «two», «three», «one», «two», «one»]
>>> print(elements.count(«one»))
3

# index
>>> elements = [«one», «two», «three», «one», «two», «one»]
>>> print(elements.index(«three»))
2

# pop
>>> elements = [1, «meow», 3, «meow»]
>>> elements.pop(1) # удаляем элемент с индексом 1
'meow' # pop возвращает удаленный элемент списка
>>> print(elements)
[1, 3, 'meow']

>>> elements.pop() # удаляем первый элемент списка
'meow'
>>> print(elements)
[1, 3]

>>> elements.pop(-1) # удаляем последний элемент списка
3
>>> print(elements)
[1]

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

# sort (по возрастанию)
>>> elements = [3, 19, 0, 3, 102, 3, 1]
>>> elements.sort()
>>> print(elements)
[0, 1, 3, 3, 3, 19, 102]

# sort (по убыванию)
>>> elements = [3, 19, 0, 3, 102, 3, 1]
>>> elements.sort(reverse = True)
>>> print(elements)
[102, 19, 3, 3, 3, 1, 0]

Вложенные списки

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

>>> elements = [1, 2, [0.1, 0.2, 0.3]]

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

>>> elements = [[«яблоки», 50], [«апельсины», 190], [«груши», 100]]

>>> print(elements[0])
['яблоки', 50]

>>> print(elements[1][0])
апельсины

Срезы

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

У них есть свой собственный синтаксис. Записывается срез так же, как обращение к элементу, используя индекс. Пример:

elements[START:STOP:STEP]

В этом случае берётся срез от номера start (включительно) до stop (не включая его), а step – это шаг. По умолчанию start и stop равны 0, step равен 1.

>>> elements = [0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4]
>>> int_elements = elements[2:6] # с 2-го элемента включительно по 6-й элемент

>>> print(id(elements), id(int_elements)) # elements и int_elements — 2 разных списка
53219112 53183848

>>> print(elements)
[0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4] # срез не модифицирует исходный список

>>> print(int_elements)
[1, 2, 3, 4]

Генераторы списков

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

>>> c = [c * 3 for c in 'list']

>>> print(c)
['lll', 'iii', 'sss', 'ttt']

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

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

>>> nums = [i for i in range(1, 15)]
>>> print(nums)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Пример посложнее:

>>> c = [c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a']
>>> print(c)
['ls', 'lp', 'lm', 'ss', 'sp', 'sm', 'ts', 'tp', 'tm']

Это усложнённая конструкция генератора списков, в которой мы сделали все возможные наборы сочетаний букв из введённых слов. Буквы-исключения видны по циклу, где стоит знак != для одной переменной и другой.

Best Practices

Последние абзацы статьи будут посвящены лучшим решениям практических задач, с которыми так или иначе сталкивается Python-разработчик.

Как получить список в обратном порядке

Изменить порядок размещения элементов в списке помогает функция list.reverse() :

>>> elements = [1, 2, 3, 4, 5, 6]
>>> elements.reverse()

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

Как перевести список в другой формат?

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

Перевод списка в строку осуществляется с помощью функции join(). На примере это выглядит так:

>>> fruits = [«яблоко», «груша», «ананас»]

>>> print(', '.join(fruits))
яблоко, груша, ананас

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

Словарь в Python – это такая же встроенная структура данных, наряду со списком. Преобразование списка в словарь — задача тоже несложная. Для этого потребуется воспользоваться функцией dict() . Вот пример преобразования:

>>> elements = [['1', 'a'],['2', 'b'],['3', 'c']]
>>> my_dict = dict(elements)

>>> print(my_dict)
{'1': 'a', '2': 'b', '3': 'c'}

JSON – это JavaScript Object Notation. В Python находится встроенный модуль json для кодирования и декодирования данных JSON. С применением метода json.dumps(x) можно запросто преобразовать список в строку JSON.

>>> import json
>>> json.dumps(['word', 'eye', 'ear'])
'[«word», «eye», «ear»]'

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

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

>>> elements = [1, 3, 6, 9, 55]

>>> print(elements.index(9))
3

В качестве аргумента передаем значение, а на выходе получаем его индекс.

Как посчитать количество уникальных элементов в списке?

Самый простой способ – приведение списка к set (множеству). После этого останутся только уникальные элементы, которые мы посчитаем функцией len() :

>>> words = [«one», «two», «one», «three», «one»]
>>> len(set(words))
3

Как проверить список на пустоту?

>>> a = []
>>> if not a:
print(«список пуст!»)

список пуст!

Как создать список числовых элементов с шагом

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

Шагом называется переход от одного элемента к другому. Если шаг отрицательный, произойдёт реверс массива, то есть отсчёт пойдёт справа налево. Вот так выглядит список с шагом.

>>> elements = [1, 2, 3, 4, 5, 8, 9, 10, 11, 14, 20]
>>> print(elements[0:11:2])
[1, 3, 5, 9, 11, 20]

Еще один вариант – воспользоваться генератором списков:

>>> elements = [c for c in range(0, 10, 2)] # от 0 (включительно) до 10 с шагом 2

>>> print(elements)
[0, 2, 4, 6, 8]

При разработке на языке Python, списки встречаются довольно часто. Знание основ работы со списками поможет быстро и качественно писать программный код ????.

Оставьте комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Adblock
detector