idz

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1. Шабатов Андрей
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('C:\\Users\\u207-12\\Desktop\\python-labs\\TEMA1')

TEMA1/report.md

@@ -0,0 +1,134 @@
+# Отчет по теме 1. Шабатов Андрей А-02-23
+
+## 1. На рабочем диске была создана папка, в которой хранятся все темы
+
+## 2. Запуск Python
+
+## 3. Изучил диалоговое окно и ввел пробную инструкцию
+
+```py
+print('Hello')
+Hello
+```
+
+## 4. Выполнил инструкцию, которая потребовала текст с клавиатуры
+
+```py
+h=input('Your name=')
+Your name=Andruxa
+```
+
+## 5. Закрыл диалоговое окно
+
+```py
+exit()
+```
+
+## 6. Запустил IDLE Python
+
+## 7. Изучил главное командное окно
+
+## 8. Настройка рабочего каталога 
+
+```py
+import os
+os.chdir('C:\\Users\\u207-12\\Desktop\\python-labs\\TEMA1')
+```
+
+## 9. Изучил главное меню. В настройках изменил шрифт и размер начального окна.
+
+## 10 Создал новый файл. Cохранил его в рабочем каталоге под названием Pr0.py и запустил его тремя способами:
+1) через меню редактора
+2) с помощью инструкции import Pr0
+3) c помощью клавиши F5(быстрый запуск).
+
+```py
+#Программа по Теме 1. Шабатов Андрей
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('C:\\Users\\u207-12\\Desktop\\python-labs\\TEMA1')
+```
+
+```py
+Hello
+Your name=123
+```
+
+## 11. Запустил программу prb1.py и изучил возможность повторения введенах ранее команд
+
+```py
+import prb1
+Как Вас зовут? andruxa
+Привет, andruxa
+```
+
+## 12-13. Запустил файл Pr0.cpython-34.pyc в текстовом редакторе
+
+![](cache.png)
+Компиляция необходима, для того чтобы оптимизировать запуск программы. Также она позволяет переводить программу в машинный код.
+
+## 14. Изучил раздел помощи
+
+```py
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+help(print);help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+```
+
+## 15
+
+### 15.1. Запустил файл prb1.py и изучил перемещение между окнами.
+
+```py
+Как Вас зовут? andruxa
+Привет, andruxa
+```
+### 15.2 Запустил программу из файла tdemo_chaos.py
+
+![](tdemo.png)
+
+### 15.3 Оценил возможности использования графических примеров в Python
+
+![](clock.png)
+
+
+## 16. Завершил работу со средой

TEMA2/report.md

@@ -0,0 +1,550 @@
+# Отчет по теме 2. Шабатов Андрей А-02-23
+
+## 1. Запустил оболочку IDLE и настроил рабочий каталог
+
+```py
+import os
+os.chdir("C:\\Users\\user\\Desktop\\python-labs\\TEMA2")
+```
+
+## 2. Изучил простые объекты
+
+### 2.1 Операции присваивания
+```py
+f1=16; f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+```
+
+### 2.2 Функции dir() и type()
+
+```py
+dir()
+['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+```
+### 2.3 Инструкция del
+
+```py
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
+```
+
+## 3. Изучил правила изменения объектов в Python
+
+```py
+gg1=1.6  #значение в виде вещественного числа
+gg1
+1.6
+hh1='Строка'  #значение в виде символьной строки
+hh1
+'Строка'
+73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
+SyntaxError: invalid decimal literal
+and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+SyntaxError: invalid syntax
+```
+
+## 4. Вывел список ключевых слов
+
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+q = keyword.kwlist
+q
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## 5. Вывел список встроенных идентификаторов и использовал некоторые функции
+
+```py
+ex1 = -9999
+print(abs(ex1))
+9999
+ex2 = 'ПРИМЕР2'
+print(len(ex2))
+7
+ex3 = [1,2,3,4,5,6]
+print(max(ex3))
+6
+print(max(ex3),min(ex3))
+6 1
+exp4 = pow(2,5)
+print(exp4)
+32
+print(round(33.3))
+33
+print(round(33.5))
+34
+ex5 = [3,4,6,2,1,5]
+print(sorted(ex5))
+[1, 2, 3, 4, 5, 6]
+print(sum(ex5))
+21
+ex61 = ('alice','bob','max')
+ex62 = (20,35,50)
+ex6 = zip(ex61,ex62)
+print(list(ex6))
+[('alice', 20), ('bob', 35), ('max', 50)]
+```
+
+## 6. Убедился в чувствительности регистра
+```py
+Gg1 = 45
+gg1,Gg1
+(1.6, 45)
+```
+
+## 7. Изучил базовые типы объектов
+
+### 7.1. Логический тип
+
+```py
+bb1=True;bb2=False
+print((bb1,bb2), type(bb1))
+(True, False) <class 'bool'>
+```
+
+### 7.2. Простые типы
+
+```py
+ii1=-1234567890
+ff1=-8.9876e-12
+ff1
+-8.9876e-12
+dv1=0b1101010
+type(dv1)
+<class 'int'>
+vsm1=0o52765
+shest1=0x7109af6
+type(shest1)
+<class 'int'>
+cc1=2-3j
+a=3.67; b=-0.45
+cc2 = complex(a,b)
+cc2
+(3.67-0.45j)
+```
+
+### 7.3. Изучение строк
+
+```py
+ss1='Это - строка символов'
+ss1
+'Это - строка символов'
+ss11 = "Это - строка символов"
+ss11
+'Это - строка символов'
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+      
+Это - " строка символов", 
+ 	 выводимая на двух строках
+ss1b = "Меня зовут: \n Шабатов А.А."
+      
+ss1b
+      
+'Меня зовут: \n Шабатов А.А.'
+print(ss1b)
+      
+Меня зовут: 
+ Шабатов А.А.
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+print(mnogo)
+      
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+**Обращение к частям строки символов с помощью индексов**
+
+```py
+ss1[0]
+      
+'Э'
+ss1[8]
+      
+'р'
+ss1[-2]
+      
+'о'
+ss1[6:9]
+      
+'стр'
+ss1[13:]
+      
+'символов'
+ss1[:13]
+      
+'Это - строка '
+ss1[5:-8]
+      
+' строка '
+ss1[3:17:2]
+      
+'  тоасм'
+ss1[17:3:-2]
+      
+'омсаот '
+ss1[-4:3:-2]
+      
+'омсаот '
+ss1[4]='='
+      
+Traceback (most recent call last):
+  File "<pyshell#89>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+ss1 = ss1[:4]+'='+ss1[5:]
+      
+ss1
+      
+'Это = строка символов'
+```
+**Самостоятельно создал объекты с разными срезами**
+```py
+ss1b[:6]
+      
+'Меня з'
+ss1b[:-6]
+      
+'Меня зовут: \n Шабато'
+ss1b[3:16]
+      
+'я зовут: \n Ша'
+ss1b[13:]
+      
+' Шабатов А.А.'
+ss1b[18]
+      
+'т'
+ss1b[-1]
+      
+'.'
+ss1b = ss1b[:4]+'!!!'+ss1b[5:]
+      
+ss1b
+      
+'Меня!!!зовут: \n Шабатов А.А.'
+```
+### 7.4. Самостоятельно придумал объекты и отобразил их типы
+
+```py
+pr1 = 1231
+      
+print(type(pr1))
+      
+<class 'int'>
+pr2 = 23323.44211
+      
+print(type(pr2))
+      
+<class 'float'>
+pr3 = False
+      
+print(type(pr3))
+      
+<class 'bool'>
+pr4 = 1+42j
+      
+print(type(pr4))
+      
+<class 'complex'>
+pr5 = 'rwwqrqrwtqw'
+      
+print(type(pr5))
+      
+<class 'str'>
+```
+
+## 8. Изучил сложные типы объектов
+
+### 8.1. Изучение списков
+```py
+spis1=[111,'Spisok',5-9j]
+      
+print(spis1)
+      
+[111, 'Spisok', (5-9j)]
+stup=[0,0,1,1,1,1,1,1,1]
+      
+spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+      
+spis[-1]
+      
+10
+stup[-8::2]
+      
+[0, 1, 1, 1]
+spis1[1]='Список'
+      
+spis1
+      
+[111, 'Список', (5-9j)]
+len(spis1)
+      
+3
+```
+**Использование методов объектов**
+```py
+spis1.append('New item')
+      
+spis1+['New item']
+      
+[111, 'Список', (5-9j), 'New item', 'New item']
+spis1
+      
+[111, 'Список', (5-9j), 'New item']
+spis1.append(ss1b)
+      
+spis1
+      
+[111, 'Список', (5-9j), 'New item', 'Меня!!!зовут: \n Шабатов А.А.']
+spis1.pop(1)
+      
+'Список'
+spis1
+      
+[111, (5-9j), 'New item', 'Меня!!!зовут: \n Шабатов А.А.']
+```
+**Самостоятельно изучил другие методы**
+```py
+spisok = [1,'qwfwq',2222]
+      
+spisok.insert(0, 'qwer')
+      
+spisok
+      
+['qwer', 1, 'qwfwq', 2222]
+spisok.insert(2,1)
+      
+spisok
+      
+['qwer', 1, 1, 'qwfwq', 2222]
+spisok.remove(1)
+      
+spisok
+      
+['qwer', 1, 'qwfwq', 2222]
+spisok1 = [1,2,3,4]
+      
+spisok.extend(spisok1)
+      
+spisok
+      
+['qwer', 1, 'qwfwq', 2222, 1, 2, 3, 4]
+spisok1.clear()
+      
+spisok1
+      
+[]
+spisok2 = [1,32424,42,3,6]
+      
+spisok2.sort()
+      
+spisok2
+      
+[1, 3, 6, 42, 32424]
+spisok2.reverse()
+      
+spisok2
+      
+[32424, 42, 6, 3, 1]
+spisok3 = spisok2.copy()
+      
+spisok3
+      
+[32424, 42, 6, 3, 1]
+spisok.count(1)
+      
+2
+spisok
+      
+['qwer', 1, 'qwfwq', 2222, 1, 2, 3, 4]
+spisok.index(2)
+      
+5
+```
+**Вложенные списки**
+```py
+spis2=[spis1,[4,5,6,7]]
+      
+spis2
+      
+[[111, (5-9j), 'New item', 'Меня!!!зовут: \n Шабатов А.А.'], [4, 5, 6, 7]]
+spis2[0][1]
+      
+(5-9j)
+spis2[0][1]=78
+      
+spis2
+      
+[[111, 78, 'New item', 'Меня!!!зовут: \n Шабатов А.А.'], [4, 5, 6, 7]]
+spis1
+      
+[111, 78, 'New item', 'Меня!!!зовут: \n Шабатов А.А.']
+```
+**Изменив элемент spis2[0][1] во вложенном списке, мы также изменили элемент в списке spis1, потому что это один и тот же объект в памяти**
+
+### 8.2. Объект-кортеж
+```py
+kort1=(222,'Kortezh',77+8j)
+      
+kort1= kort1+(1,2)
+      
+kort1
+      
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+      
+kort1
+      
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня!!!зовут: \n Шабатов А.А.')
+kort2=kort1[:2]+kort1[3:]
+      
+kort2
+      
+(222, 'Kortezh', 1, 2, 'Меня!!!зовут: \n Шабатов А.А.')
+```
+**Использование методов кортежа**
+```py
+kort1.index(2)
+      
+4
+kort1.count(222)
+      
+1
+kort1
+      
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня!!!зовут: \n Шабатов А.А.')
+kort1[2]=90
+      
+Traceback (most recent call last):
+  File "<pyshell#183>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+**Самостоятельно создал объект-кортеж**
+```py
+skort = (1,'aaaa',[3,4,5,6],(True,False))
+      
+skort
+      
+(1, 'aaaa', [3, 4, 5, 6], (True, False))
+skort[3]
+      
+(True, False)
+skort.index(1)
+      
+0
+```
+
+### 8.3. Объект-словарь
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+      
+dic1['Orel']
+      
+56
+dic1['Pskov']=78
+      
+dic1
+      
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+sorted(dic1.keys())
+      
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+      
+[45, 56, 78, 145]
+dic1
+      
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+      
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+      
+dic3['statistics'][2]
+      
+'standart deviation'
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+      
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+      
+dic5
+      
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня!!!зовут: \n Шабатов А.А.'}
+```
+**Создал свой объект-словарь**
+```py
+di1 = (1,2,3,4,5,6,7)
+      
+di2 = ['11','22','33','44','55']
+      
+di12 = dict(zip(di1,di2))
+      
+di12
+      
+{1: '11', 2: '22', 3: '33', 4: '44', 5: '55'}
+```
+В получившимся словаре 5 элементов, потому что функция zip() работает до минимальной длины списка или кортежа
+
+### 8.4 Объект-множество
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+      
+mnoz1
+      
+{'двигатель', 'линия связи', 'микропроцессор', 'датчик'}
+len(mnoz1)
+      
+4
+'датчик' in mnoz1
+      
+True
+mnoz1.add('реле')
+      
+mnoz1.remove('линия связи')
+      
+mnoz1
+      
+{'реле', 'двигатель', 'микропроцессор', 'датчик'}
+```
+
+**Создал свое множество**
+```py
+mn = {'123','456','789','101112','123'}
+      
+mn
+      
+{'789', '456', '123', '101112'}
+'789' in mn
+      
+True
+'1234' in mn
+      
+False
+len(mn)
+      
+4
+mn.add('33333')
+      
+mn
+      
+{'456', '101112', '789', '123', '33333'}
+```
+
+## 9. Закончил сеанс работы в IDLE

TEMA2/task.md

@@ -0,0 +1,48 @@
+# Общее контрольное задание по теме 2
+
+Шабатов Андрей А-02-23
+
+## Задание
+
+•Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+•Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+## Решение
+
+```py
+familia = 'ShabatovAA'
+f = familia[0]
+f
+'S'
+import keyword
+sp_kw = keyword.kwlist
+sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+sp_kw.remove('nonlocal')
+sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+kort_nam = ('Andrew','Stas','Nastya','Jenya')
+type(kort_nam)
+<class 'tuple'>
+kort_nam = kort_nam + ('Dima','Artem')
+kort_nam
+('Andrew', 'Stas', 'Nastya', 'Jenya', 'Dima', 'Artem')
+kort_nam.count('Dima')
+1
+dict_bas = dict(zip(('str','list','tuple'),(familia,sp_kw,kort_nam)))
+dict_bas
+{'str': 'ShabatovAA', 'list': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'tuple': ('Andrew', 'Stas', 'Nastya', 'Jenya', 'Dima', 'Artem')}
+```

TEMA3/Test 1.md

@@ -0,0 +1,52 @@
+# 1. При каких условиях можно создавать программы для среды Python с помощью других текстовых редакторов? Назовите примеры таких редакторов.
+
+Для того чтобы создавать программы на Pythone, текстовый редактор должен сохранять файл с расширением .py
+Примеры таких текстовых редакторов:
+1) Sublime Text
+2) Visual Studio Code
+3) PyCharm
+4) Блокнот
+
+# 2. Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов.
+
+```py
+text = 'Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов'
+text1 = text.split()
+text1
+['Создайте', 'объект,', 'содержащий', 'текст', 'задания', 'данного', 'пункта.', 'Создайте', 'новый', 'объект,', 'в', 'который', 'включите', 'из', 'первого', 'объекта', 'только', 'слова,', 'находящиеся', 'на', 'четных', 'позициях.', 'Напишите', 'инструкции', 'определения', 'класса', 'созданного', 'объекта', 'и', 'списка', 'его', 'атрибутов']
+text1 = text1[1::2]
+text1
+['объект,', 'текст', 'данного', 'Создайте', 'объект,', 'который', 'из', 'объекта', 'слова,', 'на', 'позициях.', 'инструкции', 'класса', 'объекта', 'списка', 'атрибутов']
+type(text1)
+<class 'list'>
+dir(text1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+```
+
+# 3. Создайте кортеж, содержащий слова из итогового созданного объекта в п.2. Напишите инструкции подсчета числа слов и отобразите с использованием формата результат на экране по шаблону: "в кортеже ХХ элементов".
+
+```py
+kort3 = tuple(text1)
+kort3
+('объект,', 'текст', 'данного', 'Создайте', 'объект,', 'который', 'из', 'объекта', 'слова,', 'на', 'позициях.', 'инструкции', 'класса', 'объекта', 'списка', 'атрибутов')
+print("В кортеже ", len(kort3), " элементов")
+В кортеже  16  элементов
+```
+
+# 4. Напишите инструкции создания словаря, в котором ключами будут порядковые номера, а значениями - слова из кортежа, созданного в п.3.
+
+```py
+dict2 = dict(zip(range(16),kort3))
+dict2
+{0: 'объект,', 1: 'текст', 2: 'данного', 3: 'Создайте', 4: 'объект,', 5: 'который', 6: 'из', 7: 'объекта', 8: 'слова,', 9: 'на', 10: 'позициях.', 11: 'инструкции', 12: 'класса', 13: 'объекта', 14: 'списка', 15: 'атрибутов'}
+```
+
+# 5. Преобразуйте значения из словаря во множество. Подсчитайте и выведите на экран число элементов этого множества. 
+
+```py
+mnoj = set(dict2.values())
+n = len(mnoj)
+mnoj;n
+{'текст', 'атрибутов', 'Создайте', 'который', 'слова,', 'на', 'данного', 'объекта', 'объект,', 'инструкции', 'списка', 'позициях.', 'класса', 'из'}
+14
+```

TEMA3/report.md

@@ -0,0 +1,875 @@
+# Отчет по теме 3. Шабатов Андрей А-02-23
+
+## 1. Запустил оболочку IDLE и настроил рабочий каталог
+
+```py
+import os
+os.chdir("C:\\Users\\user\\Desktop\\python-labs\\TEMA3")
+```
+
+## 2. Преобразование простых типов объектов
+
+### 2.1. Преобразование в логический тип с помощью bool
+
+```py
+logiz1 = bool(56)
+         
+logiz2 = bool(0)
+         
+logiz3 = bool('Beta')
+         
+logiz4 = bool("")
+         
+logiz1; logiz2; logiz3; logiz4
+         
+True
+False
+True
+False
+```
+
+### 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#16>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+**Число, записанное в строку, является вещественным, поэтому функция int не смогла преобразовать его в десятичную систему счисления.**
+
+```py
+flt1=float(789)
+         
+flt1
+         
+789.0
+flt2=float(-6.78e2)
+         
+flt2
+         
+-678.0
+ flt3=float("Infinity")
+         
+SyntaxError: unexpected indent
+flt3=float("Infinity")
+         
+flt3
+         
+inf
+flt4=float("-inf")
+         
+flt4
+         
+-inf
+```
+
+### 2.3. Преобразование десятичных чисел в другие системы счисления
+
+```py
+dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+         
+dv1
+         
+'0b1111011'
+vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+         
+vos1
+         
+'0o173'
+shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+         
+shs1
+         
+'0x7b'
+int(dv1,2);int(vos1,8);int(shs1,16)
+         
+123
+123
+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']
+
+spis33 = list({"A":1,"B":2,"C":9}.values())
+         
+spis33
+         
+[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')
+```
+
+### 3.4. Удаление объектов
+
+```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', 'spis33', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+
+**Самостоятельно изучил функции, используемые в этом пункте**
+
+```py
+indi34 = 'ShabatovAA'
+         
+indi34 = list(indi34)
+indi34
+         
+['S', 'h', 'a', 'b', 'a', 't', 'o', 'v', 'A', 'A']
+indi34 = tuple(indi34)
+         
+indi34
+         
+('S', 'h', 'a', 'b', 'a', 't', 'o', 'v', 'A', 'A')
+indi34 = str(indi34)
+         
+indi34
+         
+"('S', 'h', 'a', 'b', 'a', 't', 'o', 'v', 'A', 'A')"
+
+```
+
+## 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!
+         
+type(a)
+         
+<class 'float'>
+a
+         
+3.9555555555555557
+```
+
+### 4.4. Деление с округлением вниз
+
+```py
+b=178//45   #Деление двух целых чисел
+         
+b
+         
+3
+c=-24.6//12.1  #Деление двух вещественных чисел
+         
+c
+         
+-3.0
+
+ind44 = -11//3
+ind44
+         
+-4
+100//33.3
+         
+3.0
+```
+
+### 4.5. Получение остатка от деления
+
+```py
+148%33   #Остаток от деления двух целых чисел
+         
+16
+12.6%3.8  #Остаток от деления двух вещественных чисел
+         
+1.2000000000000002
+15.6%3.1
+         
+0.0999999999999992
+16%3.1
+         
+0.49999999999999956
+```
+
+### 4.6. Возведение в степень
+
+```py
+14**3  #Целое число возводится в целую степень
+         
+2744
+e=2.7**3.6  #Вещественное число возводится в вещественную степень
+         
+e
+         
+35.719843790663525
+
+3.3**3
+         
+35.937
+11.1**0
+         
+1.0
+4**2
+         
+16
+
+compl = 3- 4j
+         
+compl**2
+         
+(-7-24j)
+print(compl+1)
+         
+(4-4j)
+print(compl//2)
+         
+Traceback (most recent call last):
+  File "<pyshell#114>", line 1, in <module>
+    print(compl//2)
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+print(compl%2)
+         
+Traceback (most recent call last):
+  File "<pyshell#115>", line 1, in <module>
+    print(compl%2)
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+print(compl-(1-4j))
+         
+(2+0j)
+print(compl/2)
+         
+(1.5-2j)
+print(compl*2)
+         
+(6-8j)
+```
+
+## 5. Изучил операции с двоичными представлениями целых чисел
+
+### 5.1. Двоичная инверсия
+
+```py
+dv1 = 9
+         
+dv2 = ~dv1
+         
+dv1
+         
+9
+```
+
+### 5.2. Двоичное И
+
+```py
+7&9
+         
+1
+7&8
+         
+0
+```
+
+### 5.3. Двоичное ИЛИ
+
+```py
+7|9     # 111 или 1001 = 1111
+         
+15
+7|8     # 111 или 1000 = 1111
+         
+15
+14|5   # 1110 или 0101 = 1111
+         
+15
+```
+
+### 5.4. Двоичное исключающее ИЛИ
+
+```py
+14^5  # 1110 исключающее или 0101 = 1011
+         
+11
+```
+
+### 5.5. Сдвиг двоичного представления на заданное число разрядов влево или вправо с дополнением нулями
+
+```py
+h=14   #Двоичное представление = 1110
+         
+g=h<<2  # Новое двоичное представление = 111000
+         
+g
+         
+56
+g1=h>>1  # Новое двоичное представление = 0111
+         
+g1
+         
+7
+g2=h>>2  # Новое двоичное представление = 0011
+         
+g2
+         
+3
+```
+
+**Самостоятельно придумал два двоичных числа и выполнил операции, рассматриваемые в этом пункте**
+
+```py
+i5 = 77
+         
+bin(77)
+         
+'0b1001101'
+i51 = ~i5
+i51
+         
+-78
+bin(i5)
+         
+'0b1001101'
+bin(81)
+         
+'0b1010001'
+i5&81
+         
+65
+77|81
+         
+93
+77^81
+         
+28
+bin(i5)
+         
+'0b1001101'
+print(bin(i5<<2))
+         
+0b100110100
+print(bin(i5>>3))
+         
+0b1001
+```
+
+## 6. Изучил операции при работе с последовательностями(списки, кортежи, строки)
+
+### 6.1. Объединение последовательностей - конкатенация
+
+```py
+'Система '+'регулирования'  #Соединение двух строк символов
+         
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+         
+['abc', 'de', 'fg', 'hi', 'jkl']
+[1,2,3]+[4,5]
+         
+[1, 2, 3, 4, 5]
+('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+         
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+### 6.2. Повторение
+
+```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. Проверка наличия заданного элемента в последовательности
+
+```py
+stroka='Система автоматического управления'
+         
+'автомат' in stroka  #Наличие подстроки в строке
+         
+True
+'ку' in ['ку','-']*3  #Наличие контекста в списке
+         
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+         
+False
+```
+
+### 6.4. Подстановка значений в строку с помощью оператора %
+
+```py
+stroka='Температура = %g %s  %g'
+         
+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   # Значение zz увеличивается на 5
+         
+zz
+         
+-7
+zz-=3  # Значение уменьшается на 3
+         
+zz
+         
+-10
+stroka='Система'
+         
+stroka+=' регулирования'
+
+stroka
+         
+'Система регулирования'
+
+```
+
+### 7.3. Умножение текущего значения переменной на заданную величину
+
+```py
+zz/=2
+         
+zz
+         
+-5.0
+zz*=5
+         
+zz
+         
+-25.0
+```
+
+### 7.4. Операции с округлением, остатком от деления и степенью.
+
+```py
+pim = 11
+         
+pim%=2
+         
+pim
+         
+1
+pim = 241
+         
+pim//=121
+         
+pim
+         
+1
+pim = 2
+         
+pim**=5
+         
+pim
+         
+32
+```
+
+### 7.5. Множественное присваивание
+
+```py
+w=v=10  # Переменным присваивается одно и то же значение
+         
+w;v
+         
+10
+10
+n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+         
+n1;n2;n3
+         
+11
+-3
+'all'
+x1,x2,x3 = [1,2,3]
+         
+x1;x2;x3
+         
+1
+2
+3
+x4,x5,x6 = 'фацйпцйдидпцйжд'
+         
+Traceback (most recent call last):
+  File "<pyshell#225>", line 1, in <module>
+    x4,x5,x6 = 'фацйпцйдидпцйжд'
+ValueError: too many values to unpack (expected 3)
+x1,x2,x3 = {23,31,41}
+         
+x1,x2,x3
+         
+(41, 31, 23)
+type(x1)
+         
+<class 'int'>
+x4,x5,x6 = {'1':2,'3':4,'5':6}
+         
+x4,x5,x6
+         
+('1', '3', '5')
+```
+
+## 8. Изучил логические операции
+
+### 8.1. Операции сравнения
+
+```py
+w;v
+         
+10
+10
+w == v
+         
+True
+w != v
+         
+False
+w > v
+         
+False
+w < v
+         
+False
+w >= v
+         
+True
+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. Создание больших логических выражений с помощью И, ИЛИ и НЕ
+
+```py
+a=17
+         
+b=-6
+         
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+         
+True
+(b < a) and ('UII' in dct1['Depart'])
+         
+True
+(a <= b) or ( 'Vologda' in dic1)
+         
+True
+not ( a <= b) or ('Vologda' in dct1)
+         
+True
+not ( a <= b) and ('Vologda' in dct1)
+         
+False
+```
+
+### 8.4. Проверка ссылок переменных на один и тот же объект
+
+```py
+w1=['A','B']
+         
+v1=['A','B']
+         
+w1 is v1
+         
+False
+```
+** Это ложно, потому что для списки создаются в разных ячейках памяти**
+
+
+## 9. Изучил операции с объектами, выполняемые с помощью методов
+
+```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']
+```
+
+### 9.1. Методы для работы со строками
+
+```py
+stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+    
+5
+stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+    
+4
+stroka.replace(' у',' автоматического у')
+    
+'Микропроцессорная система автоматического управления'
+spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+    
+spis22
+    
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()   #Возвращает строку со всеми заглавными буквами
+    
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+    
+stroka3
+    
+'Микропроцессорная система управления'
+stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+    
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+    
+('Микропроцессорная си', 'с', 'тема управления')
+strk1='Момент времени {}, значение = {}'
+    
+strk1.format(1,89.7)
+    
+'Момент времени 1, значение = 89.7'
+strk2='Момент времени {1}, значение = {0}:{2}'
+    
+strk2.format(36.7,2,'норма!')
+    
+'Момент времени 2, значение = 36.7:норма!'
+strk3='Момент времени {num}, значение = {znch}'
+    
+strk3.format(znch=89.7,num=2)
+    
+'Момент времени 2, значение = 89.7'
+```
+
+### 9.2. Методы для работы со списками
+
+```py
+spsk = [1,2,3,4,5,6,7]
+dir(spsk)
+    
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+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
+krt = (1,2,3,4,5)
+dir(krt)
+    
+['__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']
+krt.count(5)
+    
+1
+```
+
+### 9.4. Самостоятельно изучил методы словарей 
+
+```py
+dirr={"A":3, "B":4}
+    
+dir(dirr)
+    
+['__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']
+dirr.keys()
+    
+dict_keys(['A', 'B'])
+```
+
+## 10. Завершил работу в IDLE

TEMA3/task.md

@@ -0,0 +1,90 @@
+# Общее контрольное задание по теме 3
+
+Шабатов Андрей А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+•	Преобразовать восьмеричное значение 45 в целое число.
+
+•	Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+•	Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+•	Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+•	Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+•	Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+
+•	Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+
+## Решение
+
+```py
+a1 = int('45',8)
+    
+a1
+    
+37
+D = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+    
+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']
+spis1 = list(D)
+    
+spis1
+    
+['усиление', 'запаздывание', 'постоянная времени']
+spis2 = list(D.values())
+    
+spis2
+    
+[23, 12, 78]
+kor1 = tuple(spis1)+tuple(spis2)
+    
+kor1
+    
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+((1768//24.8)%3)**2.4
+    
+5.278031643091577
+((~(13&27))^14)<<2
+    
+-32
+spis3 = ['колебат','колебат','колебат','колебат']
+'аткол' in spis3[1]+spis3[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])
+st = 'Создать объект - символьную строку с текстом данного предложения.'
+spis4 = st.split(" ")
+    
+spis4
+    
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+'-' in spis4
+    
+True
+spis4[spis4.index('-')] = ','
+    
+spis4
+    
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+spis4.remove('данного')
+    
+spis4
+    
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```
+

TEMA4/idz.md

@@ -0,0 +1,30 @@
+# Идз
+
+# Шабатов Андрей, А-02-23
+
+# Индивидуальное контрольное задание
+Напишите инструкцию запоминания в переменной текущего регионального времени.
+Напишите инструкцию превращения этого времени в символьную строку.
+Отобразите результат на экране. Создайте множество с 5 элементами – случайными целыми числами из диапазона значений от -23 до 57.
+Подсчитайте корень квадратный из суммы элементов этого множества и отобразите на экране в виде: «результат = ХХХ» с округлением числа до одного знака после точки.
+
+```py
+time1 = time.localtime()
+                          
+time1
+                          
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=14, tm_min=18, tm_sec=4, tm_wday=0, tm_yday=286, tm_isdst=0)
+time2 = time.strftime("%Y-%m-%d  %H-%M-%S", time1)
+                          
+time2
+                          
+'2025-10-13  14-18-04'
+import random
+s = (random.randint(-23,57),random.randint(-23,57),random.randint(-23,57),random.randint(-23,57),random.randint(-23,57))
+s1 = set(s)
+s1
+{8, 11, -15, 51, 22}
+import math
+print('Результат=' , round(math.sqrt(sum(s1)),1))
+Результат= 8.8
+```

TEMA4/report.md

@@ -0,0 +1,420 @@
+# Отчет по теме 4
+
+Шабатов Андрей , А-02-23
+
+## 1 Запуск интерактивной оболочки IDLE 
+
+Была запущена интерактивная оболочка IDLE.
+
+## 2 Изучение стандартных встроенных функций 
+
+## 2.1 Изучение функции округления
+
+Была применена функция round с одним и двумя аргументами и изучены различия между указанием одного и двух аргументов.
+
+```py
+>>>round(123.456,1)
+123.5
+>>>round(123.456,0)
+123.0
+>>>type(round(123.456,1))
+<class 'float'>
+>>>type(round(123.456,0)) #В результате получаются числа класса float, так как указано сколько цифр после запятой нужно оставить. Два вышеупомянутых варианта отличаются именно количесивом цифр, оставленных после запятой при округлении.
+<class 'float'>
+>>>round(123.456)
+123
+>>>type(round(123.456)) #В данном случае получается число типа int, так как не указано количество цифр после запятой, и по умолчанию число округляется до целого.
+<class 'int'>
+```
+
+## 2.2 Изучение функции создания последовательности
+
+Была применена функция range с тремя и с одним аргументо и изучена разница  между этими способами применения функции.
+
+```py
+>>>gg=range(76,123,9)
+>>>gg
+range(76, 123, 9)
+>>>list(gg)
+[76, 85, 94, 103, 112, 121]
+>>>range(23) #При указывание одного аргумента строится последовательность от 0 до указанного числа не включительно, с шагом 1.
+range(0, 23)
+>>>list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+## 2.3 Изучение функции zip
+
+Была применена функция zip и произведена попытка обращения к элементу созданной последовательности по индексу.
+
+```py
+>>>qq=["Shabatov", "Efremov", "Zelenkina", "Pohil"]
+>>>ff=zip(gg,qq)
+>>>tuple(ff) #В итоге получится последовательность из 4 элементов, так как в qq 4 элемента, а в gg 6. Длина равна длине самого короткого списка.
+((76, 'Shabatov'), (85, 'Efremov'), (94, 'Zelenkina'), (103, 'Pohil'))
+>>>ff[1] #Исходя из текста ошибки, можно сказать, что zip обьекты не поддерживают доступ по индексу.
+Traceback (most recent call last):
+  File "<pyshell#15>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+
+## 2.4 Изучение функции eval 
+
+Была применена функция eval.
+
+```py
+>>>fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=6
+>>>dan
+-126.0
+```
+
+## 2.5 Изучение функции exec
+
+Была применена функция exec.
+
+```py
+>>>exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>>gg
+221.456
+```
+
+## 2.6 Изучение ряда полезных функций (abs, pow, max, min, sum, divmod, len, map)
+
+Был изучен и применен ряд полезных функций:
+
+abs - выдает значение по модулю;
+len - выдает длину обьекта;
+max - выдает максимальное число из списка введенных в аргумент; 
+min - выдает минимальное число из списка введенных в аргумент;
+pow - при двух аргументах: возводит первый в степень второго, при наличие третьего аргумента делит получившийся результат на третий аргумент и показывает остаток;
+sum - суммирует числа;
+divmod  - возвращает кортеж (a // b, a % b), где а и b соответственно первый и второй аргумент;
+map - применяет функцию из первого аргумента к каждому элементу итерируемого обьекта, который указан во втором аргументе.
+
+```py
+>>>abs(-5)
+5
+>>>len("hi")
+2
+>>>max(3, 4)
+4
+>>>min(3, 4)
+3
+>>>pow(3, 2)
+9
+>>>pow(3, 2, 3)
+0
+>>>sum([2, 3])
+5
+>>>divmod(7, 2)
+(3, 1)
+>>>list(map(lambda x: x*2, [1, 2, 3, 4]))
+[2, 4, 6, 8]
+```
+
+## 3 Изучение функций из модуля math для работы с математическими выражениями и операциями.
+
+Был импортирован и изучен модуль math. Были изучены и применены некоторые функции из модуля math.
+
+sin - считает и выдает синус аргумента в радианах;
+acos - считает и выдает арккосинус аргумента в радианах;
+degrees - переводит число в радианах в градусы;
+radians - переводит число в градусах в радианы;
+exp - выдает значение числа e возведенного в степень, которая указана в аргументе;
+log - считает натуральный логарифм числа;
+log10 - считает делятичный логарифм числа;
+sqrt - считает корень из числа в аргументе;
+ceil - округляет число вверх;
+floor - округляет число вниз;
+pi - данная функция является представлением числа пи в питоне.
+
+```py
+>>>import math
+>>>dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>>help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+>>>math.factorial(5)
+120
+>>>math.sin(180)
+-0.8011526357338304
+>>>math.acos(0.5)
+1.0471975511965979
+>>>help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>>math.degrees(0.5)
+28.64788975654116
+>>>math.radians(28)
+0.4886921905584123
+>>>math.exp(1)
+2.718281828459045
+>>>math.log(1)
+0.0
+>>>math.log10(1)
+0.0
+>>>math.sqrt(9)
+3.0
+>>>help(math.ceil)
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+
+    This is the smallest integer >= x.
+
+>>>math.ceil(4.7)
+5
+>>>math.floor(4.7)
+4
+>>>math.pi
+3.141592653589793
+>>>math.sin(2*math.pi/7+math.exp(0.23))
+0.8334902641414562
+```
+
+## 4 Изучение модуля cmath для работы с комплексными числами
+
+Был импортирован и изучен модуль cmath и применены функции для извлечения корня и расчета фазы комплексного числа.
+
+```py
+>>>import cmath
+>>>dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>>cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+>>>cmath.phase(1-0.5j)
+-0.4636476090008061
+```
+
+## 5 Изучения стандартного модуля randon для работы с псевдослучайными числами
+
+Были самостоятельно изучены и применены методы модуля random:
+
+random - равномерно распределенное случайное число;  
+uniform- равномерно распределенное случайное число в диапазоне, заданном двумя аргументами;  
+randint - случайные целые числа в диапазоне от значения первого аргумента до значения второго;
+gauss - нормально распределенное случайное число с средним равным певому аргументу и стандартным отклонением равным второму аргументу; 
+choice - случайный выбор из совокупности указанной в аргументе; 
+shuffle - случайная перестановка элементов списка в аргументе; 
+sample - случайный выбор подмножества элементов из списка в первом аргументе (количество элементов равно числу, указанному во втором аргументе); 
+betavariate - случайное число с бета-распределением, где альфа равна первому аргументу, а бета равна второму аргументу;
+gammavariate - случайное число с гамма-распределением, где альфа равна первому аргументу, а бета равна второму аргументу.
+
+Также был самостоятельно создан список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+
+```py
+>>>import random
+>>>dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>>help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+>>>random.seed()
+>>>r = random.random()
+>>>r
+0.915829800247012
+>>>u = random.uniform(1, 10)
+>>>u
+6.398971726523061
+>>>rnd = random.randint(1, 10)
+>>>rnd
+3
+>>>g = random.gauss(0, 1)
+>>>g
+1.6312864971445826
+>>>l = ["a", "b", "c"]
+>>>ch = random.choice(l)
+>>>ch
+'b'
+>>>random.shuffle(l)
+>>>l
+['b', 'a', 'c']
+>>>s = random.sample(l, 2)
+>>>s
+['c', 'b']
+>>>b = random.betavariate(2, 5)
+>>>b
+0.20276652629326136
+>>>g = random.gammavariate(2, 2)
+>>>g
+4.361266204290336
+>>>random_list = [random.uniform(1, 10), random.gauss(5, 2), random.betavariate(2, 5),  random.gammavariate(2, 2)]
+>>>random_list
+[1.8429009082320071, 5.582736307655225, 0.21284691290111155, 2.9271296316078654]
+```
+
+## 6 Изучение модуля time для работы со временем и календарями
+
+Были изучены и применены методы из модуля time:
+
+time - возвращает время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г;
+gmtime - возвращает объект класса struct_time, содержащий полную информацию о текущем времени (UTC): год (tm_year), месяц (tm_mon), день tm_mday)...;
+localtime - для получения «местного» времени (которое стоит на компьютере);
+asctime - преобразовывает представление времени из кортежа в строку (просто отображает время в формате строки);
+ctime - преобразовывает время в секундах, прошедшего с начала эпохи, в строку;
+sleep - прерывает работу программы на заданное время в секундах; 
+mktime - преобразовает время из типа кортежа или struct_time в число секунд с начала эпохи.
+
+```py
+>>>import time
+>>>dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>>c1=time.time()
+>>>c1
+1757585123.0268378
+>>>c1=time.time() #Для проверки заново применили функцию спустя 14 секунд.
+>>>c1
+1757585137.4425445
+>>>c2=time.time()-c1
+>>>c2
+272.143741607666
+>>>dat=time.gmtime()
+>>>dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=10, tm_min=13, tm_sec=29, tm_wday=3, tm_yday=254, tm_isdst=0)
+>>>dat.tm_mon
+9
+>>>tim=time.localtime()
+>>>tim
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=12, tm_min=15, tm_sec=7, tm_wday=3, tm_yday=254, tm_isdst=0)
+>>>time.asctime()
+'Thu Sep 11 12:16:36 2025'
+>>>time.ctime()
+'Thu Sep 11 12:16:57 2025'
+>>>time.sleep(2) #Две секунды в IDLE не появлялось приглашение для ввода команды.
+>>>time.mktime(tim)
+1757585707.0
+>>>time.localtime(c1)
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=12, tm_min=5, tm_sec=37, tm_wday=3, tm_yday=254, tm_isdst=0)
+```
+
+## 7 Изучение графических функций
+
+Был создан линейный график, на котором изображена зависимость сигналов от времени.
+
+```py
+>>>import pylab
+>>>x=list(range(-3,55,4))
+>>>x
+[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
+>>>t=list(range(15))
+>>>t
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+>>>pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000022B3EEDAD50>]
+>>>pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>>pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>>pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>>pylab.show() #Отображение графика на экране
+```
+
+![](Ris1.png)
+
+Далее были созданы два линейных графика на одном поле. (По оси y - значения из списка, по оси х - порядковый номер значений).
+
+```py
+>>>X1=[12,6,8,10,7]
+>>>X2=[5,7,9,11,13]
+>>>pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000022B3EFEB890>]
+>>>pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000022B3EFEB9D0>]
+>>>pylab.show()
+```
+
+![](Ris2.png)
+
+Также была создана круговая диаграмма.
+
+```py
+>>>region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>>naselen=[65,12,23,17]  # Значения для диаграммы
+>>>pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000022B3EEAE3C0>, <matplotlib.patches.Wedge object at 0x0000022B42875590>, <matplotlib.patches.Wedge object at 0x0000022B42875950>, <matplotlib.patches.Wedge object at 0x0000022B42875BD0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>>pylab.show()  #Отображение диаграммы
+```
+
+![](Ris3.png)
+
+Самостоятельно была создана гистограмма (по оси у - частота повторения значений, по оси х сами значения)
+
+```py
+>>>data = [1, 2, 3, 3, 2, 3, 3, 3, 2]
+>>>pylab.hist(data, bins=3)
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>>pylab.title("Гистограмма")
+Text(0.5, 1.0, 'Гистограмма')
+>>>pylab.show()
+```
+
+![](Ris4.png)
+
+Самостоятельно была создана столбиковая диаграмма, где по оси х - категории, а по оси у - значения, относящиеся к каждой категории.
+
+```py
+>>>c = ['A', 'B', 'C', 'D']
+>>>v = [25, 40, 30, 50]
+>>>pylab.bar(c, v)
+<BarContainer object of 4 artists>
+>>>pylab.title("Столбиковая диаграмма")
+Text(0.5, 1.0, 'Столбиковая диаграмма')
+>>>pylab.show()
+```
+
+![](Ris5.png)
+
+## 8 Изучение модуля statistics для работы в сфере статистики
+
+Самостоятельно был импортирован и изучен модуль statistics. Из него были использованы функции подсчета среднего значения, медианы и моды для выборки в списке.
+
+```py
+>>>import statistics
+>>>dir(statistics)
+['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_kernel_invcdfs', '_mean_stdev', '_newton_raphson', '_normal_dist_inv_cdf', '_quartic_invcdf', '_quartic_invcdf_estimate', '_random', '_rank', '_sqrt_bit_width', '_sqrtprod', '_ss', '_sum', '_triweight_invcdf', '_triweight_invcdf_estimate', 'acos', 'asin', 'atan', 'bisect_left', 'bisect_right', 'correlation', 'cos', 'cosh', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'isfinite', 'isinf', 'itemgetter', 'kde', 'kde_random', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pi', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sin', 'sqrt', 'stdev', 'sumprod', 'sys', 'tan', 'tau', 'variance']
+>>>data = [1, 2, 2, 3, 4, 5, 5, 5, 6]
+>>>mean = statistics.mean(data)
+>>>mean
+3.6666666666666665
+>>>median = statistics.median(data)
+>>>median
+4
+>>>mode = statistics.mode(data)
+>>>mode
+5
+```
+
+## 9 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.
+ 
+
+

TEMA4/task.md

@@ -0,0 +1,48 @@
+# Общее контрольное задание по теме 4
+
+Шабатов Андрей, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+    • Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+ 
+    • Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+    • Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+    • Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+    • Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+    • Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+>>>divmod((round(cmath.phase(0.2+0.8j), 2))*20, 3)
+(8.0, 2.6000000000000014)
+>>>divmod(math.floor((round(cmath.phase(0.2+0.8j), 2))*20), 3) #Для получения остатка в целом виде и делении целых чисел, можно использовать такое выражение.
+(8, 2)
+>>>v = time.localtime()
+>>>v
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=11, tm_hour=14, tm_min=3, tm_sec=26, tm_wday=3, tm_yday=254, tm_isdst=0)
+>>>st = v.tm_hour, v.tm_min
+>>>st = str(v.tm_hour)+" hour "+str(v.tm_min)+" min "
+>>>st
+'14 hour 3 min '
+>>>ned = ["пн", "вт", "ср", "чт", "пт", "сб", "вскр"]
+>>>random.sample(ned, 3)
+['пн', 'вскр', 'вт']
+>>>random.choice(list(range(14, 33, 3)))
+20
+>>>N = round(random.gauss(15, 4))
+>>>N
+15
+>>>import string #Импортировали модуль в котором есть латинский алфавит, чтобы из него выбрать буквы. Без использования этого модуля создавать список с алфавитом нужно было бы вручную.
+>>>random.sample(string.ascii_letters, N)
+['M', 'J', 'X', 'H', 'R', 'D', 'V', 'U', 'c', 'g', 'l', 'k', 'm', 't', 'w']
+>>>time.localtime().tm_min - v.tm_min
+24
+```