diff --git a/TEMA3/figure0.png b/TEMA3/figure0.png
new file mode 100644
index 0000000..30d4d53
Binary files /dev/null and b/TEMA3/figure0.png differ
diff --git a/TEMA3/report.md b/TEMA3/report.md
new file mode 100644
index 0000000..111cfa3
--- /dev/null
+++ b/TEMA3/report.md
@@ -0,0 +1,772 @@
+# Отчет по теме 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.
diff --git a/TEMA3/report.py b/TEMA3/report.py
new file mode 100644
index 0000000..e69de29
diff --git a/TEMA3/task.md b/TEMA3/task.md
new file mode 100644
index 0000000..9aaee16
--- /dev/null
+++ b/TEMA3/task.md
@@ -0,0 +1,58 @@
+# Общее контрольное задание по теме 3
+
+Степанов Артём, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Преобразовать восьмеричное значение 45 в целое число.
+* Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+* Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+* Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+* Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+* Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+* Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>> znch = int("45", 8)
+>>> znch
+    37
+>>> D = {
+        "усиление" : 23,
+        "запаздывание" : 12,
+        "постоянная времени" : 78
+        }
+>>> D_keys, D_values = list(D.keys()), list(D.values())
+>>> D_keys
+    ['усиление', 'запаздывание', 'постоянная времени']
+>>> D_values
+    [23, 12, 78]
+>>> D_tuple = tuple(zip(D_keys, D_values)) # Кортеж, в отличие от списка, является неизменяемым объектом 
+>>> D_tuple
+    (('усиление', 23), ('запаздывание', 12), ('постоянная времени', 78))
+>>> ((1768 // 24.8) % 3) ** 2.4
+    5.278031643091577
+>>> (~(13 & 27) ^ 14) << 2
+    -32
+>>> list1 = ["колебат",] * 4
+>>> list1
+    ['колебат', 'колебат', 'колебат', 'колебат']
+>>> "аткол" in list1[1] + list1[2]
+    True
+>>> dir(D)
+    ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> D.keys()
+    dict_keys(['усиление', 'запаздывание', 'постоянная времени']) # Список ключей словаря
+>>> D.values()
+    dict_values([23, 12, 78]) # Список значений словаря
+>>> string = "Создать объект - символьную строку с текстом данного предложения."
+>>> string_list = string.split(" ")
+>>> string_list[string_list.index("-")] = ","
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> string_list.remove("данного")
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```
\ No newline at end of file