ЛАБОРАТОРНАЯ РАБОТА №5

Тема: Множества. Словари. Генераторы

Цель: Рассмотрение способов работы с множествами, словарями и генераторами

ОГЛАВЛЕНИЕ

 Оглавление

1 Множества

Объекты множества в языке Python представляют собой неупорядоченные контейнеры (см. подраздел 1.1 лаб. раб. №3) уникальных хэшируемых объектов.
Объект является хэшируемым, если он имеет значение хэш-функции, которое не меняется в течение времени существования объекта, т.е. поддерживает метод __hash__() и может быть сравним с другими объектами с помощью метода __eq__() (см. подраздел 1.3 лаб. раб. №3). Все хэшируемые объекты являются неизменяемыми объектами и принадлежат ABC-классу Hashable (см. раздел 1 лаб. раб. №3).
Хэшируемость объектов позволяет использовать их в качестве элементов множества и ключей словарей (см. подраздел 2.1), поскольку эти структуры данных используют значения хэш-функции.
В языке Python все встроенные неизменяемые объекты (такие, как числа, логические значения, строки и кортежи) являются хэшируемыми:

>>> from collections import Hashable
>>> isinstance (1.25e-1, Hashable)
True
>>> isinstance ( False , Hashable)
True
>>> isinstance ( 'Web' , Hashable)
True
>>> isinstance ((1,2,3),collections.Hashable)
True

в то время как изменяемые контейнеры, такие как изменяемые множества (см. подраздел 1.1), словари (см. подраздел 2.1) и списки (см. раздел 2 лаб. раб. №3) – нет:

>>> isinstance ([ 'a' , 'b' , 'c' ], Hashable
False

Объекты, которые являются экземплярами созданных пользователем классов, являются хэшироваными по умолчанию, при сравнении между собой они не равны и значения их хэшей являются значениям их id().
Объекты множества могут быть использованы при проверке на наличие элементов в последовательности, при удалении дубликатов из последовательности и при выполнении математических операций над множествами, таких как объединение, пересечение и вычитание.
Имеется два встроенных типа (класса) множеств: set и frozenset (см. подраздел 2.1).
Тип set является изменяемым множеством или просто множеством. Как изменяемый объект, он не может быть использован ни в качестве ключа в словарях, ни в качестве элемента другого множества.
Тип frozenset является неизменяемым множеством. Поэтому может быть ключом в словаре и элементом другого множества.

 Оглавление

1.1 Создание множеств

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

>>> a_set={1,2, 'a' , 'b' }
>>> a_set
{'b', 1, 2, 'a'},

или с помощью генератора элементов множества (см. подраздел 3.2).
Проверим изменяемость (нехэшируемость) множеств:

>>> isinstance (a_set, Hashable)
False.

Также для создания множества можно использовать конструктор – встроенную функцию set([iterable]) (см. подраздел 8.1 лаб. раб. №1), аргументом которой является итерабельный объект. Поэтому в объекты множества можно преобразовать такие последовательности, как строки, списки, кортежи и диапазоны. Если строка, список, кортеж или диапазон содержат одинаковые элементы, после преобразования из них останется только один:

>>> set ( 'ABBA' )
{'B','A'}.

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

>>> set ([1,2,[3,4]])
TypeError: unhashable type: 'list'

Для создания объектов множества неизменяемого типа frozenset необходимо использовать конструктор – встроенную функцию frozenset() (см. подраздел 8.1 лаб. раб. №1, аргументом которой является итерабельный объект:

>>> frozenset (( 'a' , 'c' , 'd' , 'c' ))
frozenset({'d', 'a', 'c'}) .

Экземпляры типов set и frozenset, являясь контейнерами:

>>> import collections
>>> isinstance ({1,2},collections.Container)
True
>>> isinstance (frozenset({1,2}), collections.Container)
True

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

>>> isinstance ({1,2},collections.Sequence)
False
>>> isinstance (frozenset({1,2}), collections.Sequence)
False

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

• x in s – возвращает True, если x содержится в s, False – в противном случае;
• x not in s – возвращает True, если x не содержится в s, False – в противном случае;
• len(s) – возвращает число элементов s;
• max(s) – возвращает максимальный элемент s;
• min(s) – возвращает миниимальный элемент s.

Можно добавить, что объекты изменяемого множества set принадлежат ABC-классу MutableSet:

>>> s={1,2,3}
>>> isinstance (s,collections.MutableSet)
True,

а объекты неизменяемого класса frozenset – нет:

>>> fs=frozenset(s)
>>> isinstance (fs,collections.MutableSet)
False

 Оглавление

1.2 Добавление элементов к множеству

Имеется два способа добавления элементов в существующее множество:

• метод add() принимает один аргумент, который может быть любого неизменяемого типа и добавляет данное значение к множеству:
  
  >>> a_set.add((4,5))
  >>> a_set
  {'a', 1, 2, 'b', (4, 5)}
  
  
• метод update() может принимать несколько аргументов разных типов и добавлять их к множеству, если аргументами являются последовательности (списки, кортежи или множества), то их элементы должны быть хэшируемыми (неизменяемых типов) и добавляться как новые элементы множества (при этом одинаковые элементы удаляются):
  
  >>> a_set.update([2,3],{ 'b' , 'c' })
  >>> a_set
  {1, 2, 3, 'a', 'c', 'b', (4, 5)}
  
  

Отметим, что объекты типа frozenset, будучи неизменяемыми множествами, не имеют методов добавления элементов к множеству.

 Оглавление

1.3 Удаление элементов из множества

Имеется несколько способов удаления элементов из существующего множества:

• метод discard() принимает в качестве аргумента одиночное значение и удаляет это значение из множества, если этого значения в множестве нет, то ничего не произойдет:
  
  >>> a_set.discard(2)
  >>> a_set
  {1, 3, 4, 'b', 'c', 'a'};
  
  
• метод remove() также принимает в качестве аргумента одиночное значение, и также удаляет его из множества, но в отличие от метода discard(), если в множестве нет элемента, то будет выработано исключение KeyError:
  
  >>> a_set.remove( 'a' )
  {1, 3, 4, 'c', 'b'},
  >>> a_set.remove( 'a' )
  >>> KeyError: 'a';
  
  
•  метод pop() удаляет из множества первый элемент и возвращает его значение:
  
  >>> a_set.pop()
  1
  >>> a_set
  {3, 4, 'c', 'b'},
  если множество пусто – обозначается set(), то вырабатывается исключение:
  
  KeyError: 'pop from an empty set'
  
  С помощью метода pop() можно просмотреть все элементы множества:
  
  >>> while a_set:
  print (a_set.pop())
  3
  4
  b
  c;
  
  
• метод clear() удаляет все элементы множества, создавая пустое множество:
  
  >>> a_set.clear()
  >>> a_set
  set().
  

В логическом контексте пустое множество set() соответствует False, любое другое – True.
Отметим, что объекты типа frozenset, будучи неизменяемыми множествами, не имеют методов удаления элементов из множества.

 Оглавление

1.4 Сравнение и копирование множеств

Python имеет несколько методов сравнения множеств:

• метод isdisjoint() принимает в качестве аргумента другое множество и возвращает значение True, если множенства не имеют общих элементов:
  
  >>> a_set={1,2,5,6}
  >>> a_set.isdisjoint({3,7})
  True,
  >>> a_set.isdisjoint({2,7})
  False;
  
  
•   метод issubset() принимает в качестве аргумента другое множество и возвращает значение True, если каждый элемент данного множества содержится в другом множестве:
  
  >>> a_set.issubset({1,2,3,3,5,6})
  True;
  
  
• метод issuperset() принимает в качестве аргумента другое множество и возвращает значение True, если каждый элемент другого множества содержится в данном множестве:
  
  >>> a_set.issuperset({1,6})
  True.
  

Метод copy() используется для "поверхностного" копирования списков (см. раздел 4)):

>>> b_set=a_set.copy()
>>> b_set
{1, 2, 5, 6}.

 Оглавление

1.5 Операции над множествами

Python имеет несколько методов для выполнения основных операций над множествами:

• метод union() (объединение) возвращает новое множество, содержащее все элементы каждого из множеств:
  
  >>> a_set={1,2,5,6,9}
  >>> b_set={2,4,6,8}
  >>> a_set.union(b_set)
  {1, 2, 4, 5, 6, 8, 9},
  
  метод симметричен, т.е. a_set.union(b_set)=b_set.union(a_set):
  
  >>> b_set.union(a_set)
  {1, 2, 4, 5, 6, 8, 9};
  
  
• метод intersection() (пересечение) возвращает новое множество, содержащее все элементы, которые есть и в первом множестве, и во втором:
  
  >>> a_set.intersection(b_set)
  {2, 6},
  
  метод симметричен;
• метод difference() (разность) возвращает новое множество, содержащее все элементы, которые есть в множестве a_set, но которых нет в множестве b_set:
  
  >>> a_set.difference(b_set)
  {9, 5, 1},
  
  этот метод не симметричен, поскольку a_set.difference(b_set) не равно b_set.difference(a_set):
  
  >>> b_set.difference(a_set)
  {8, 4};
  
  
• метод symmetric_difference() (симметрическая разность) возвращает новое множество, которое содержит только уникальные элементы обоих множеств:
  
  >>> a_set.symmetric_difference(b_set)
  {1, 4, 5, 8, 9},
  
  метод симметричен.

 Оглавление

2 Словари

Словари в языке Python имеют тип (класс) dict и представляют собой множество пар вида ключ:значение. Словари в языке Python похожи на ассоциативные массивы языка Jaxascript.

 Оглавление

2.1 Создание словарей

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

>>> a_dict={ 'alpha' :1, 'beta' :2, 'gamma' :3}
>>> a_dict
{'alpha': 1, 'beta': 2, 'gamma': 3}

В качестве ключа необходимо использовать только неизменяемые (хэшируемые) типы: числа (целые и с плавающей точкой), строки, логические значения, кортежи, диапазоны и неизменяемые множества. В качестве значения могут быть заданы любые из рассмотренных типов, включая изменяемые множества и словари.
Словари также можно задавать с помощью конструктора – встроенной функции dict() (см. подраздел 8.1 лаб. раб. №1). Если при вызове функция не имеет аргументов, то создается пустой список:

>>> dict ()
{},

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

• именованные аргументы, которые указываются в виде пар "имя=значение" (см. подраздел 1.1.2 лаб. раб. №6):
  
  >>> b_dict= dict (alpha=1, beta=2, gamma=3);
  
  
•   аргумент, имеющий тип словаря:
  
  >>> c_dict= dict ({ 'gamma' :3, 'alpha' :1, 'beta' :2}) ;
  
  
• аргумент итерабельного типа, например, список, элементами которого являются кортежи, содержащие ровно два элемента: первый из которых задает ключ словаря, а второй – значение:
  
  >>> d_dict= dict ([( 'alpha' ,1), ( 'beta' ,2), ( 'gamma' ,3)])
  

Выше четырьмя разными способами были созданы словари a_dict(), b_dict(), c_dict() и d_dict(), имеющие одно и то же значение. Проверим это:

>>> a_dict==b_dict==c_dict==d_dict
True.

Если ключи и значения словаря заданы последовательностями, то для создания словаря также можно использовать встроенную функцию zip(*iterable) (см. подраздел 8.1 лаб. раб. №1), которая возвращает итератор, элементами которого являются кортежи, где i-й кортеж содержит i-е элементы каждого аргумента последовательностей или итерабельных объектов. Если последовательности, явдяющиеся аргументами функции, имеют разную длину, то формируемые кортежи имеют число элементов, равное длине минимальной последовательности. Если указан один элемент – функция возвращает итератор, состоящий из одноэлементных кортежей. Если аргументы не указаны – возвращается пустой итератор.
Пусть, например, ключи словаря представлены списком key_list, а значения – кортежом value_tuple:

>>> key_list=[ 'a' , 'b' , 'c' ]
>>> value_tuple=(1.32, 'value' , [1,2,3], 25)

Теперь с помощью функции zip(), аргументами которой являются последовательности key_list и value_tuple, создаем итератор с именем zipped:

>>> zipped= zip (key_list, value_tuple),

который имеет тип zip:

>>> type (zipped)
<class 'zip'>

Остается только преобразовать его с помощью конструктора в словарь:

>>> e_dict= dict (zipped)
>>> e_dict
{'a': 1.32, 'b': 'value', 'c': [1, 2, 3]}

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

>>> import collections
>>> isinstance ({1: 'a' ,2: 'b' ,3: 'c' },collections.Container)
True
>>> isinstance ({1: 'a' ,2: 'b' ,3: 'c' },collections.Mapping)
True
>>> isinstance ({1: 'a' ,2: 'b' ,3: 'c' },collections.MutableMapping)
True

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

>>> a_dict[ 'beta' ]
2,

если указанный ключ отсутствует – возбуждается исключение KeyError:

>>> a_dict[ 'delta' ]
KeyError: 'delta'.

Чтобы получить все значения словаря следует использовать оператор for in:

>>> for key in a_dict:
print (key, '=' ,a_dict[key])
alpha = 1
beta = 2
gamma = 3

Можно изменять значение ключа:

>>> a_dict[ 'alpha' ]=11
>>> a_dict
{'alpha': 11, 'beta': 2, 'gamma': 3}

и добавлять новые пары в словарь:

>>> a_dict[ 'epsilon' ]=5
>>> a_dict
{'alpha': 22, 'beta': 2, 'gamma': 3, 'epsilon': 5}

Для удаления ключа необходимо указать:

>>> del a_dict[ 'alpha' ]
>>> ]
{'beta': 2, 'gamma': 3, 'epsilon': 5}.

Словари так же, как последовательности и множества поддерживают функцию определения числа элементов len() и оператор in, позволяющий определить принадлежность элемента контейнеру.
Пустой словарь – {} в логическом контексте равен False, все остальные словари – True.

 Оглавление

2.2 Методы словарей

Словари поддерживают следующие методы:

• clear() – очищает словарь, возвращая значение {}:
  
  >>> b_dict={1:101, 2:102, 3:103}
  >>> b_dict.clear()
  >>> a_dict
  {}.
  
  Метод clear() поддерживается всеми изменяемыми классами данных;
• copy() – возвращает ссылку на вновь созданный объект класса dict с теми же значениями (т.е. выполняет "поверхностное" копирование, см. раздел 4):
  
  >>> b_dict=a_dict.copy()
  >>> b_dict
  {'beta': 2, 'gamma': 3, 'epsilon': 5}.
  
  Метод copy() поддерживается всеми изменяемыми классами данных;
• get(key[, default]) – если словарь имеет ключ key, возращает его значение, если нет – возвращает значение, заданное вторым аргументом (значение по умолчанию):
  
  >>> a_dict.get( 'gamma' , 'new_key' )
  'gamma'
  >>> a_dict.get( 'delta' , 'new_key' )
  'new_key';
  
  
• items() – возвращает элементы словаря в виде пар (key, value):
  
  >>> items=a_dict.items()
  >>> items
  dict_items([('epsilon', 5), ('beta', 2), ('gamma', 3)])
  
  
• keys() – возвращает все ключи словаря:
  
  >>> a_dict.keys()
  dict_keys(['beta', 'gamma', 'epsilon'])
  
  
• pop(key[, default) – если указанный ключ содержится в словаре, удаляет его из словаря и возвращает его значение, иначе возвращает значение по умолчанию. Если значение по умолчанию не указано и ключ не содержится в словаре, то возникает исключение KeyError:
  
  >>> a_dict.pop( 'gamma' )
  3
  >>> a_dict
  {'beta': 2, 'delta': 4, 'epsilon': 5} ;
  
  
• popitem() – удаляет и возвращает произвольную пару вида (key, value) из словаря;
• setdefault(key[, default) – похож на метод get(), но если ключа нет в словаре – не только возвращает значение по умолчанию, но и устанавливает его:
  
  >>> a_dict.setdefault( 'delta' , 4 )
  4
  >>> a_dict
  {'beta': 2, 'delta': 4, 'epsilon': 5}
  
  
• update([dict2]) – возвращает слияние элементов данного словаря и словаря, заданного аргументом (аргумент может быть задан: в виде именованных аргументов, в виде итерабельного типа или в виде словаря (см. описание конструктора dict() в подразделе 2.1):
  
  >>> b_dict={ 'figure' : 'circle' , 'color' : 'green' }
  >>> a_dict.update(b_dict)
  >>> a_dict
  {'beta': 2, 'figure': 'circle', 'delta': 4, 'color': 'green', 'epsilon': 5}
  
  
• values() – возвращает все значения словаря:
  
  >>> a_dict.values
  dict_values([2, 'circle', 4, 'green', 5]).
  
  

 Оглавление

3 Генераторы

В литералах при создании списков, множеств и словарей помимо указания перечня их элементов (см. подразделы 2.1 лаб. раб. №3, 1.1 и 2.1) можно также указать генераторы элементов этих контейнеров.

 Оглавление

3.1 Использование генератора для формирования списка

Например, создание списка кубов целых чилел от 1 до 10 можно осуществить следующим образом:

>>> a_list=[x**3 for x in range (1, 11)]
>>> a_list
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000].

Выражение x**3 for x in range(1,11) является генераторным выражением. Оно имеет тип генератора:

>>> type (x**3 for x in range (1, 11))
<class 'generator'>

и состоит из выражения x**3, за которым следует оператор for для итерабельного типа. В таком виде генераторное выражение может использоваться только в качестве единичного аргумента в функциях. В остальных случаях необходимо указывать его в скобках, например при анализе, является ли тип generator итерабельным:

>>> import collections
>>> isinstance ((x**3 for x in range (1, 11)), collections.Iterable)
True.

В приведенном примере сформированные кубы целых чисел сохранены в памяти в виде списка. Для длинных последовательностей это не всегда удобно. Рассмотрим вариант генерации кубов чисел без сохранения их в памяти:

>>> gen=(x**3 for x in range (1, 11))
>>> for x in gen:
print x, end= ' ' )
1, 8, 27, 64, 125, 216, 343, 512, 729, 1000.

Поскольку значения генератора gen не сохранены в памяти повторное его использование ничего не дает:

>>> for x in gen:
print x, end= ' ' )

 Оглавление

3.2 Использование генератора для формирования множества

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

>>> a_set={x for x in 'Карл украл у Клары кораллы' .upper()}
>>> a_set
{'О', 'Л', 'К', 'А', ' ', 'Ы', 'Р', 'У'} .

 Оглавление

3.3 Использование генератора для формирования словаря

В качестве последнего примера использования генераторов рассмотрим создание словаря, ключами которого являются числа, заданные в списке, а значениями – квадратные корни этих чисел:

>>> {x:x**(1/2) for x in [2, 5, 25] }
{25: 5.0, 2: 1.4142135623730951, 5: 2.23606797749979}.

Формировать элементы последовательностей также можно с использованием встроенной функции map() (см. подраздел 1.5.2 лаб. раб. №6).

 Оглавление

4 Копирование объектов

В подразделе 1.4 при описании метода copy() был использован термин поверхностная копия. Поскольку существует еще и глубокая копия, дадим разъяснение этим терминам.
Операторы присваивания в языке Python не копируют объекты, они только сооздают ссылки на объект. Для контейнеров, которые являются изменяемыми или содержат изменяемые элементы, возникает иногда необходимость их копирования – чтобы можно было изменить копию, не изменяя исходные значения.
Модуль copy содержит два метода:

• один для создания поверхностной копии – copy.copy(x);
• другой для создания глубокой копии – copy.deepcopy(x).

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

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

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

>>> import copy
>>> a_dict={1:5,2:{3:25}}
>>> a_dict
{1: 5, 2: {3: 25}}
>>> b_dict=copy.copy(a_dict)
>>> b_dict
{1: 5, 2: {3: 25}}
>>> b_dict[2][3]=77
>>> a_dict
{1: 5, 2: {3: 77}}.

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

>>> a_dict={1:5,2:{3:25}}
>>> c_dict=copy.deepcopy(a_dict)
>>> c_dict[2][3]=77
>>> a_dict
{1: 5, 2: {3: 25}}.

Для создания "поверхностной" копии помимо метода copy() модуля copy() можно также использовать:

• методы copy() изменяемых объектов: списков, множеств и словарей (см. подразделы 2.3 лаб. раб. №3, 1.4 и 2.2);
• срезы последовательностей (см. подраздел 1.4.2 лаб. раб. №3);
• конструкторы, аргументы которых содержат тот же тип, что и создаваемый объект (см. описания конструкторов всех рассмотренных типов).

 Оглавление

Индивидуальные задания

Разработать программу на языке Python, которая выполняет следующее:

• 1 Создает множество a_set, содержащее не менее 7 элементов любых разрешенных типов, с помощью (см. колонку "Множество"/"Создание" табл. №1):
  • 1 – литерала;
  • 2 – конструктора;
  • 3 – генератора.
• 2 Изменяет множество a_set с помощью методов (см. колонку "Множество"/"Методы" табл. №1):
  • 1 – add();
  • 2 – update();
  • 3 – discard();
  • 4 – remove();
  • 5 – pop().
• 3 Создает итерабельный объект it_ob, содержащий не менее трех элементов, имеющихся в объекте a_set, и проверить, все ли элементы it_ob хэшируемы. Если нет – заменить нехэшируемые элементы хэшируемыми.
• 4 Преобразует объект it_ob в множество b_set и выполняет над множествами a_set и b_set операции (см. колонку "Множество"/"Операции" табл. №1):
  • 1 – union();
  • 2 – intersection();
  • 3 – difference();
  • 4 – symmetric_difference().
• 5 Создает словарь a_dict с помощью (см. колонку "Словарь"/"Создание" табл. №1):
  • 1 – литерала;
  • 2 – конструктора с именованованными аргументами;
  • 3 – конструктора с аргументом, имеющем тип словаря;
  • 4 – конструктора с аргументом итерабельного типа;
  • 5 – генератора.
• 6 Выполняет следующие методы словаря a_dict (см. колонку "Словарь"/"Методы" табл. №1):
  • 1 – clear();
  • 2 – get(key[, default]);
  • 3 – items();
  • 4 – keys();
  • 5 – pop(key[, default);
  • 6 – popitem();
  • 7 – setdefault(key[, default);
  • 8 – update([dict2]);
  • 9 – values().

 Оглавление