diff --git a/TEMA3/report.md b/TEMA3/report.md
index e69de29..8cb98ed 100644
--- a/TEMA3/report.md
+++ b/TEMA3/report.md
@@ -0,0 +1,1108 @@
+# Отчет по теме 3
+
+Володин Денис, А-02-23
+
+
+## Пункт 1.
+
+Рабочая среда настроена на нахождение в нужной директории:
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA3')
+```
+
+## Пункт 2.
+
+## Пункт 2.1
+
+Преобразование в логический тип (bool())
+
+Различные варианты:
+
+```py
+>>> logiz1=bool(56)
+>>> logiz1
+True
+>>> logiz2=bool(0)
+>>> logiz2
+False
+>>> logiz3=bool("Beta")
+>>> logiz3
+True
+>>> logiz4=bool("")
+>>> logiz4
+False
+>>> logiz5=bool(" ")
+>>> logiz5
+True
+>>> logiz6=bool(-1)
+>>> logiz6
+True
+>>> logiz7=bool(None)
+>>> logiz7
+False
+>>> logiz8=bool([])
+>>> logiz8
+False
+>>> logiz8=bool([" "])
+>>> logiz8
+True
+```
+
+2.2 Преобразование в целое с заданной системой счисления (по умолчанию
+десятичная)
+
+```py
+>>> tt1=int(198.6)
+>>> 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#34>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+Как видно, последняя команда вернула диагностическое сообщение. Это происходит
+потому, что команда int ожидает, что ей сообщат строку, похожую на тип int
+(только цифры, может быть знак в начале). Здесь есть точка, поэтому вознакает
+несоответствие ожидаемого формата фактическому. Можно сначала строку перевести
+в число с плавающей точкой, а потом уже в int.
+
+Еще варианты:
+
+```py
+>>> tt6=int("+43")
+>>> tt6
+43
+>>> tt6=int("aaa")
+Traceback (most recent call last):
+  File "<pyshell#37>", line 1, in <module>
+    tt6=int("aaa")
+ValueError: invalid literal for int() with base 10: 'aaa'
+>>> tt6=int("aaa", 16)
+>>> tt6
+2730
+```
+
+Преобразование в вещественное число:
+
+```py
+>>> flt1 = float(789)
+>>> flt1
+789.0
+>>> flt2=float(-6.78e2)
+>>> flt2
+-678.0
+>>> flt3=float("Infinity")
+>>> flt3
+inf
+>>> flt4=float("-inf")
+>>> flt4
+-inf
+>>> flt5=float(False)
+>>> flt5
+0.0
+>>> flt6=float(True)
+>>> flt6
+1.0
+``
+
+## Пункт 2.3
+
+Преобразование в другие системы счисления.
+
+```py
+>>> hh=123
+>>> dv1 = bin(hh)
+>>> dv1
+'0b1111011'
+>>> vos1 = oct(hh)
+>>> vos1
+'0o173'
+>>> shs1 = hex(hh)
+>>> shs1
+'0x7b'
+```
+
+Обратный перевод с целью проверки:
+
+```py
+>>> int(dv1, 2)
+123
+>>> int(vos1, 8)
+123
+>>> int(shs1, 16)
+123
+>>> hh == int(shs1, 16)
+True
+```
+
+##  Пункт 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
+
+Преобразование в список
+
+```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']
+```
+
+Как видно, такая команда вернула список только из ключей. Можно написать так,
+чтобы в список попали только значения:
+
+```py
+>>> spis4 = list({"A":1,"B":2,"C":9}.values())
+>>> spis4
+[1, 2, 9]
+```
+
+## Пункт 3.3
+
+Преобразование в кортеж (tuple())
+
+```py
+>>> kort7=tuple('Строка символов')
+>>> kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8 = tuple(spis2)
+>>> kort8
+(124, 236, -15, 908)
+>>> kort9 = tuple(({"A":1,"B":2,"C":9}))
+>>> kort9
+('A', 'B', 'C')
+```
+
+Аналогично предыдущему пункту, в кортеж попали только ключи. Значения можно записать в
+кортеж так:
+
+```py
+>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values()))
+>>> kort9
+(1, 2, 9)
+```
+
+## Пункт 3.4
+
+Удаление объектов.
+
+```py
+>>> del strk5, kort8
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__',
+ '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'flt5', 'flt6', 'hh', 'kort7',
+ 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'logiz5', 'logiz6', 'logiz7', 'logiz8',
+ 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3',
+ 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt6', 'vos1']
+```
+
+## Пункт 4.
+
+Арифметические операции
+
+### Пункт 4.1
+
+Сложение и вычитание
+
+```py
+>>> 12 + 7 + 90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994 
+```
+
+Видно, что результат выглядит неточно. Это связанно с тем, что
+вещественные числа в python внутри представляются как двоичные, но не всегда вещественное
+число можно представить как двоичное абсолютно точно, из-за этого возникают такие неточности
+
+```py
+>>> 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
+>>> b
+3   
+>>> 178/45
+3.9555555555555557
+>>> c=-24.6//12.1
+>>> c
+-3.0
+>>> -24.6/12.1
+-2.0330578512396698
+>>> d = 65.45//13
+>>> d
+5.0
+>>> 65.45/13
+5.0346153846153845
+>>> e = 75//3.78
+>>> e
+19.0
+>>> 75/3.78
+>>> 19.841269841269842
+```
+
+## Пункт 4.5
+
+Получение остатка от деления (%)
+
+```py
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+>>> 34%2.3
+1.8000000000000025
+>>> 56.97%6
+2.969999999999999
+```
+
+## Пункт 4.6
+
+Возведение в степень (**)
+
+```py
+>>> 14**3
+2744
+>>> 2.7**3.6
+35.719843790663525
+```
+
+Попробуем проделать арифметические операции над комплексными числами
+
+```py
+>>> comp1 = (3 + 2j)
+>>> type(comp1)
+<class 'complex'>
+>>> comp2 = (6 - 4j)
+>>> type(comp2)
+<class 'complex'>
+>>> comp1 + comp2
+(9-2j)
+>>> comp1 - comp2
+(-3+6j)
+>>> comp1 * comp2
+(26+0j)
+>>> type(comp1 * comp2)
+<class 'complex'>
+>>> comp1 / comp2
+(0.19230769230769232+0.46153846153846156j)
+>>> comp1 // comp2
+Traceback (most recent call last):
+  File "<pyshell#30>", line 1, in <module>
+    comp1 // comp2
+TypeError: can't take floor of complex number.
+>>> comp1 // 6
+Traceback (most recent call last):
+  File "<pyshell#33>", line 1, in <module>
+    comp1 // 6
+TypeError: can't take floor of complex number.
+>>> comp1 % comp2
+Traceback (most recent call last):
+  File "<pyshell#31>", line 1, in <module>
+    comp1 % comp2
+TypeError: can't mod complex numbers.
+>>> comp1 % 6
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    comp1 % 6
+TypeError: can't mod complex numbers.
+>>> comp1 ** comp2
+(-717.4651414273118-23072.00404010235j)
+```
+
+## Пункт 5
+
+Операции с двоичными представлениями чисел
+
+## Пункт 5.1
+
+Двоичная инверсия (в двоичном виде 0 меняется на 1 и наоборот)
+
+```py
+>>> dv1 = 9
+>>> dv2 = ~dv1
+>>> dv2
+-10
+>>> bin(dv1)
+'0b1001'
+>>> bin(dv2)
+'-0b1010'
+```
+
+Видно, что результат не совсем совпадает с ожидаемым видом "0110". Вот почему эту происходит: 
+в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака. Знак
+в двоичных числах записывается с помощью дополнительного кода. Получается, происходит
+следующее:
+    1. Было число 9 (1001)
+    2. Меняем все значения на противоположные, станет 0110
+    3. Теперь надо поменять знак. Чтобы поменять знак, надо, во-первых, инвертировать все
+    значения разрядов - будет опять 1001
+    4. Во-вторых, надо прибавить к полученному числу еще единицу, которая как раз и отвечает
+    за минус. Будет 1001 + 1 = 1010.
+
+В целом, можно сказать, что в Python двоичная инверсия делает из числа n число -(n+1).
+
+## Пункт 5.2
+
+Двоичное "И" (&)
+
+```py
+>>> bin(7&9)
+'0b1'
+>>> bin(7&8)
+'0b0'
+```
+
+Пояснение: 7 в двоичной системе счисления: 0111
+           9 в двоичной системе счисления: 1001
+           Совпадение единиц только в первом разряде, поэтому итог - 0001 или просто 1
+           8 в двоичной системе счисления: 1000
+           Совпадений единиц нет, итог - 0000 или просто 0
+
+## Пункт 5.3
+
+Двоичное "ИЛИ" (|)
+
+```py
+>>> bin(7|9)
+'0b1111'
+>>> bin(7|8)
+'0b1111'
+>>> bin (14|5)
+'0b1111'
+```
+
+Пояснение: 7 в двоичной системе счисления: 0111
+           9 в двоичной системе счисления: 1001
+           Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов
+           есть единица, поэтому итог - 1111
+           8 в двоичной системе счисления: 1000
+           Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов
+           есть единица, поэтому итог - 1111
+           14 в двоичной системе счисления: 1110
+           5 в двоичной системе счисления: 0101
+           Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов
+           есть единица, поэтому итог - 1111
+
+## Пункт 5.4
+
+Двоичный XOR (^) (возвращается единица, если оба разряда разные)
+
+```py
+>>> bin(14^5)
+'0b1011'
+```
+
+Пояснение: 14 в двоичной системе счисления: 1110
+           5 в двоичной системе счисления: 0101
+           Возвращается 1, если оба разряда разные, поэтому итог - 1011 или 11 в десятичной сс
+           
+## Пункт 5.5
+
+Побитовый сдвиг (<< влево) и (>> вправо).
+Биты, которые "выпадают" за пределы числа, отбрасываются.
+Освободившиеся позиции заполняются нулями.
+
+```py
+>>> h = 14
+>>> bin(h)
+'0b1110'
+>>> g = h << 2
+>>> g
+56
+>>> bin(g)
+'0b111000'
+```
+
+Было 001110. Сдвинули влево на один разряд, будет 011100. Сдвинули еще раз - 111000.
+Слева можно добавить сколько угодно незначащих нулей, чтобы было нагляднее.
+
+```py  
+>>> g1 = h >> 1
+>>> g1
+7
+>>> bin(g1)
+'0b111'  
+>>> g2 = h >> 2
+>>> g2
+3
+>>> bin(g2)
+'0b11'
+```
+
+Было 1110. Сдвиг вправо на один разряд: 0111. Еще на один - 0011 (Биты, выходящие за
+правый край, отбрасываются).
+
+Возьмем два двоичных числа:
+1011101 (в десятичной системе это 93)
+1100110 (в десятичной системе это 102)
+
+```py
+>>> ~93
+-94
+>>> bin(~93)
+'-0b1011110'
+>>> bin(93&102)
+'0b1000100'
+>>> bin(93|102)
+'0b1111111'
+>>> bin(93^102)
+'0b111011' 
+>>> 93 >> 3
+11
+>>> bin(93 >> 3)
+'0b1011'
+>>> 102 << 2
+408
+>>> bin (102 << 2)
+'0b110011000'
+```
+
+## Пункт 6
+
+Операции при работе с последовательностями
+
+## Пункт 6.1
+
+Конкатенация (объединение)
+
+```py
+>>> 'Система '+'регулирования'
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+!! Конкатенировать словари и множества нельзя.
+Словари нельзя конкатенировать напрямую с помощью +, потому что ключи должны быть
+уникальными, и если у двух складываемых словарей будет одинаковая пара ключей, будет
+конфликтная ситуация.
+Множества нельзя складывать потому, что они не итерируются так, как итерируются другие
+коллекции, например, списки или кортежи. Конкатенация подразумевает добавление в конец,
+но у множеств нет конца в таком же понимании, как, например, у списков.
+
+```py
+>>> {'one':1 , 'two':2} + {'three':3}
+Traceback (most recent call last):
+  File "<pyshell#90>", line 1, in <module>
+    {'one':1 , 'two':2} + {'three':3}
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+>>> {1, 2} + {1, 3, 3, 4}
+Traceback (most recent call last):
+  File "<pyshell#85>", line 1, in <module>
+    {1, 2} + {1, 3, 3, 4}
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+
+## Пункт 6.2
+
+Повторение (*)
+
+```py
+>>> 'ля-'*5
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*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
+'Температура = %g %s  %g'
+>>> stroka % (16, "меньше")
+Traceback (most recent call last):
+  File "<pyshell#113>", line 1, in <module>
+    stroka % (16, "меньше")
+TypeError: not enough arguments for format string
+>>> stroka % (16,' меньше ',25,15)
+Traceback (most recent call last):
+  File "<pyshell#118>", line 1, in <module>
+    stroka % (16,' меньше ',25,15)
+TypeError: not all arguments converted during string formatting
+```
+
+Вот различные типы вставок для оператора %:
+    %s - строка
+    %d и %i - целое число (d - всегда десятичное, а i - десятичное или переведенное
+         в десятичное из другой с/с, а еще может содержать знак)
+    %f - число с плавающей точкой
+    %e - экспоненциальная форма записи числа
+    %g - автовыбор между e и f в зависимости от размера (очень большие и очень близкие к нулю
+         числа удобнее записать в экспоненциальной форме. Обычно %g будет использовать %f,
+         если значение находится в пределах от 1e-4 до 1e+15)
+    %.nf - число с плавающей точкой, но конкретным количеством знаков после запятой (пр. %.2f)
+
+```py
+>>> 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
+>>> zz
+-7
+>>> zz -= 3
+>>> zz
+-10
+>>> stroka = 'Система'
+>>> stroka += ' регулирования'
+>>> stroka
+'Система регулирования'
+```
+
+## Пункт 7.3
+
+Присваивание с умножением и делением.
+
+```py
+>>> type(zz)
+<class 'int'>
+>>> zz /= 2
+>>> zz
+-5.0
+>>> type(zz)
+<class 'float'>
+>>> zz *= 5
+>>> zz
+-25.0
+>>> stroka = "mew "
+>>> stroka *= 3
+>>> stroka
+'mew mew mew '
+```
+
+## Пункт 7.4
+
+```py
+>>> zz //= 4
+>>> zz
+-7.0
+>>> zz %= -0.45
+>>> zz
+-0.24999999999999983
+```
+
+## Пункт 7.5
+
+Множественное присваивание
+
+```py
+>>> w = v = 10
+>>> w
+10
+>>> v
+10
+>>> n1, n2, n3 = (11, -3, 'all')
+>>> n1
+11
+>>> n2
+-3
+>>> n3
+'all'
+>>> x1, x2, x3 = ["a", 67, None]
+>>> x1
+'a'
+>>> x2
+67
+>>> x3
+>>> type(x3)
+<class 'NoneType'>
+>>> s1, s2, s3 = {"one": 1, "two": 2, "three": 3}
+>>> s1, s2, s3
+('one', 'two', 'three')
+>>> s1, s2, s3 = {"one": 1, "two": 2, "three": 3}.values()
+>>> s1, s2, s3
+(1, 2, 3)
+>>> y1, y2, y3 = {"one": 1, "two": 2, "three": 3}.items()
+>>> y1
+('one', 1)
+>>> y2
+('two', 2)
+>>> y3
+('three', 3)
+>>> m1, m2, m3 = {1, 2, 3}
+>>> m1, m2, m3
+(1, 2, 3)
+>>> m1, m2, m3 = {54, 9, 0}
+>>> m1, m2, m3
+(0, 9, 54)
+>>> c1, c2, c3 = "cat", "dog", "pig"
+>>> c1, c2, c3
+('cat', 'dog', 'pig')
+```
+
+## Пункт 8
+
+Логические операции
+
+## Пункт 8.1
+
+Используем операции сравнения на ранее созданных переменных:
+
+```py
+>>> w == v
+True
+>>> w != v
+False
+>>> w < v
+False
+>>> w > v
+False
+>>> w <= v
+True
+>>> w >= v
+True
+>>> 0 == False
+True
+>>> 1 == True
+True
+>>> 0 == None
+False
+>>> None == None
+True
+>>> 5 != 5.0000
+False
+>>> inf = float ("Infinity")
+>>> inf1 = float("-inf")
+>>> inf > -inf
+True
+>>> inf2 = float ("Infinity")
+>>> inf == inf2
+True
+>>> [1, 2, 3] == (1, 2, 3)
+False
+>>> "9" == 9
+False
+>>> None > 0
+Traceback (most recent call last):
+  File "<pyshell#198>", line 1, in <module>
+    None > 0
+TypeError: '>' not supported between instances of 'NoneType' and 'int'
+>>> '100' < 100
+Traceback (most recent call last):
+  File "<pyshell#200>", line 1, in <module>
+    '100' < 100
+TypeError: '<' not supported between instances of 'str' and 'int'
+```
+
+## Пункт 8.2
+
+Проверка наличия заданного элемента
+
+```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
+>>> a = [1, 2, 3]
+>>> b = a
+>>> b
+[1, 2, 3]
+>>> a == b
+True
+>>> a in b
+False
+```
+
+## Пункт 8.3
+
+Создание больших логических выражений
+
+```py
+>>> a = 17
+>>> b = 6
+>>> (a >= b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+>>> ((per1 + 50) in dic1.values()) and not per2 or 'Tula' in dic1
+True
+>>> not(len(dic1) == 3) or (sum(dic1.values()) > 300) or ('ITAE' in dct1['Depart'])
+False
+```
+
+## Пункт 8.4
+
+Проверка ссылок переменных на один и тот же объект
+
+Проверим is для разных объектов неизменяемого типа с одним значением
+
+```py
+>>> v = w = 10
+>>> w is v
+True
+>>> w1 = ['A', 'B']
+>>> v1 = ['A', 'B']
+>>> w1 is v1
+False
+>>> w1 == v1
+True
+```
+
+--Почему так происходит?--
+Оператор is проверяет, ссылаются ли объекты на один и тот же адрес в памяти. Переменные
+целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти.
+Словари были созданы в разных строках, и адреса они разные, т.е. они ссылаются на разные
+участки в памяти, поэтому is возвращает False. Можно убедиться в этом наглядно: 
+
+```py
+>>> id(w)
+2290989558352
+>>> id(v)
+2290989558352
+>>> id(w1)
+2291031104768
+>>> id(v1)
+2291031109824
+>>> a = 15
+>>> b = 15
+>>> a is b
+True
+>>> id(a)
+2290989558512
+>>> id(b)
+2290989558512
+```
+
+Это связано с тем, что python - очень высокоуровневый язык, возможности в плане оперирования
+памятью сведены к минимуму, и иногда использование памяти оптимизировано. Например, числа
+от -5 до 256 python подвергает интернированию, т.е. делает так, чтобы они ссылались на
+один участок памяти (конкретно в cpython). Но с числами, не попадающими в этот диапазон, это
+не работает.
+
+```py
+>>> aaa = 567
+>>> bbb = 567
+>>> aaa is bbb
+False
+>>> a = b = 567
+>>> a is b
+True
+>>> aa = ()
+>>> bb = ()
+>>> aa is bb
+True
+```
+
+## Пункт 9
+
+Операции с объектами, выполняемые с помощью методов
+
+```py
+>>> stroka='Микропроцессорная система управления'
+>>> dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__',
+ '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
+ '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__',
+ '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
+ '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__',
+ '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith',
+ 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii',
+ 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace',
+ 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition',
+ 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
+ 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title',
+ 'translate', 'upper', 'zfill']
+```
+
+## Пункт 9.1
+
+Методы строк
+
+```py
+>>> stroka.find('пр')
+5
+>>> stroka.count("с")
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ')
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka.lower()
+'микропроцессорная система управления'
+>>> stroka3=" ".join(spis22)
+>>> stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1
+'Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+>>> strk2='Момент времени {1}, значение = {0}:{2}
+>>> strk2
+'Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3
+'Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+
+## Пункт 9.2
+
+Методы списков
+
+```py
+>>> spsk = [12, "kitten", (1, 2), "a", 56.78]
+>>> spsk.pop(2)
+(1, 2)
+>>> spsk
+[12, 'kitten', 'a', 56.78]
+>>> spsk.append('c')
+>>> spsk
+[12, 'kitten', 'a', 56.78, 'c']
+>>> spsk.insert(2,'a')
+>>> spsk
+[12, 'kitten', 'a', 'a', 56.78, 'c']
+>>> spsk.count('a')
+2
+```
+
+## Пункт 9.3
+
+Методы кортежей
+
+Кортежи неизменяемы, поэтому методов, связанных с удалением или добавлением элементов, нет
+
+```py
+>>> cor = (11, "oopsie", "doopsie", 64.9, 5+7j)
+>>> cor.count(11)
+1
+>>> cor.index(64.9)
+3
+>>> cor.index("nothing")
+Traceback (most recent call last):
+  File "<pyshell#316>", line 1, in <module>
+    cor.index("nothing")
+ValueError: tuple.index(x): x not in tuple
+```
+
+## Пункт 9.4
+
+Методы словарей
+
+```py
+>>> newdi = di.copy()
+>>> newdi
+{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False}
+>>> di.get("key2")
+'val2'
+>>> print(di.get("key77"))
+None
+>>> di.items()
+dict_items([('key1', 1), ('key2', 'val2'), ('key3', 34.6), ('key4', 'f'), ('key5', False)])
+>>> type(di.items())
+<class 'dict_items'>
+>>> di.keys()
+dict_keys(['key1', 'key2', 'key3', 'key4', 'key5'])
+>>> di.values()
+dict_values([1, 'val2', 34.6, 'f', False])
+
+Пояснение:
+    Возвращаются объекты dict_keys, dict_values, dict_items, и они - объекты-итераторы. Они
+    ссылаются на адреса ключей или значений в памяти, но не хранят значения. Также эти объекты
+    автоматически обновляются при обновлении словаря. Например, добавим в словарь пару:
+    
+```py
+>>> di["key6"] = 546
+>>> di
+{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False, 'key6': 546}
+>>> dikeys = di.keys()
+>>> dikeys
+dict_keys(['key1', 'key2', 'key3', 'key4', 'key5', 'key6'])
+>>> di.popitem()
+('key6', 546)
+>>> di
+{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False}
+>>> dikeys
+dict_keys(['key1', 'key2', 'key3', 'key4', 'key5'])
+>>> newdi.clear()
+>>> newdi
+{}
+>>> di.pop("key3")
+34.6
+>>> di
+{'key1': 1, 'key2': 'val2', 'key4': 'f', 'key5': False}
+>>> se = {1, "val2", 34.6, "f", False, 546}
+>>> se
+{False, 1, 34.6, 546, 'f', 'val2'}
+>>> se.add(5+6j)
+>>> se
+{False, 1, 34.6, 546, (5+6j), 'f', 'val2'}
+>>> newse = se.copy()
+>>> newse
+{False, 1, 34.6, 546, (5+6j), 'f', 'val2'}
+>>> se.remove(1)
+>>> se
+{False, 34.6, 546, (5+6j), 'f', 'val2'}
+>>> se.remove(90000)
+Traceback (most recent call last):
+  File "<pyshell#348>", line 1, in <module>
+    se.remove(90000)
+KeyError: 90000
+>>> se.discard("f")
+>>> se.discard(90000)
+>>> print(se.discard(90000))
+None
+>>> newse.clear()
+>>> newse
+set()
+>>> se.pop()
+False
+>>> se
+{34.6, 546, (5+6j), 'val2'}
+>>> se.update({True, "kekeke"})
+>>> se
+{True, 34.6, 546, 'val2', (5+6j), 'kekeke'}
+```
\ No newline at end of file
diff --git a/TEMA3/task.md b/TEMA3/task.md
new file mode 100644
index 0000000..8b1569f
--- /dev/null
+++ b/TEMA3/task.md
@@ -0,0 +1,69 @@
+# Общее контрольное задание по теме 3
+
+Володин Денис, А-02-23
+
+## Задание
+    • Преобразовать восьмеричное значение 45 в целое число.
+    • Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+    • Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+    • Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+    • Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+    • Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+    • Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>> octv = '45'
+>>> decv = int(octv, 8)
+>>> decv
+37
+>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
+>>> keyD = list(D.keys())
+>>> keyD
+['усиление', 'запаздывание', 'постоянная времени']
+>>> valD = list(D.values())
+>>> valD
+[23, 12, 78]
+>>> tupD = (keyD, valD)
+>>> tupD
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+>>> ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+>>> ((~(13 & 27)) ^ 14) << 2
+-32
+>>> lst = ["колебат"] * 4
+>>> lst[1] += lst[2]
+>>> lst
+['колебат', 'колебатколебат', 'колебат', 'колебат']
+>>> lst.pop(2)
+'колебат'
+>>> lst
+['колебат', 'колебатколебат', 'колебат']
+>>> 'аткол' in lst[1]
+True
+>>> D
+{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
+>>> dir(D)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__',
+ '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
+ '__getitem__', '__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])
+>>> sen = "Создать объект - символьную строку с текстом данного предложения"
+>>> senl = sen.split()
+>>> senl
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl[senl.index("-")] = ","
+>>> senl
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl.remove("данного")
+>>> senl
+['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+