Урок 32. Итоги раздела «Структуры данных в Python»

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

Краткий пересказ раздела «Структуры данных в Python»

Списки

Первый урок начали с нескольких примеров списков:

list1 = [2, 4, 8, 16]  
list2 = ["Иван", "Иванов", 20]  
list3 = [list1, list2]

list3 = [[2, 4, 8, 16], ["Иван", "Петр"]]

И написали программу, которая выводит гласные, встречающиеся в строке:

letters = ["а", "е", "и", "о", "у", "э", "ю", "я"]
word = "список – это массив"

for item in word:
    if item in letters:
        print(item) 

Далее пробежались по основным методам, работающим со списками: append, pop, extend, remove и insert. Позднее изучили и другие: index, clear, reverse, count. Познакомились с универсальными функциями sum(), min() и max(). Вспомнили про модуль random и перемешали элементы списка с помощью метода snuffle():

import random
a = [1, "Hello", [3, 6, 7], 4, 5]
random.shuffle(a) # ~=> [5, 'Hello', 4, 1, [3, 6, 7]]

Изучая списки, мы затронули срезы (slice), которые помогают изменять их на месте:

a = [1, 2, 3, 4, 5]
a[1:3] # => [2, 3]
a[1:] # => [2, 3, 4, 5]
a[1:] = [6, 7] # => [1, 6, 7]

В конце выяснили как правильно «соединять» (конкатенировать) списки и с какими неожиданными эффектами можно столкнуться при их копировании. В этом же уроке познакомились с функцией sorted() и методом sort(), с помощью которых можно сортировать списки.

Словари

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

person = {"firstname": "Ivan",
          "lastname": "Ivanov",
          "age": 30}

print(person["firstname"]) 

В этом же уроке мы познакомились с методом setdefault(), который упрощает наш код.

for letter in word:
    letters.setdefault(letter, 0)
    letters[letter] += 1

Затем мы разобрались как можно перебирать элементы словаря. Это делается не так просто как со списками. Использовали всё тот же цикл for:

numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four'}

for item in numbers:
    print(item, numbers[item])

Далее рассмотрели методы items(), keys() и values(). Метод items() возвращает список кортежей из двух элементов. Методы keys() и values() возвращают список ключей и список значений, соответственно:

print(numbers.items())  # => dict_items([(1, 'One'), (2, 'Two'), (3, 'Three'), (4, 'Four')])
print(numbers.keys())   # => dict_keys([1, 2, 3, 4])
print(numbers.values()) # => dict_values(['One', 'Two', 'Three', 'Four'])

Вооружившись новыми методами, переписали пример выше:

numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four'}

for k, v in numbers.items():
    print(k, v)

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

Далее познакомились со следующими методами словарей: pop(), get(), popitem(), clear(), copy(), fromkeys() и update(). Изучили универсальную функцию len() и ключевое слово del.

Множества

В Python множество – структура данных, которая очень похожа на множества из школьной математики. Главная особенность множества – автоматическое удаление одинаковых значений. Как в строке оставить только уникальные символы? Очень просто:

letters = set("ааоеее")
print(letters) # => {'а', 'о', 'е'}

В следующем уроке мы выяснили как создаются множества и познакомились с различными методами: add(), remove(), discard(), pop() и clear(). Научились проверять наличие элемента во множестве:

s = {1, 1, 2, 2, 3}
print(1 in s) # => True

Кстати, проверка выполняется очень быстро, так как множества основаны на хэш-таблицах.

Далее мы говорили об отношениях между множествами и методах issubset(), issuperset(), update(), intersection(), intersection_update(), difference(), difference_update(), symmetric_difference(), symmetric_difference_update(). Урок очень подробный и наглядный, поэтому рекомендую к нему вернуться. Там же немного поговорили о структуре frozenset.

Кортежи

После изучения списков, множеств и словарей, о кортежах мало что можно сказать. Кортежи – неизменяемая структура. Начали мы с определения кортежей в коде. Их выдают круглые скобки. Нужно быть только внимательными с кортежами из одного элемента: интерпретатор может принять их за другой объект:

c = ("Строка")
print(type(c)) # => <class 'str'>

c = ("Строка", )
print(type(c)) # => <class 'tuple'>

Если забыли про функцию type(), вернитесь к уроку про преобразование и проверку типов в Python.

В следующем уроке поговорили подробнее о кортежах и их вездесущности. Так же затронули оператор распаковки (*).

Еще говорили о неизменяемости кортежей. В этой фразе тоже есть нюанс, например:

t = (1, 2, [3, 4], 5)
t[2][1] = 6
print(t) # => (1, 2, [3, 6], 5)

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

Новая информация из раздела «Структуры данных в Python»

Списки

Пустой список в Python создается достаточно просто: [] или list():

list1 = []
list2 = list()  

Списки имеют следующие основные методы:

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

На примере работа методов списков будет понятнее:

list1 = []
list1.append(1)
list1.append("a")
list1 # => [1, 'a']

list1.remove(1)
list1 # => ['a']

list1.extend([1, 2, 3])
list1 # => ['a', 1, 2, 3]

list1.insert(2, 'a'
list1 # => ['a', 1, 'a', 2, 3]

list1.index(2) # => 3

list1.count('a') # => 2

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

list1.clear()
list1 # => []

Теперь вспомним как изменять списки на месте (то есть использовать срезы). Напомню, списки являются изменяемой структурой и поэтому они поддерживают операции, которые изменяют объект списка на месте (Changing Lists In-Place). Возьмем для примера список и сделаем пару срезов:

a = [1, 2, 3, 4, 5]
a[1:3] # => [2, 3]
a[1:] # => [2, 3, 4, 5]
a[1:] = [6, 7] # => [1, 6, 7]

Список сортировать достаточно просто. Чтобы отсортировать сам список, можно использовать метод sort():

a = [5, 12, 3, 6, 1, 2, 7]
a.sort()
a # => [1, 2, 3, 5, 6, 7, 12] 

Для сортировки списка без внесения изменений в оригинальный, используем функцию sorted():

a = ['CA', 'ba', 'Ab']
sorted(a) # =>  ['Ab', 'CA', 'ba']

Словари

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

a = {}
a = dict()

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

СЛОВАРЬ = {
	КЛЮЧ_1: ЗНАЧЕНИЕ_1,
	КЛЮЧ_2: ЗНАЧЕНИЕ_2, 
	...
}

print(СЛОВАРЬ[КЛЮЧ_1]) # => ЗНАЧЕНИЕ_1

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

• items() - возвращает список кортежей из двух элементов. Первый элемент является ключом, второй – значением. Программистам на С++ это знакомо как пара (в STL шаблон pair).
• keys() - возвращает список ключей словаря. 
• values() - возвращает список значений словаря.
• pop() - удаляет ключ и возвращает его значение.
• get() - возвращает значение элемента по указанному ключу или None, если такого ключа не существует.
• popitem() - удаляет последний элемент в словаре и возвращает кортеж из двух элементов: ключа и значения.
• clear() - полностью очищает словарь.
• copy() - копирование словаря.
• fromkeys() - принимает два параметра: итерируемый объект в качестве ключей (например, кортеж) и необязательный параметр, который является значением по умолчанию для каждого ключа.
• setdefault() - возвращает элемент словаря по указанному ключу. Если такого ключа нет, то в словарь запишется указанный ключ и значение по умолчанию, и вернется это значение.
• update() - добавление новых элементов и перезапись уже имеющихся ключей.

Далее пару примеров, чтобы вспомнить методы словарей в Python:

dict1 = {}
list1 = {3, 4, 5, 6}

dict1 = dict.fromkeys(list1, None)
print(dict1) # => {3: None, 4: None, 5: None, 6: None}

print(dict1.pop(5)) # => None
print(dict1) # => {3: None, 4: None, 6: None}

dict1.update({6: 'Six'})
print(dict1) # => {3: None, 4: None, 6: 'Six'}

Помните, мы говорили о возможности в Python инициализировать сразу несколько переменных? Воспользуемся этими знаниями и объединим их с методом items(), который возвращает кортеж из двух элементов:

numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four'}

for k, v in numbers.items():
    print(k, v)

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

numbers = {1: 'One', 3: 'Three', 2: 'Two'}
numbers = sorted(numbers.items())
numbers # => [(1, 'One'), (2, 'Two'), (3, 'Three')]
dict(numbers) # => {1: 'One', 2: 'Two', 3: 'Three'}

Другой способ сортировать словарь по ключам:

numbers = {1: 'One', 2: 'Two', 4: 'Four', 3: 'Three'}
list_keys = list(numbers.keys())
list_keys.sort()

for i in list_keys:
    print(i, ':', numbers[i])

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

import operator  
numbers = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four'}  
  
numbers = sorted(numbers.items(), key=operator.itemgetter(1))  
  
dict(numbers) # => {4: 'Four', 1: 'One', 3: 'Three', 2: 'Two'}

Для удаления из словаря элемента или самого словаря, используйте ключевое слово del:

del numbers['One'] # удаление элемента с ключом One
del numbers # удаление словаря numbers

Множества

Пустое множество можно создать с помощью функции set() и, казалось бы, фигурных скобок {}, но во втором варианте есть нюанс.

a = set()
s = {}

print(type(s)) # => <class 'dict'>

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

Для множеств в Python доступны следующие методы:

• add() - добавление элемента во множество.
• remove() - удаление элемента из множества с вызовом исключения KeyError, в случае отсутствия удаляемого элемента.
• discard() - удаление элемента из множества без вызова исключения.
• pop() - возвращает «случайный» элемент и удаляет его из множества.
• clear() - полностью очищает множество.
• intersection() - определение пересечения множеств.
• intersection_update() - определение пересечения множеств и изменение текущего.
• isdisjoint() - возвращает истину, если оба множества не имеют общих элементов.
• issubset() - является ли множество (для которого вызывается метод) подмножеством.
• issuperset() - является ли множество (для которого вызывается метод) надмножеством.
• union() - объединение двух множеств.
• difference() - определение элементов, которые есть в первом множестве, но нет во втором.
• differenсe_update() - определение элементов, которые есть в первом множестве, но нет во втором и изменение текущего множества.
• symmetric_difference() - определение элементов одного множества, которых нет во втором и элементов второго множества, которых нет в первом.
• symmetric_difference_update() - определение элементов одного множества, которых нет во втором и элементов второго множества, которых нет в первом. И изменение текущего множества.

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

Кортежи

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

t = tuple()
t = ()

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

c = ("Строка", )
print(type(c)) # => <class 'tuple'>

Кортежи поддерживают такие же методы как и списки, за исключением тех, которые могут их поменять. Например, методы sort() и append() кортежи не поддерживают.

Общее

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

# словарь  
d = {4: 5, 1: 1, 3: 12, 2: 3}  
len(d) # => 4  
  
# строка  
s = "Hello"  
len(s) # => 5

Заключение

Раздел «Структуры данных в Python» получился объемным. Мы рассмотрели всего четыре структуры данных, но в тоже время затронули и другие важные базовые темы, понимание которых поможет с наименьшими потерями душевного равновесия разобраться с более сложным материалом в дальнейшем. Не буду много писать в заключении, и так много текста получилось. Переходите к следующему разделу, в котором мы вернемся к циклам и изучим новую тему: обработка исключений.

Урок 33. Введение в раздел «Снова циклы и немного исключений»