# Отчет по теме 3

Степанов Артём, А-02-23

## Операции с объектами

### 1. Установка рабочего каталога. Создание рабочего протокола.

В оболочке IDLE установил актуальный рабочий каталог, а затем в нём создал рабочий протокол.

![Скриншот созданного рабочего протокола](figure0.png)

### 2. Преобразование простых базовых типов объектов.

#### 2.1. Преобразование в логический тип. 

Функция __bool()__ позволяет преобразовывать переданные ей объекты в логический тип.

```py
>>> logiz1 = bool(56) # Любое целое число, кроме 0, преобразуется в True
>>> logiz1
    True
>>> logiz2 = bool(0) # 0 преобразуется в False
>>> logiz2
    False
>>> logiz3 = bool("Beta") # Непустая строка преобразуется в True
>>> logiz3
    True
>>> logiz4 = bool("") # Пустая строка преобразуется в False
>>> logiz4
    False
```

#### 2.2. Преобразование объекта в число. 

Функция __int()__ позволяет преобразовывать переданные ей объекты в целое десятичное число.

```py
>>> tt1 = int(198.9) # Отбрасывается дробная часть
>>> tt1
    198
>>> tt2 = int("-76") # Число – в строке символов, система по умолчанию - десятичная
>>> tt2
    -76
>>> tt3 = int("B", 16) # Число в шестнадцатеричной системе счисления
>>> tt3
    11
>>> tt4 = int("71", 8) # Число в восьмеричной системе счисления
>>> tt4
     57
>>> tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым
    Traceback (most recent call last):
      File "<pyshell#18>", line 1, in <module>
        tt5 = int("98.76")
    ValueError: invalid literal for int() with base 10: '98.76'
```

Функция __float()__ позволяет преобразовывать переданные ей объекты в вещественное число.

```py
>>> flt1 = float(789) # Преобразование целого числа в вещественное
>>> flt1
    789.0
>>> flt2 = float(-6.78e2)
>>> flt2
    -678.0
>>> flt3 = float("Infinity") # В функцию float() можно передавать строки со значениями inf и NaN
>>> flt3
    inf
>>> flt4 = float("-inf") # Значения inf и NaN являются нерегистрочувствительными
>>> flt4
    -inf
```

#### 2.3. Преобразование десятичных чисел в другие систем счисления. 

Функции __bin()__, __oct()__ и __hex()__ позволяют преобразовать переданные ей десятичные числа в двоичную, восьмеричную и шестнадцатеричную системы счисления соответственно.

```py
>>> hh = 123
>>> dv1 = bin(hh)
>>> dv1
    '0b1111011'
>>> vos1 = oct(hh)
>>> vos1
    '0o173'
>>> shs1 = hex(hh)
>>> shs1
    '0x7b'
>>> int(dv1, 2) # Обратное преобразование из двоичной системы счисления
    123
>>> int(vos1, 8) # Обратное преобразование из восьмеричной системы счисления
    123
>>> int(shs1, 16) # Обратное преобразование из шестнадцатеричной системы счисления
    123
```

### 3. Изучение преобразования более сложных базовых типов объектов.

#### 3.1. Преобразование в строку символов. 

Функция __str()__ позволяет преобразовывать переданные ей объекты в строку символов.

```py
>>> strk1 = str(23.6) # Преобразование вещественного числа в строку символов
>>> strk1
    '23.6'
>>> strk2 = str(logiz3) # Преобразование логической переменной в строку символов
>>> strk2
    'True'
>>> strk3 = str(["A", "B", "C"]) # Преобразование списка в строку символов
>>> strk3
    "['A', 'B', 'C']"
>>> strk4 = str(("A", "B", "C")) # Преобразование кортежа в строку символов
>>> strk4
    "('A', 'B', 'C')"
>>> strk5 = str({"A" : 1, "B" : 2, "C" : 9}) # Преобразование словаря в строку символов
>>> strk5
    "{'A': 1, 'B': 2, 'C': 9}"
```

#### 3.2. Преобразование в список. 

Функция __list()__ позволяет преобразовывать переданные ей объекты в список.

```py
>>> spis1 = list("Строка символов") # Преобразование строки символов в список
>>> spis1
    ['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
>>> spis2 = list((124, 236, -15, 908)) # Преобразование кортежа в список
>>> spis2
    [124, 236, -15, 908]
>>> spis3 = list({"A" : 1, "B" : 2, "C" : 9}) # Преобразование словаря в список
>>> spis3
    ['A', 'B', 'C']
```

#### 3.3. Преобразование в кортеж. 

Функция __tuple()__ позволяет преобразовывать переданные ей объекты в кортеж.

```py
>>> kort7 = tuple("Строка символов") # Преобразование строки символов в кортеж
>>> kort7
    ('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
>>> kort8 = tuple(spis2) # Преобразование списка в кортеж
>>> kort8
    (124, 236, -15, 908)
>>> kort9 = tuple({"A" : 1, "B" : 2, "C" : 3}) # Преобразование словаря в кортеж
>>> kort9
    ('A', 'B', 'C')
```

#### 3.4. Удаление объектов.

С помощью функции __del__ можно удалить объекты из оперативной памяти. 

```py
>>> del strk5, kort8
>>> dir()
    ['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spisi3', 'spsi3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
```

#### 3.5. Использование операций с приведением типов на практике

```py
>>> fullName = "StepanovAV"
>>> spisok = list(fullName) # Преобразование строки символов в список
>>> spisok
    ['S', 't', 'e', 'p', 'a', 'n', 'o', 'v', 'A', 'V']
>>> kortezh = tuple(spisok) # Преобразование списка в кортеж
>>> kortezh
    ('S', 't', 'e', 'p', 'a', 'n', 'o', 'v', 'A', 'V')
>>> stroka = str(kortezh) # Преобразование кортежа в строку символов
>>> stroka
    "('S', 't', 'e', 'p', 'a', 'n', 'o', 'v', 'A', 'V')"
```

### 4. Арифметические операции.

#### 4.1. Сложение и вычитание. 

```py
>>> 12 + 7 + 90 # Сложение целых чисел
    109
>>> 5.689e-1 - 0.456 # Вычитание вещественных чисел
    0.11289999999999994
>>> 23.6 + 54 # Сложение вещественного и целого чисел
    77.6
>>> 14 - 56.7 + 89 # Сложение и вычитание целых и вещественных чисел
    46.3
```

#### 4.2. Умножение. 

```py
>>> -6.7 * 12 # Умножение вещественного и целого чисел
    -80.4
```

#### 4.3. Деление. 

```py
>>> -234.5 / 6 # Деление вещественного и целого чисел
    -39.083333333333336
>>> a = 178 / 45 # Деление целых чисел, но результат всё равно вещественное число
>>> a
    3.9555555555555557
>>> type(a)
    <class 'float'>
```

#### 4.4. Деление с округлением вниз. 

```py
>>> b = 178 // 45 # 3.956 округляется вниз, т.е. до 3
>>> b
    3
>>> type(b)
    <class 'int'>
>>> c = -24.6 // 12.1 # -2.033 округляется вниз, т.е. до -3
>>> c
    -3.0
>>> type(c)
    <class 'float'>
>>> 12 // 6.5
    1.0
>>> 12.0 // 5
    2.0
```

#### 4.5. Получение остатка от деления. 

```py
>>> 148 % 33 # Остаток от деления двух целых чисел
    16
>>> 12.6 % 3.8 # Остаток от деления двух вещественных чисел
    1.2000000000000002
>>> 12 % 6.5
    5.5
>>> 12.0 % 5
    2.0
```

#### 4.6. Возведение в степень. 

```py
>>> 14 ** 3
    2744
>>> e = 2.7 ** 3.6
>>> e
    35.719843790663525
>>> 12 ** 6.5
    10343751.997175492
>>> 12.0 ** 5
    248832.0
```

#### 4.7 Операции с комплексными числами

```py
>>> z1 = 1 + 1j
>>> z2 = 2 + 2j
>>> z1 + z2
    (3+3j)
>>> z1 - z2
    (-1-1j)
>>> z1 * z2
    4j
>>> z1 / z2
    (0.5+0j)
>>> z1 ** 2
    2j
>>> z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
    Traceback (most recent call last):
      File "<pyshell#115>", line 1, in <module>
        z1 // 2
    TypeError: unsupported operand type(s) for //: 'complex' and 'int'
>>> z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
    Traceback (most recent call last):
      Fle "<pyshell#116>", line 1, in <module>
        z1 % z2
    TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
```

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

### 5. Операции с двоичными представлениями целых чисел.

#### 5.1. Двоичная инверсия. 

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

```py
>>> dv1 = 9
>>> bin(dv1)
    '0b1001'
>>> dv2 = ~dv1
>>> dv2
    -10
>>> bin(dv2)
    '-0b1010'
```

#### 5.2. Двоичное «И». 

Двоичное «И» - логическое умножение, побитовое совпадение двоичных представлений чисел.

```py
>>> 7 & 9 # 0111 & 1001 = 0001
    1
>>> bin(7)
    '0b111'
>>> bin(9)
    '0b1001'
>>> 7 & 8 # 0111 & 1000 = 0000
    0
>>> bin(8)
    '0b1000'
```

#### 5.3. Двоичное «ИЛИ». 

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

```py
>>> 7 | 9 # 0111 | 1001 = 1111
    15
>>> bin(7)
    '0b111'
>>> bin(9)
    '0b1001'
>>> bin(15)
    '0b1111'
>>> 7 | 8 # 0111 | 1000 = 1111
    15
>>> bin(8)
    '0b1000'
>>> 14 | 5 # 1110 & 0101 = 1111
    15
>>> bin(14)
    '0b1110'
>>> bin(5)
    '0b101'
```

#### 5.4. Двоичное «исключающее ИЛИ». 

Двоичное «исключающее ИЛИ» - побитовое совпадение двоичных представлений чисел, в котором 0 получается, только если оба сравниваемых разряда имеют одинаковые значения.

```py
>>> 14 ^ 5 # 1110 ^ 0101 = 1011
    11
>>> bin(14)
    '0b1110'
>>> bin(5)
    '0b101'
>>> bin(11)
    '0b1011'
```

#### 5.5. Поразрядный сдвиг. 

Поразрядный сдвиг двоичного представления числа на заданное количество шагов осуществляется с помощью операторов __<<__ и __>>__.

```py
>>> h = 14
>>> bin(h)
    '0b1110'
>>> g = h << 2 # Сдвиг на два разряда влево (добавление двух 0 в конец двоичного представления числа)
>>> bin(g)
    '0b111000'
>>> g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
>>> bin(g1)
    '0b111'
>>> g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)

>>> bin(g2)
    '0b11'
```

#### 5.6 Использование операций с двоичным представлением чисел на практике

```py
>>> a = 0b111000111
>>> a
    455
>>> b = 0b100100100
>>> b
    292
>>> ~a # Двоичная инверсия
    -456
>>> bin(~a)
    '-0b111001000'
>>> a & b # Двоичное «И» 
    260
>>> bin(a & b)
    '0b100000100'
>>> a | b # Двоичное «ИЛИ
    487
>>> bin(a | b)
    '0b111100111'
>>> a ^ b # Двоичное «исключающее ИЛИ»
    227
>>> bin(a ^ b)
   '0b11100011'
>>> a >> 3 # Поразрядный сдвиг
    56
>>> bin(a >> 3)
    '0b111000'
```

### 6. Операции при работе с последовательностями.

#### 6.1. Объединение последовательностей. 

Конкатенация - операция объединения(склеивания) двух и более последовательностей одного типа.

```py
>>> "Система " + "регулирования" # Конкатенация двух строк символов
    'Система регулирования'
>>> ["abc", "de", "fg"] + ["hi", "jkl"] # Конкатенация двух списков
    ['abc', 'de', 'fg', 'hi', 'jkl']
>>> ("abc", "de", "fg") + ("hi", "jkl") # Конкатенация двух кортежей
    ('abc', 'de', 'fg', 'hi', 'jkl')
```

#### 6.2. Повторение. 

С помощью оператора __*__  в Python можно повторять объект заданное количество раз.

```py
>>> "ля-" * 5 # Повторение строки 5 раз
    'ля-ля-ля-ля-ля-'
>>> ["ку", "-"] * 3 # Повторение списка 3 раза
    ['ку', '-', 'ку', '-', 'ку', '-']
>>> ("кис", "-") * 4 # Повторение кортежа 4 раза
    ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
>>> signal1 = [0] * 3 + [1] * 99
>>> signal1
    [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> signal2 = (0,) * 3 + (1,) * 5 + (0,) * 7
>>> signal2
    (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
```

#### 6.3. Проверка наличия элемента в последовательности. 

Наличие элемента в последовательность можно проверить с помощью оператора __in__.

```py
>>> stroka = "Система автоматического управления"
>>> "автомат" in stroka # Наличие подстроки в строке
    True
>>> "ку" in ["ку", "-"] * 3 # Наличие контекста в списке
    True
>>> "ля-" in ("abc", "de", "fg", "hi", "jkl") # Наличие контекста в кортеже
    False
```

#### 6.4. Подстановка значений в строку. 

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

```py
>>> stroka = "Температура = %g %s %g"
>>> stroka % (16, "меньше", 25)
    'Температура = 16 меньше 25'
>>> stroka = "Температура = %(zn1)g %(sravn)s %(zn2)g"
>>> stroka % {"zn1" : 16, "sravn" : "меньше", "zn2" : 25}
    'Температура = 16 меньше 25'
```

### 7. Оператор присваивания.

#### 7.1. Обычное присваивание значения переменной. 

Оператор присваивания __=__ позволяет задать определенное значение переменной.

```py
>>> zz = -12
>>> zz
    -12
```

#### 7.2. Увеличение/уменьшение значения переменной на заданную величину. 

Операторы __+=__ и __-=__ позволяют увеличить или уменьшить значение переменной на заданную величину соответственно.

```py
>>> zz += 5 # Увеличение значения на 5
>>> zz
    -7
>>> zz -= 3 # Уменьшение значения на 3
>>> zz
    -10
>>> stroka = "Система"
>>> stroka += " регулирования" # Конкатенация строк символов через оператор +=
>>> stroka
    'Система регулирования'
```

#### 7.3. Умножение/деление значения переменной на заданную величину. 

Операторы __/=__ и __*=__ позволяют разделить или умножить значение переменной на заданную величину соответственно.

```py
>>> zz /= 2 # Деление значения на 2
>>> zz
    -5.0
>>> zz *= 5 # Умножение значения на 5
>>> zz
    -25.0
>>> stroka = "ABC "
>>> stroka *= 3 # Повторение строки символов 3 раза
>>> stroka
    'ABC ABC ABC '
```

#### 7.4. Дополнительные сокращенные арифметические операции. 

В Python также существуют дополнительные сокращенные арифметические операции:
* __//__ - целочисленное деление,
* __%__ - получение остатка от деления,
* __**__ - возведение в степень.

```py
>>> a = 14
>>> a //= 5 # Целочисленное деление
>>> a
    2
>>> b = 13
>>> b %= 6 # Получение остатка от деления
>>> b
    1
>>> c = 2
>>> c **= 4 # Возведение в степень
>>> c
    16
```

#### 7.5. Множественное присваивание. 

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

```py
>>> w = v = 10
>>> w, v
    (10, 10)
>>> n1, n2, n3 = (11, -3, "all")
>>> n1, n2, n3
    (11, -3, 'all')
>>> n1, n2, n3 = "11 -3 all".split(" ")
>>> n1, n2, n3
    ('11', '-3', 'all')
>>> n1, n2, n3 = [11, -3, "all"]
>>> n1, n2, n3
    (11, -3, 'all')
>>> n1, n2, n3 = {1 : 11, 2 : -3, 3 : "all"}
>>> n1, n2, n3
    (1, 2, 3)
>>> n1, n2, n3 = {11, -3, "all"}
>>> n1, n2, n3
    (11, 'all', -3)
```

### 8. Логические операции.

#### 8.1. Основные логические операции. 

```py
>>> w == v # Операция равенства
    True
>>> w != v # Операция неравенства
    False
>>> w += 1
>>> w < v # Операция меньше
    False
>>> w > v # Операция больше
    True
>>> w <= v # Операция меньше или равно
    False
>>> w >= v # Операция больше или равно
    True
```

#### 8.2. Проверка наличия элемента в последовательности или сложном объекте. 

Наличие элемента в сложном объекте также можно проверить с помощью оператора __in__.

```py
>>> mnoz1 = {"pen", "book", "pen", "iPhone", "table", "book"}
>>> "book" in mnoz1 # Проверка наличия элемента в множестве
    True
>>> "cap" in mnoz1
    False
>>> dic1 = {"Saratov" : 145, "Orel" : 56, "Vologda" : 45}
>>> "Vologda" in dic1 # Проверка наличия ключа в словаре
    True
>>> "Pskov" in dic1 
    False
>>> 56 in dic1.values() # Проверка наличия значения в словаре
    True
>>> dct1 = {"Institut" : ["AVTI", "IEE", "IBB"], "Depart" : ["UII", "PM", "VMSS", "MM"], "gruppa" : ["A-01-15", "A-02-15"]}
>>> "UII" in dct1["Depart"] # # Проверка наличия значения в словаре по ключу
    True
>>> dct1["Depart"][1] == "MM" # Сранение значения словаря по ключу
    False
```

#### 8.3. Создание больших логических выражений.

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

```py
>>> a = 17
>>> b = -6
>>> (a >= b) and ("book" in mnoz1) and not ("Pskov" in dic1)
    True
>>> (a % 2 == 1) and (("cap" in mnoz1) or (145 in dic1.values()))
    True
>>> not (b < 0) or (len(mnoz1)== 4)
    True
```

#### 8.4. Ссылки переменных на один и тот же объект.  

Сравнивать ссылки на объект можно с помощью оператора __is__.

```py
>>> w = v = 10
>>> w is v
    True
>>> w1 = ["A", "B"]
>>> v1 = ["A", "B"]
>>> w1 is v1
    False
```

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

### 9. Изучение методов объектов.

#### 9.1. Методы для работы со строками. 

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

```py
>>> stroka = "Микропроцессорная система управления"
>>> stroka.find("пр") # Поиск первого вхождения подстроки в строку
    5
>>> stroka.count("с") # Подсчет вхождений подстроки в строку
    4
>>> stroka.replace(" у", " автоматического у") # Замена всех вхождений подстроки в строку
    'Микропроцессорная система автоматического управления'
>>> spis22 = stroka.split(" ") # Разделение строки на список подстрок по определенному разделителю
>>> spis22
    ['Микропроцессорная', 'система', 'управления']
>>> stroka.upper() # Перевод строки в верхний регистр
    'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
>>> stroka3 = " ".join(spis22) # Создание строки из списка построк с некоторым разделителем
>>> stroka3
    'Микропроцессорная система управления'
>>> stroka3.partition("с") # Создание кортежа с результатом первого вхождения подстроки  в строку
    ('Микропроце', 'с', 'сорная система управления')
>>> stroka3.rpartition("с") # Создание кортежа с результатом последнего вхождения подстроки  в строку
    ('Микропроцессорная си', 'с', 'тема управления')
```

Метод __format()__ используется для форматирования строк по следующему принципу:
1. Если в форматированной строке не указан порядок вставки элементов, то они войдут в неё в порядке их передачи в метод,
2. Если в форматированной строке указан порядок вставки элементов, то они войдут в неё в с таким же порядком,
3. Если в форматированной строке поименно указаны позиции вставки элементов, то они войдут в неё в соответствии с ними.
```py
>>> strk1 = "Момент времени {}, значение {}"
>>> strk1.format(1, 89.7) # Случай 1
    'Момент времени 1, значение 89.7'
>>> strk2 = "Момент времени {1}, значение = {0} : {2}"
>>> strk2.format(36.7, 2, "норма") # Случай 2
    'Момент времени 2, значение = 36.7 : норма'
>>> strk3 = "Момент времени {num}, значение = {znch}"
>>> strk3.format(znch = 89.7, num = 2) # Случай 3
    'Момент времени 2, значение = 89.7'
```

#### 9.2. Методы для работы со списками. 

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

```py
>>> spsk = [1, 2, 3, 4, 5, 6, 7]
>>> spsk.pop(2) # Удаление элемента по индексу из списка, с возвращением его значения
    3
>>> spsk
    [1, 2, 4, 5, 6, 7]
>>> spsk.append("c") # Добавление элемента в конец списка
>>> spsk
    [1, 2, 4, 5, 6, 7, 'c']
>>> spsk.insert(2, "a") # Добавление элемента на определенную позицию в списке
>>> spsk
    [1, 2, 'a', 4, 5, 6, 7, 'c']
>>> spsk.count("a") # Подсчет количества соответствующих элементов в списке
    1
```

#### 9.3. Методы для работы с кортежами. 

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

```py
>>> kortezh = (1, 2, 3, 4, 5, 6, 7)
>>> dir(kortezh)
    ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
>>> kortezh.count(3) # Подсчет количества соответствующих элементов в кортеже
    1
>>> kortezh.index(2) # Вычисление индекса переданного элемента, если он есть в кортеже
    1
```

#### 9.4. Методы для работы с словарями и множествами. 

Методы для работы со словарями рассмотрены в примере ниже.

```py
>>> dictionary = {"A" : 1, "B" : 2, "C" : 3, "D" : 4, "E" : 5}
>>> dictionary.get("D") # Получение значения из словаря по соответствующему ему ключу
    4
>>> dictionary.items() # Получение списка кортежей всех пар ключ-значений в словаре
    dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5)])
>>> dictionary.keys() # Получение списка всех ключей в словаре
    dict_keys(['A', 'B', 'C', 'D', 'E'])
>>> dictionary.values() # Получение списка всех значений в словаре
    dict_values([1, 2, 3, 4, 5])
>>> dictionary.pop("C") # Удаление определенной пары ключ-значение из словаря по переданному ключу
    3
>>> dictionary
    {'A': 1, 'B': 2, 'D': 4, 'E': 5}
>>> dictionary.popitem() # Удаление последней пары ключ-значение из словаря
    ('E', 5)
>>> dictionary
    {'A': 1, 'B': 2, 'D': 4}
>>> dictionary.update({"A" : 5}) # Обновление словаря новыми значениями
>>> dictionary
    {'A': 5, 'B': 2, 'D': 4}
>>> dictionary.clear() # Очистка словаря
>>> dictionary
    {}
```

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

```py
>>> mnozhestvo = {"Apple", "Orange", "Peach", "Pear"}
>>> mnozhestvo.add("Banana") # Добавление элемента в множество
>>> mnozhestvo
    {'Apple', 'Orange', 'Peach', 'Banana', 'Pear'}
>>> mnozhestvo2 = mnozhestvo.copy() # Копирование множества
>>> mnozhestvo2
    {'Apple', 'Peach', 'Orange', 'Banana', 'Pear'}
>>> mnozhestvo2.remove("Apple") # Удаление элемента из множества
>>> mnozhestvo2
    {'Peach', 'Orange', 'Banana', 'Pear'}
>>> mnozhestvo.difference(mnozhestvo2) # Сравнение двух множеств по содержимому, возвращает разницу
    {'Apple'}
>>> mnozhestvo2.clear() # Очистка множества
>>> mnozhestvo2
    set()
```

### 10. Завершение работы со средой.

Сохранил файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.