Списки - это коллекции изменяемых объектов различного типа. Проще говря, вы можеет класть в списки различные объекты, будь то: строки, числа, другие списки и в любое время изменять их.
Больше о списках
Тип данных списка имеет еще несколько методов. Вот все методы списочных объектов:
list.append( х )
Добавьте элемент в конец списка. Эквивалент .a[len(a):] = [x]
list.extend( itaration )
Расширьте список, добавив все элементы из итараций. Эквивалент .a[len(a):] = iterable
list.insert( pos, х )
Вставьте элемент в заданную позицию. Первый аргумент - это индекс элемента, перед которым вставляется, поэтому вставляется в начало списка и эквивалентен .a.insert(0, x)a.insert(len(a), x)a.append(x)
list.remove( х )
Удалите первый элемент из списка, значение которого равно x . Возникает, ValueError если такого элемента нет.
list.pop( [ pos ] )
Удалите элемент в указанной позиции в списке и верните его. Если индекс не указан, a.pop()удаляет и возвращает последний элемент в списке. (Квадратные скобки вокруг сигнатуры метода означают, что параметр является необязательным, а не то, что вы должны вводить квадратные скобки в этой позиции. Вы часто будете видеть это обозначение в Справочнике по библиотеке Python.)
list.clear( )
Удалить все элементы из списка. Эквивалент .del a[:]
list.index( x [, start [, end ] )
Возвращает первый элемент со значение x в списке . Поднимает, ValueError если такого предмета нет.
Необязательные аргументы start и end используются, как срезы. С помощью них можно органичить поиск.
list.count( х )
Возвращает количество x в ссписке
list.sort( key=None, reverse=False )
Сортировка элементов списка на месте.
list.reverse( )
Меняет местами элементы списка.
list.copy( )
Возвращает копию списка. Эквивалент a[:].
Пример, который использует большинство методов списка:
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4) # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
Вы могли заметить, что такие методы, как insert, removeили sortкоторые только изменяют список, не имеют возвращаемого значения - они возвращают значение по умолчанию None. 1 Это принцип проектирования для всех изменяемых структур данных в Python.
Вы также можете заметить, что не все данные можно сортировать или сравнивать. Например, [None, 'hello', 10] не сортируется, потому что целые нельзя сравнивать со строками, а None нельзя сравнивать с другими типами. Кроме того, есть некоторые типы, которые не имеют определенного отношения упорядочения. Например, 3+4j < 5+7j недопустимое сравнение.
Использование списков в качестве стека
Методы списка позволяют очень легко использовать список в виде стека, где последний добавленный элемент - это первый извлеченный элемент («последний пришел, первый вышел»). Чтобы добавить элемент на вершину стека, используйте append(). Чтобы получить элемент из верхней части стека, используйте pop()без явного индекса. Например:
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
Использование списков в качестве очередей
Если кратко, то это позволит вам быстро добавлять и убирать элементы не только с онца, но и с начала списка.
Чтобы реализовать очередь, используйте функцию, collections.deque которая была разработана для быстрого добавления и всплытия с обоих концов. Например:
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry пришел
>>> queue.append("Graham") # Graham пишел
>>> queue.popleft() # Первого теперь нет
'Eric'
>>> queue.popleft() # Второго еперь нет
'John'
>>> queue # Оставшаяся очередь
deque(['Michael', 'Terry', 'Graham'])
Генератор списков
Генераторы списков обеспечивают краткий способ создания списков. Обычные приложения - создают новые списки, в которых каждый элемент является результатом некоторых операций, примененных к каждому члену другой последовательности или повторений, или создавать последовательность тех элементов, которые удовлетворяют определенному условию.
Предположим, что мы хотим создать список квадратов, например:
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Обратите внимание, что это создавая (или перезаписывая) переменную с именем, x которая все еще существует после завершения цикла. Мы можем вычислить список квадратов без каких-либо побочных эффектов, используя:
squares = list(map(lambda x: x**2, range(10)))
или:
squares = [x**2 for x in range(10)]
который является более кратким и читабельным.
Понимание списка состоит из скобок, содержащих выражение, за которым следует for оператор, затем ноль или более for или if конструкция. Результатом будет новый список, полученный в результате оценки выражения в контексте предложений for и, if которые следуют за ним. Например, этот генератор объединяет элементы двух списков, если они не равны:
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
и это эквивалентно:
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Обратите внимание, что порядок операторов for and ifодинаков в обоих этих фрагментах.
Если выражение является кортежем (например, в предыдущем примере), оно должно быть заключено в скобки.(x, y)
>>> vec = [-4, -2, 0, 2, 4]
>>> # новый список с удвоенными значениями
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # уюираем оттуда отрицательные числа
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # применяем ффункцию ко всем элементам
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # вызваем метод для каждого элемента
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # создаем список из 2-х кортежей
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # кортеж должен быть заключен в скобки, в противном случае возникает ошибка
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1, in <module>
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> # отсортируем список, используя генераторы
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Понимания списка могут содержать сложные выражения и вложенные функции:
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
Генератор вложенных списков
Начальным выражением в генераторах может быть любое произвольное выражение, включая другой генератор.
Рассмотрим следующий пример матрицы 3x4, реализованной в виде списка из 3 списков длиной 4:
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
Следующий генератор будет трансформировать строки и столбцы:
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Как мы видели в предыдущем разделе, вложенный генератор оценивается в контексте for следующего за ним, поэтому этот пример эквивалентен
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
что, в свою очередь, совпадает с:
>>> transposed = []
>>> for i in range(4):
... # следующие 3 строки реализуют вложенный генератор
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Но лучше использовать встроенные функции сложным операторам потока. zip()Функция будет делать большую работу для этого случая использования:
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
Оператор del
Существует способ удалить элемент из списка по его индексу, а не по значению - это del оператор. Он отличается от pop()метода, который возвращает значение, тем, что удаляет, не возвращая значение. del оператор также можно использовать для удаления срезов из списка или очистки всего списка (что мы делали ранее путем назначения пустого среза списку). Например:
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
del также может использоваться для удаления целых переменных:
>>> del a
Ссылка на имя в aдальнейшем является ошибкой (по крайней мере, пока ему не присвоено другое значение). Мы найдем другие варианты использования del позже.
Кортежи и последовательности
Мы видели, что списки и строки имеют много общих свойств, таких как операции индексации и среза. Эти два типоа данных - последовательности. Существует также другой стандартный тип данных последовательностей - кортеж .
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Кортежи могут быть вложенными:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Кортежи неизменяемы:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # Но они могут включать в себя изменяемые объекты:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
Как видите, на выходе кортежи всегда заключаются в круглые скобки, так что вложенные кортежи интерпретируются правильно; они могут быть введены с или без окружающих скобок, хотя часто все равно необходимы скобки (если кортеж является частью большего выражения). Невозможно назначить отдельным элементам кортежа, однако возможно создать кортежи, которые содержат изменяемые объекты, такие как списки.
Хотя кортежи могут показаться похожими на списки, они часто используются в разных ситуациях и для разных целей. Кортежи являются неизменяемыми и обычно содержат гетерогенную последовательность элементов, доступ к которым осуществляется через распаковку или индексацию . Списки являются изменяемыми, и их элементы обычно однородны и доступны путем итерации по списку.
Особой проблемой является создание кортежей, содержащих 0 или 1 элемент: в синтаксисе есть некоторые дополнительные причуды для их учета. Пустые кортежи состоят из пустой пары скобок; кортеж с одним элементом создается следующим за запятыми значением (недостаточно заключить одно значение в скобки). Например:
>>> empty = ()
>>> singleton = 'hello', # <-- Обратите внимание на запятую
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)
Заявление t = 12345, 54321, 'hello!'является примером кортежа упаковки. Значения 12345, 54321 и 'hello!' упакованы вместе в кортеже. Обратная операция также возможна:
>>> x, y, z = t
Это называется, соответственно, распаковкой последовательности и работает для любой последовательности с правой стороны. Распаковка последовательности требует, чтобы в левой части знака равенства было столько же переменных, сколько элементов в последовательности. Обратите внимание, что множественное назначение на самом деле является просто комбинацией упаковки кортежа и распаковки последовательности.
Множества
Python также включает в себя тип данных для множеств . Множетсва - это неупорядоченная коллекция без повторяющихся элементов. Основное использование включает тестирование членства и устранение дублирующихся записей. Объекты Set также поддерживают математические операции, такие как объединение, пересечение, разность и симметричная разность.
Фигурные скобки или set()функция могут быть использованы для создания наборов. Примечание: чтобы создать пустой набор, вы должны использовать set(), а не {}; последний создает пустой словарь, структуру данных, которую мы обсудим в следующем разделе.
Вот краткий пример:
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # повторяющиеся слова будут удалены
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # быстрая проверка на членство
True
>>> 'crabgrass' in basket
False
>>> # Продемонстрируем операции над множествами с помощью уникальных букв из двух слов
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # уникальные буквы в a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # буквы в a, но не в b
{'r', 'd', 'b'}
>>> a | b # буквы в a или d и
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # юуквы в a и в b
{'a', 'c'}
>>> a ^ b # уникальные буквы в а или в b
{'r', 'd', 'b', 'm', 'z', 'l'}
Аналогично списочным представлениям, также поддерживаются заданные значения:
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
Словари
Другим полезным типом данных, встроенным в Python, является словари. Словари иногда встречаются на других языках как «ассоциативные воспоминания» или «ассоциативные массивы». В отличие от последовательностей, которые индексируются диапазоном чисел, словари индексируются ключами, которые могут быть любого неизменного типа; строки и числа всегда могут быть ключами. Кортежи могут использоваться в качестве ключей, если они содержат только строки, числа или кортежи; если кортеж содержит какой-либо изменяемый объект прямо или косвенно, он не может использоваться в качестве ключа. Вы не можете использовать списки в качестве ключей, так как списки могут быть изменены на месте, используя назначения индекса, назначения срезов или методы, подобные append()и extend().
Лучше всего рассматривать словарь как набор пар ключ: значение с требованием, чтобы ключи были уникальными (в пределах одного словаря). Пара скобок создает пустой словарь: {}. Размещение разделенного запятыми списка пар ключ: значение в фигурных скобках добавляет начальные пары ключ: значение в словарь; так же словари пишутся на выходе.
Основные операции над словарем - это сохранение значения с некоторым ключом и извлечение значения с учетом ключа. Также возможно удалить пару ключ: значение с del. Если вы храните ключ, который уже используется, старое значение, связанное с этим ключом, будет забыто. Ошибка извлечения значения с использованием несуществующего ключа.
Выполнение list(d)словаря возвращает список всех ключей, используемых в словаре, в порядке вставки (если вы хотите, чтобы он был отсортирован, просто используйте sorted(d)вместо этого). Чтобы проверить, есть ли один ключ в словаре, используйте inключевое слово.
Вот небольшой пример использования словаря:
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
dict() Строит словарь непосредственно из последовательностей пар ключ-значение:
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
Кроме того, для создания словарей из произвольных выражений ключей и значений можно использовать слова dict:
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
Когда ключи являются простыми строками, иногда проще указать пары, используя аргументы ключевых слов:
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}
Методы зацикливания
При циклическом перемещении словарей ключ и соответствующее значение могут быть извлечены одновременно с использованием items()метода.
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
При циклическом выполнении последовательности индекс позиции и соответствующее значение могут быть получены одновременно с помощью enumerate()функции.
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
Чтобы зациклить две или более последовательности одновременно, записи могут быть соединены с zip() функцией.
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
Чтобы зациклить последовательность в обратном порядке, сначала укажите последовательность в прямом направлении, а затем вызовите reversed() функцию.
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1 )
Чтобы зациклить последовательность в отсортированном порядке, используйте sorted()функцию, которая возвращает новый отсортированный список, оставляя источник без изменений.
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
Иногда бывает заманчиво изменить список, пока вы зацикливаетесь на нем; тем не менее, часто проще и безопаснее создать новый список:
>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
... if not math.isnan(value):
... filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]
Больше об условиях
Условия , используемые в while и if конструкциях могут содержать любые операторы, не только сравнение.
Операторы сравнения inи not in не встречается ли значение в последовательности. Операторы is и is not сравнивают, являются ли два объекта действительно одним и тем же объектом; это имеет значение только для изменчивых объектов, таких как списки. Все операторы сравнения имеют одинаковый приоритет, который ниже, чем у всех числовых операторов.
Сравнения могут быть связаны. Например a < b == c, проверяет, является ли a меньше b и является ли b равным c.
Сравнения могут быть объединены с использованием логических операторов and и or, и результат сравнения (или любого другого логического выражения) может быть сведен на нет not. Они имеют более низкие приоритеты, чем операторы сравнения; между ними, not имеет самый высокий приоритет и or самый низкий. Так что A and not B or C эквивалетно (A and (not B)) or C Как всегда, круглые скобки могут быть использованы для выражения желаемой композиции.
and и or с булевыми операторами работают следующим образом: их аргументы оцениваются слева направо, их оценка останавливается, как только определяется результат. Например, если Aи C верны, но B ложно, то выражение A and B and C не оценивается . При использовании в качестве общего значения, а не в качестве логического значения, возвращаемое значение оператора является последним оцененным аргументом.
Можно присвоить результат сравнения или другого логического выражения переменной. Например,
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
Сравнение последовательностей и других типов данных
Объекты последовательности обычно можно сравнивать с другими объектами с таким же типом последовательности. Для сравнения используется лексикографический порядок: сначала сравниваются первые два элемента, и если они отличаются, это определяет результат сравнения; если они равны, сравниваются следующие два элемента и т. д., пока не будет исчерпана любая последовательность. Если все элементы двух последовательностей являются равными, последовательности считаются равными. Если одна последовательность является начальной подпоследовательностью другой, более короткая последовательность является меньшей последовательностью. Лексикографическое упорядочение строк использует номер кодовой точки Unicode для упорядочения отдельных символов. Некоторые примеры сравнений между последовательностями одного типа:
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
Обратите внимание, что сравнение объектов различных типов с < или > допустимо при условии, что объекты имеют соответствующие методы сравнения. Например, смешанные числовые типы сравниваются в соответствии с их числовым значением, поэтому 0 равно 0,0 и т. Д. В противном случае, вместо обеспечения произвольного порядка, интерпретатор вызовет TypeError исключение.
Заключение
Было довольно сложно, но автор надеется, что вы изучили новые типы данных в питоне. Если же вы вдуг что-нибудь оказалось непонятным, то гуглите или задавайте в нашем чате @coolcoders_chat
Пост создан для тг-канала @coolcoders
