diff --git a/TEMA3/figure0.png b/TEMA3/figure0.png
new file mode 100644
index 0000000..530a6ae
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..210c6bd
--- /dev/null
+++ b/TEMA3/report.md
@@ -0,0 +1,674 @@
+# Отчет по Теме 3
+
+Беженарь Алёна Николаевна
+
+## Способы использования объектов разных типов.
+
+## 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") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+    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']
+>>> spis4=list({"A":1,"B":2,"C":9}.values())  #Преобразование словаря в список по значениям
+>>> spis4
+[1, 2, 9]
+>>> spis5=list({"A":1,"B":2,"C":9}.items())  #Преобразование словаря в список ключи и значения
+>>> spis5
+[('A', 1), ('B', 2), ('C', 9)]
+```
+### 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__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+Использую операции с приведением типов на практике
+```py
+>>> fullName = "StepanovAV"
+>>> spisok = list(fullName) # Преобразование строки символов в список
+>>> spisok
+    ['B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N']
+>>> kortezh = tuple(spisok) # Преобразование списка в кортеж
+>>> kortezh
+    ('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')
+>>> stroka = str(kortezh) # Преобразование кортежа в строку символов
+>>> stroka
+    "('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')"
+```
+## 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
+```
+Проведем операции с комплексными числами
+
+```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 в конец двоичного представления числа)
+>>> g
+     56
+>>> bin(g)
+    '0b111000'
+>>> g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
+>>> bin(g1)
+    '0b111'
+>>> g1
+    7
+>>> g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)
+
+>>> bin(g2)
+    '0b11'
+>>> g2
+    3
+```
+Использование операций с двоичным представлением чисел на практике
+
+```py
+>>> a = 0b111010111
+>>> a
+    471
+>>> b = 0b100100100
+>>> b
+    292
+>>> ~a # Двоичная инверсия
+    -472
+>>> bin(~a)
+    '-0b111011000'
+>>> a & b # Двоичное «И» 
+    260
+>>> bin(a & b)
+    '0b100000100'
+>>> a | b # Двоичное «ИЛИ
+    503
+>>> bin(a | b)
+    '0b111110111'
+>>> a ^ b # Двоичное «исключающее ИЛИ»
+    243
+>>> bin(a ^ b)
+   '0b11110011'
+>>> a >> 3 # Поразрядный сдвиг
+    58
+>>> bin(a >> 3)
+    '0b111010'
+```
+
+## 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 # Операция меньше
+    True
+>>> w > v # Операция больше
+    False
+>>> w <= v # Операция меньше или равно
+    True
+>>> w >= v # Операция больше или равно
+    False
+```
+### 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()))
+    False
+>>> 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 = "Микропроцессорная система управления"
+>>>dir(stroka)
+   ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__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']
+
+>>> stroka.find("пр") # Поиск первого вхождения подстроки в строку(Возвращает номер позиции первого вхождения указанного контекста или значение -1)
+    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]
+>>> 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..b569a8e
--- /dev/null
+++ b/TEMA3/report.py
@@ -0,0 +1,481 @@
+#Протокол по ТЕМЕ 3 Беженарь Алёна Николаевна
+import os
+os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA3")
+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
+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") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+ValueError: invalid literal for int() with base 10: '98.76'
+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
+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
+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}"
+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']
+spis4=list({"A":1,"B":2,"C":9}.values())  #Преобразование словаря в список по значениям
+spis4
+[1, 2, 9]
+spis5=list({"A":1,"B":2,"C":9}.items())  #Преобразование словаря в список ключи и значения
+spis5
+[('A', 1), ('B', 2), ('C', 9)]
+kort7 = tuple("Строка символов") # Преобразование строки символов в кортеж
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8 = tuple(spis2) # Преобразование списка в кортеж
+kort8
+(124, 236, -15, 908)
+kort9 = tuple({"A" : 1, "B" : 2, "C" : 3}) # Преобразование словаря в кортеж
+kort9
+('A', 'B', 'C')
+del strk5, kort8
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+fullName = "BezhenarAN"
+spisok = list(fullName) # Преобразование строки символов в список
+spisok
+['B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N']
+kortezh = tuple(spisok) # Преобразование списка в кортеж
+kortezh
+('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')
+stroka = str(kortezh) # Преобразование кортежа в строку символов
+stroka
+"('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')"
+12+7+90 # Сложение целых чисел
+109
+5.689e-1 - 0.456 # Вычитание вещественных чисел
+0.11289999999999994
+23.6 + 54 # Сложение вещественного и целого чисел
+77.6
+14 - 56.7 + 89 # Сложение и вычитание целых и вещественных чисел
+46.3
+-6.7 * 12 # Умножение вещественного и целого чисел
+-80.4
+-234.5 / 6 # Деление вещественного и целого чисел
+-39.083333333333336
+a = 178 / 45 # Деление целых чисел, но результат всё равно вещественное число
+a
+3.9555555555555557
+type(a)
+<class 'float'>
+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
+148 % 33 # Остаток от деления двух целых чисел
+16
+12.6 % 3.8 # Остаток от деления двух вещественных чисел
+1.2000000000000002
+12 % 6.5
+5.5
+12.0 % 5
+2.0
+14 ** 3 #Целое число возводится в целую степень
+2744
+e = 2.7 ** 3.6 #Вещественное число возводится в вещественную степень
+e
+35.719843790663525
+12 ** 6.5
+10343751.997175492
+12.0 ** 5
+248832.0
+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#108>", line 1, in <module>
+    z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+dv1 = 9
+bin(dv1)
+'0b1001'
+dv2 = ~dv1
+dv2
+-10
+bin(dv2)
+'-0b1010'
+7 & 9 # 0111 & 1001 = 0001
+1
+bin(7)
+'0b111'
+bin(9)
+'0b1001'
+7 & 8 # 0111 & 1000 = 0000
+0
+bin(8)
+'0b1000'
+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'
+14 ^ 5 # 1110 ^ 0101 = 1011
+11
+bin(14)
+'0b1110'
+bin(5)
+'0b101'
+bin(11)
+'0b1011'
+h = 14
+bin(h)
+'0b1110'
+g = h << 2
+g
+56
+bin(g)
+'0b111000'
+g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
+bin(g1)
+'0b111'
+g1
+7
+g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)
+bin(g2)
+'0b11'
+g2
+3
+a = 0b111010111
+a
+471
+b = 0b100100100
+b
+292
+~a # Двоичная инверсия
+-472
+bin(~a)
+'-0b111011000'
+a & b # Двоичное «И»
+260
+bin(a & b)
+'0b100000100'
+a | b # Двоичное «ИЛИ
+503
+bin(a | b)
+'0b111110111'
+a ^ b # Двоичное «исключающее ИЛИ»
+243
+bin(a ^ b)
+'0b11110011'
+a >> 3 # Поразрядный сдвиг
+58
+bin(a >> 3)
+'0b111010'
+"Система " + "регулирования" # Конкатенация двух строк символов
+'Система регулирования'
+["abc", "de", "fg"] + ["hi", "jkl"] # Конкатенация двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+("abc", "de", "fg") + ("hi", "jkl") # Конкатенация двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+### 6.2. Повторение.
+"ля-" * 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)
+stroka = "Система автоматического управления"
+"автомат" in stroka # Наличие подстроки в строке
+True
+"ку" in ["ку", "-"] * 3 # Наличие контекста в списке
+True
+"ля-" in ("abc", "de", "fg", "hi", "jkl") # Наличие контекста в кортеже
+False
+stroka = "Температура = %g %s %g"
+stroka % (16, "меньше", 25)
+'Температура = 16 меньше 25'
+stroka = "Температура = %(zn1)g %(sravn)s %(zn2)g"
+stroka % {"zn1" : 16, "sravn" : "меньше", "zn2" : 25}
+'Температура = 16 меньше 25'
+zz = -12
+zz
+-12
+zz += 5 # Увеличение значения на 5
+zz
+-7
+zz -= 3 # Уменьшение значения на 3
+zz
+-10
+stroka = "Система"
+stroka += " регулирования" # Конкатенация строк символов через оператор +=
+stroka
+'Система регулирования'
+zz /= 2 # Деление значения на 2
+zz
+-5.0
+zz *= 5 # Умножение значения на 5
+zz
+-25.0
+stroka = "ABC "
+stroka *= 3 # Повторение строки символов 3 раза
+stroka
+'ABC ABC ABC '
+a = 14
+a //= 5 # Целочисленное деление
+a
+2
+b = 13
+b %= 6 # Получение остатка от деления
+b
+1
+c = 2
+c **= 4 # Возведение в степень
+c
+16
+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
+('all', 11, -3)
+w == v # Операция равенства
+True
+w != v # Операция неравенства
+False
+v += 1
+w < v # Операция меньше
+True
+w > v # Операция больше
+False
+w <= v # Операция меньше или равно
+True
+w >= v # Операция больше или равно
+False
+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 = 17
+b = -6
+(a >= b) and ("book" in mnoz1) and not ("Pskov" in dic1)
+True
+(a % 3 == 1) and (("cap" in mnoz1) or (45 in dic1.values()))
+False
+not (b < 0) or (len(mnoz1)== 4)
+True
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+True
+w1 = ["A", "B"]
+v1 = ["A", "B"]
+w1 is v1
+False
+stroka = "Микропроцессорная система управления"
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__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']
+stroka.find("пр") # Поиск первого вхождения подстроки в строку
+5
+stroka.count("с") # Подсчет вхождений подстроки в строку
+4
+stroka.replace(" у", " автоматического у") # Замена всех вхождений подстроки в строку
+'Микропроцессорная система автоматического управления'
+spis22 = stroka.split(" ") # Разделение строки на список подстрок по определенному разделителю
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper() # Перевод строки в верхний регистр
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3 = " ".join(spis22) # Создание строки из списка построк с некоторым разделителем
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с") # Создание кортежа с результатом первого вхождения подстроки  в строку
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с") # Создание кортежа с результатом последнего вхождения подстроки  в строку
+('Микропроцессорная си', 'с', 'тема управления')
+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'
+spsk = [1, 2, 3, 4, 5, 6]
+spsk.pop(2) # Удаление элемента по индексу из списка, с возвращением его значения 3
+3
+spsk
+[1, 2, 4, 5, 6]
+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
+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
+{}
+mnozhestvo = {"Apple", "Orange", "Peach", "Pear"}
+mnozhestvo.add("Banana") # Добавление элемента в множество
+mnozhestvo
+{'Orange', 'Pear', 'Peach', 'Banana', 'Apple'}
+mnozhestvo2 = mnozhestvo.copy() # Копирование множества
+mnozhestvo2
+{'Orange', 'Pear', 'Peach', 'Banana', 'Apple'}
+mnozhestvo2.remove("Apple") # Удаление элемента из множества
+mnozhestvo2
+{'Orange', 'Pear', 'Peach', 'Banana'}
+mnozhestvo.difference(mnozhestvo2) # Сравнение двух множеств по содержимому, возвращает разницу
+{'Apple'}
+mnozhestvo2.clear() # Очистка множества
+mnozhestvo2
+set()
diff --git a/TEMA3/task.md b/TEMA3/task.md
new file mode 100644
index 0000000..3015da8
--- /dev/null
+++ b/TEMA3/task.md
@@ -0,0 +1,54 @@
+# Общее контрольное задание по теме 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) #1 пункт
+>>> znch
+    37
+>>> D = {"усиление" : 23, "запаздывание" : 12, "постоянная времени" : 78} #2 пункт
+>>> 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 #3 пункт
+    5.278031643091577
+>>> (~(13 & 27) ^ 14) << 2 #4 пункт
+    -32
+>>> list1 = ["колебат",] * 4 #5 пункт
+>>> list1
+    ['колебат', 'колебат', 'колебат', 'колебат']
+>>> "аткол" in list1[1] + list1[2]
+    True
+>>> dir(D) #6 пункт
+    ['__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 = "Создать объект - символьную строку с текстом данного предложения." #7 пункт
+>>> string_list = string.split(" ")
+>>> string_list[string_list.index("-")] = ","
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> string_list.remove("данного")
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```
\ No newline at end of file