ТЕМА4/test.md

TEMA1/Pr0.py

@@ -0,0 +1,6 @@
+# Программа по Теме 1 Девятова МЕ
+
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('C:\\Users\\u207-05\\Desktop\\ПОАС\\python-labs\\TEMA1\\')

TEMA1/report.md

@@ -0,0 +1,104 @@
+# Отчет по теме 1
+
+Девятова Мария, А-03-23
+
+## 1 Знакомство с интерпретатором и интерактивной оболочкой IDLE 
+
+## 1.1 Настройка текущего каталога и окна IDLE
+
+```
+import os
+os.chdir('C:\\Users\\u207-05\\Desktop\\ПОАС\\python-labs\\TEMA1\\')
+```
+
+![Скриншот настройки шрифта](figure01.PNG)
+![Скриншот настройки окна](figure02.PNG)
+![Скриншот настройки подсветки комментариев](figure03.PNG)
+
+## 1.2 Запуск программы в командном окне
+
+Был создан файл Pr0.py, в командном окне IDLE был запущен на выполнение + файл prb1.py, данный изначально.
+Результаты выполнения:
+
+```
+import Pr0
+Hello
+Your name=Maria
+import prb1
+Как Вас зовут? Maria
+Привет, Maria
+```
+
+## 1.3 Содержимое файла в папке pycache
+
+После запуска Pr0.py в рабочем каталоге появилась папка pycache, в которой расположен файл Pr0.cpython-311.pyc
+Данный файл содержит байт-код для исходного Pr0.py, который интерпретируется виртуальной машиной Python.
+Фрагмент файла, открытый в текстовом редакторе, приведен ниже:
+
+![Скриншот с частью файла Pr0.cpython-311.pyc](figure04.PNG)
+
+## 1.4 Изучение раздела help
+
+Было выполнено обращение к помощи по функции print(), затем по функциям print(), input()
+
+```
+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.
+```
+
+## 1.5 Выполнение пункта 15
+
+```
+======= RESTART: C:\Users\u207-05\Desktop\ПОАС\python-labs\TEMA1\prb1.py =======
+Как Вас зовут? Maria
+Привет, Maria
+```
+```
+import tdemo_chaos
+```
+
+![Результат выполнения tdemo_chaos](figure05.PNG)
+
+Через раздел помощи Help был запущен пример clock, результат ниже:
+
+![Часы](figure06.PNG)

TEMA2/report.md

@@ -0,0 +1,819 @@
+# Отчет по теме 2
+
+Девятова Мария, А-03-23
+
+## 1 Запуск оболочки IDLE, подготовка к работе
+
+Был запущен IDLE Python 3.11, установлен текущий каталог:
+
+```
+import os
+os.chdir('C:\\Users\\ASUS X507UF\\Desktop\\поас\\python-labs\\TEMA2\\')
+```
+
+## 2 Изучение простых объектов
+
+Были созданы две переменные со значениями 16 и 3
+
+```
+f1=16; f2=3
+```
+
+Чтобы узнать значения нескольких переменных, достаточно перечислить имена переменных через запятую или точку с запятой.
+
+```
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+```
+
+Использование функции dir() без аргументов позволяет узнать, какие объекты в данный момент cуществуют в среде Python.
+
+```
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__',
+'__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+ 
+Если эту же функцию использовать с именем объекта в качестве аргумента (например, f1), то будет выведен список атрибутов этого объекта.
+
+```
+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', 'numerator', 'real', 'to_bytes']
+```
+
+Классовую принадлежность объекта можно определить с помощью функции type(). Объект f2 принадлежит к целочисленному типу данных.
+
+```
+type(f2)
+<class 'int'>
+```
+
+Было произведено удаление ранее созданных объектов f1 и f2, а также проверено с функцией dir(). 
+Объекты действительно были удалены из оперативной памяти.
+
+```
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', 
+'__name__', '__package__', '__spec__', 'os']
+``` 
+
+## 3 Правила именования объектов
+
+При именовании объектов в Python необходимо руководствоваться следующими правилами:
+1) имена должны состоять из латинских букв, цифр и символов подчеркивания;
+2) имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
+3) заглавные и строчные буквы в именах различаются (чувствительность к регистру);
+4) имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python.
+Были выполнены следующие операции:
+
+```
+gg1=1.6
+gg1
+1.6
+hh1='Строка'
+hh1
+'Строка'
+73sr=3
+SyntaxError: invalid decimal literal
+and=7
+SyntaxError: invalid syntax
+```
+
+Ошибки были выведены при создании переменной с цифрой в начале имени и с именем, совпадающим с ключевым словом.
+Остальные переменные получили введенное значение.
+
+## 4 Вывод списка ключевых слов
+
+Был выведен список ключевых слов.
+
+```
+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']
+```
+
+Данный список был сохранен в переменной с именем kw.
+
+```
+kw = keyword.kwlist
+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']
+```
+
+## 5 Список встроенных идентификаторов и изучение некоторых функций
+
+Был выведен список встроенных идентификаторов.
+
+```
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 
+'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 
+'BrokenPipeError', 'BufferError', 'BytesWarning', 
+'ChildProcessError', 'ConnectionAbortedError', 
+'ConnectionError', 'ConnectionRefusedError', 
+'ConnectionResetError', 'DeprecationWarning', 
+'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 
+'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 
+'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 
+'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 
+'IndentationError', 'IndexError', 'InterruptedError', 
+'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 
+'LookupError', 'MemoryError', 'ModuleNotFoundError', 
+'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 
+'NotImplementedError', 'OSError', 'OverflowError', 
+'PendingDeprecationWarning', 'PermissionError', 
+'ProcessLookupError', 'RecursionError', 'ReferenceError', 
+'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 
+'StopAsyncIteration', 'StopIteration', 'SyntaxError', 
+'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 
+'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 
+'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 
+'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 
+'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', 
+'_', '__build_class__', '__debug__', '__doc__', '__import__', 
+'__loader__', '__name__', '__package__', '__spec__', 'abs', 
+'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 
+'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 
+'classmethod', 'compile', 'complex', 'copyright', 'credits', 
+'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 
+'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 
+'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 
+'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 
+'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 
+'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 
+'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 
+'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 
+'super', 'tuple', 'type', 'vars', 'zip']
+```
+
+Можно отметить, что в нем присутствуют уже использованные функции type() и dir().
+Было изучено назначение функций: abs, len, max, min, pow, round, sorted, sum, zip.
+abs - модуль объекта.
+
+```
+abs(-20)
+20
+```
+
+len - длина объекта.
+
+```
+len([1, 3, 5, 7, 9, 11])
+6
+```
+
+max/min - максимум/минимум объекта.
+
+```
+max(0, -50, 23)
+23
+min(0, -50, 23)
+-50
+```
+
+pow - возведение в степень.
+
+```
+pow(3, 2)
+9
+```
+
+round - округление (в кач-ве второго аргумента - кол-во знаков после запятой, по умолчанию none, т.е. округление до целого).
+
+```
+round(5.5276)
+6
+round(5.5276, 3)
+5.528
+```
+
+sorted - сортировка элементов в объекте (по умолчанию - по возрастанию, при reverse=True - по убыванию).
+
+```
+sorted([2, -7, 4, 0])
+[-7, 0, 2, 4]
+sorted([2, -7, 4, 0], reverse=True)
+[4, 2, 0, -7]
+```
+
+sum - сумма элементов (в кач-ве второго аргумента - начальное значение, по умолчанию 0).
+
+```
+sum([1, 4, 7])
+12
+sum([1, 4, 7], 5)
+17
+```
+
+zip - поэлементное объединение объектов в набор кортежей, при разной длине объектов функция создает кортежи до длины самого короткого объекта.
+
+```
+list(zip('efghi', [2, 6, 3], [7, 9, 0, 0]))
+[('e', 2, 7), ('f', 6, 9), ('g', 3, 0)]
+```
+
+## 6 Проверка на чувствительность к регистру
+
+Была создана переменная Gg1 с присвоенным значением, отличным от присвоенного ранее объекту gg1. Проверка показала, что gg1 и Gg1 - разные объекты, т.е. Python чувствителен к регистру.
+
+```
+Gg1=45
+gg1; Gg1
+1.6
+45
+```
+
+## 7 Простые базовые типы объектов
+
+### 7.1 Логический тип
+
+```
+bb1=True; bb2=False
+bb1; bb2
+True
+False
+type(bb1)
+<class 'bool'>
+```
+
+### 7.2 Другие простые типы
+
+ii1 - целое число, десятичное
+
+```
+ii1=-1234567890
+type(ii1)
+<class 'int'>
+```
+
+ff1 - экспоненциальная форма записи вещественного числа
+
+```
+ff1=-8.9876e-12
+type(ff1)
+<class 'float'>
+```
+
+dv1 - двоичное число
+
+```
+dv1=0b1101010
+type(dv1)
+<class 'int'>
+```
+
+vsm1 - восьмеричное число
+
+```
+vsm1=0o52765
+type(vsm1)
+<class 'int'>
+```
+
+shest1 - шестнадцатеричное число
+
+```
+shest1=0x7109af6
+type(shest1)
+<class 'int'>
+```
+
+cc1 и cc2 - комплексные числа
+
+```
+cc1=2-3j
+type(cc1)
+<class 'complex'>
+a=3.67; b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j)
+```
+
+### 7.3 Строка символов
+
+Была двумя способами создана строка - с использованием одинарных и двойных кавычек. Оба способа дают идентичный результат (но важно, чтобы открывающие и закрывающие кавычки были одинаковыми).
+
+```
+ss1='Это - строка символов'
+ss1
+'Это - строка символов'
+ss1="Это - строка символов"
+ss1
+'Это - строка символов'
+```
+
+Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие.
+
+```
+ss1a="Это - \" строка символов \", \n \t выводимая на 
+двух строках"
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+```
+ss1b= 'Меня зовут: \n Девятова М.Е.'
+print(ss1b)
+Меня зовут: 
+ Девятова М.Е.
+```
+
+Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек. При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.
+
+```
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. Нумерация начинается с 0. При знаке минус отсчет идет от конца строки.
+
+```
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+```
+
+Операция создания "среза".
+С 6-го индекса по 8-й, 9-й не включая.
+C 13-го индекса и до конца. 
+С начала и до 12-го индекса включительно.
+C 5-го индекса и до 8-го с конца
+С 3-го по 16-й с шагом 2
+
+```
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+```
+
+При отрицательном значении шага. Если 17 заменить на -4, то результат будет тот же.
+
+```
+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
+'Это = строка символов'
+```
+
+С использованием ранее созданной строки ss1b были созданы объекты с разными срезами.
+
+```
+ss1b[1::3]
+'е в: во Е'
+ss1b[0]
+'М'
+ss1b[12]
+'\n'
+ss1b[5:10]
+'зовут'
+ss1b[14:-8]
+'Девят'
+ss1b[-8:14:-2]
+'ояе'
+```
+
+Были созданы объекты разных типов с отображением их типов.
+
+```
+obj1=9.87609
+type(obj1)
+<class 'float'>
+obj2=654
+type(obj2)
+<class 'int'>
+obj3=8+5j
+type(obj3)
+<class 'complex'>
+obj4='о'
+type(obj4)
+<class 'str'>
+obj7="""две
+строки"""
+type(obj7)
+<class 'str'>
+```
+
+## 8 Списки, кортежи, словари, множества
+
+### 8.1 Списки
+
+Список – это упорядоченная последовательность объектов произвольных типов, список является изменяемым объектом.
+Был создан список с 3 элементами разных типов.
+
+```
+spis1=[111,'Spisok',5-9j]
+spis1
+[111, 'Spisok', (5-9j)]
+type(spis1)
+<class 'list'>
+```
+
+Еще пример: список, содержащий последовательность отсчетов сигнала в виде "единичной ступеньки".
+
+```
+stup=[0,0,1,1,1,1,1,1,1]
+stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+type(stup)
+<class 'list'>
+```
+
+Список можно вводить на нескольких строках, для завершения ввода должна быть введена закрывающая квадратная скобка.
+
+```
+spis=[1,2,3,4,
+   5,6,7,
+   8,9,10]
+spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+При работе с элементами списка можно использовать индексы точно так же, как это производилось с элементами символьной строки.
+
+```
+spis1[-1]
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+```
+
+Список - изменяемый объект, поэтому его элементам можно присваивать новые значения.
+
+```
+spis1[1]='Список'
+spis1
+[111, 'Список', (5-9j)]
+```
+
+Функция len() отображает кол-во элементов в списке.
+
+```
+len(spis1)
+3
+```
+
+Был выведен список атрибутов списка и с помощью функции help() - описание одного из методов.
+
+```
+dir(spis1)
+['__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']
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+
+Добавить элемент в список можно двумя способами, но при конкатенации (второй способ) добавленный элемент не сохраняется в списке:
+
+```
+spis1.append('New item')
+spis1
+[111, 'Список', (5-9j), '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 Девятова М.Е.']
+```
+
+Из списка был удален элемент с индексом 1.
+
+```
+spis1.pop(1)
+'Список'
+spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Девятова М.Е.']
+```
+
+Также были изучены еще некоторые методы.
+insert вставляет элемент (второй аргумент функции) по номеру индекса (первый аргумент функции).
+
+```
+sss=[1, 3, 'Hello', 47+9j, 1, 666]
+sss
+[1, 3, 'Hello', (47+9j), 1, 666]
+sss.insert(2, ')')
+sss
+[1, 3, ')', 'Hello', (47+9j), 1, 666]
+```
+
+remove удаляет первый элемент со значением, указанным в кач-ве аргумента. В примере элементы с индексами 0 и 5 имеют значение 1, но функция удалила только элемент с индексом 0.
+
+```
+sss.remove(1)
+sss
+[3, ')', 'Hello', (47+9j), 1, 666]
+```
+
+extend принимает объект в кач-ве аргумента и добавляет его в конец списка. 
+В сравнении с append данная функция может распаковывать сложные типы как список и добавлять его поэлементно, в то время как append добавляет список как один объект.
+
+```
+sss.extend([1, 2, 3, 'X'])
+sss
+[3, ')', 'Hello', (47+9j), 1, 666, 1, 2, 3, 'X']
+sss.append([1, 2, 3, 'X'])
+sss
+[3, ')', 'Hello', (47+9j), 1, 666, 1, 2, 3, 'X', [1, 2, 3, 'X']]
+```
+
+sort - сортировка элементов, по умолчанию - по возрастанию.
+
+```
+sss1=[1, -5, 9, 0, -43]
+sss1.sort()
+sss1
+[-43, -5, 0, 1, 9]
+```
+
+reverse - обратный порядок элементов.
+
+```
+sss.reverse()
+sss
+[[1, 2, 3, 'X'], 'X', 3, 2, 1, 666, 1, (47+9j), 'Hello', ')', 3]
+```
+
+copy - создание копии списка.
+
+```
+s00=sss.copy()
+s00
+[[1, 2, 3, 'X'], 'X', 3, 2, 1, 666, 1, (47+9j), 'Hello', ')', 3]
+```
+
+count - счетчик элементов по значению.
+
+```
+sss.count(1)
+2
+sss.count(9)
+0
+```
+
+index - индекс первого элемента с заданным в аргументе значением.
+
+```
+sss.index(1)
+4
+```
+
+clear - полное очищение списка
+
+```
+sss.clear()
+sss
+[]
+```
+
+Списки могут быть вложенными.
+Пример обращения к элементу вложенного списка. При изменении элемента вложенного списка, сам spis1 изменяется, потому что при создании spis2 использовалась не копия spis1, а ссылка на него.
+
+```
+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[0][1]
+78
+spis1
+[111, 78, 'New item', 'Меня зовут: \n Девятова М.Е.']
+```
+
+Объект-список, элементами которого объекты разных типов: число, строка, логическое значение, список
+
+```
+myspis=[gg1, ss1, bb2, sss]
+myspis
+[1.6, 'Это = строка символов', False, []]
+type(myspis[0])
+<class 'float'>
+type(myspis[1])
+<class 'str'>
+type(myspis[2])
+<class 'bool'>
+type(myspis[3])
+<class 'list'>
+```
+
+### 8.2 Кортежи
+
+Объект-кортеж похож на список, но является неизменяемым, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки.
+Создание кортежа. Вместо изменения кортежа - его переопределение.
+
+```
+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 Девятова М.Е.')
+```
+
+Два метода кортежа, одинаковых со списком.
+
+```
+kort1.index(2)
+4
+kort1.count(222)
+1
+```
+
+Была произведена попытка заменить элемент кортежа, но результат - сообщение о невозможности изменения кортежа.
+
+```
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#241>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+
+Был создан объект-кортеж с элементами разных типов: число, строка, список, кортеж.
+
+```
+mykort=(a, ss1, spis1, kort2)
+mykort
+(3.67, 'Это = строка символов', [111, 78, 'New item', 'Меня зовут: \n Девятова М.Е.'], (222, 'Kortezh', 1, 2, 'Меня зовут: \n Девятова М.Е.'))
+type(mykort)
+<class 'tuple'>
+type(mykort[0])
+<class 'float'>
+type(mykort[1])
+<class 'str'>
+type(mykort[2])
+<class 'list'>
+type(mykort[3])
+<class 'tuple'>
+```
+
+### 8.3 Словари
+
+Словарь - неупорядоченная совокупность элементов. Содержанием словаря является совокупность пар: "ключ (key)":"значение (value)". 
+В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. 
+Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению.
+Был создан словарь. Обращение к элементам производилось не по индексам, а по ключам.
+Был добавлен элемент в словарь. Из-за неупорядоченности словарей элементы при выводе могут располагаться не в том порядке, что и при формировании словаря.
+
+```
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+dic1['Orel']
+56
+dic1['Pskov']=78
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+С использованием методов keys, values, создающие списки ключей и значений, и функции sorted можно сформировать списки упорядоченных ключей и значений словаря.
+
+```
+sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+```
+
+Элементы словаря могут быть любого типа. 
+Были рассмотрены разные способы создания словаря, а также обращение к элементу вложенного словаря.
+При создании словаря с использованием zip необходимо помнить, что при разных длинах объектов функция объединяет элементы до длины самого короткого объекта (пример: dic555)
+
+```
+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)])
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Девятова М.Е.'}
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Девятова М.Е.'}
+dic555=dict(zip(('1', '2', '3', '4', '5', '6', '7'), ['one', 'two', 'three', 'four', 'five']))
+dic555
+{'1': 'one', '2': 'two', '3': 'three', '4': 'four', '5': 'five'}
+AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
+AVTI['Курс III'][5]
+15
+```
+
+### 8.4 Множества
+
+Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).
+Было создано множество и продемонстрировано, что элементы в нем не повторяются, подсчитано кол-во элементов в нем, проверено наличие элемента, затем добавлен новый элемент и удален другой.
+
+```
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'микропроцессор', 'двигатель', 'датчик', 'линия связи'}
+len(mnoz1)
+4
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+mnoz1
+{'микропроцессор', 'датчик', 'двигатель', 'линия связи', 'реле'}
+mnoz1.remove('линия связи')
+mnoz1
+{'микропроцессор', 'датчик', 'двигатель', 'реле'}
+```
+
+Было создано еще одно множество и проведены некоторые операции над ним.
+
+```
+mnoz2={a, ss1, bb2}
+mnoz2
+{False, 3.67, 'Это = строка символов'}
+mnoz2.remove(3.67)
+mnoz2
+{False, 'Это = строка символов'}
+mnoz2.add(90)
+mnoz2
+{False, 90, 'Это = строка символов'}
+```

TEMA2/task.md

@@ -0,0 +1,42 @@
+# Общее контрольное задание по теме 2
+
+Девятова Мария, А-03-23
+
+## Задание
+
+1) Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+2) Создать переменную со значением, совпадающим с первой буквой из familia.
+3) Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+4) Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+5) Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+6) Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+7) Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+8) Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+
+## Выполнение
+
+```
+familia='Deviatova'
+d=familia[0]
+d
+'D'
+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=('Maria', 'Lyudmila', 'Danil', 'Ilya')
+type(kort_nam)
+<class 'tuple'>
+kort_nam=kort_nam + ('Vadim', 'Nikita')
+kort_nam
+('Maria', 'Lyudmila', 'Danil', 'Ilya', 'Vadim', 'Nikita')
+kort_nam.count('Dima')
+0
+dict_bas={'строка':familia, 'символ':d, 'список':sp_kw, 'кортеж':kort_nam}
+dict_bas
+{'строка': 'Deviatova', 'символ': 'D', 'список': ['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'], 'кортеж': ('Maria', 'Lyudmila', 'Danil', 'Ilya', 'Vadim', 'Nikita')}
+```

TEMA2/task1.md

@@ -0,0 +1,22 @@
+# Индивидуаьное контрольное задание по теме 2
+
+Девятова Мария, А-03-23
+
+# Вариант №14
+
+## Задание
+
+Создайте объект
+ fg={'b':23,'c':45,'a':-12}
+К какому классу относится этот объект? Напишите инструкцию, создающую словарь, у которого упорядоченным по алфавиту ключам объекта fg соответствуют упорядоченные по величине значения этого объекта.
+
+## Выполнение
+
+```
+fg={'b':23,'c':45,'a':-12}
+type(fg)
+<class 'dict'>
+fg_sort=dict(zip(sorted(fg.keys()), sorted(fg.values())))
+fg_sort
+{'a': -12, 'b': 23, 'c': 45}
+```

TEMA3/report.md

@@ -0,0 +1,716 @@
+# Отчет по теме 3
+
+Девятова Мария, А-03-23
+
+## 1 Запуск интерактивной оболочки IDLE, стандартные подготовительные операции
+
+## 2 Преобразование простых базовых типов объектов
+
+### 2.1 Преобразование в логический тип с помощью функции bool().
+
+С помощью функции bool() были преобразованы объекты в логический тип. В примерах возвращает True, если передаваемое целое число не равно нулю или если передаваемая строка не является пустой.
+
+```
+logiz1=bool(56); logiz1; type(logiz1)
+True
+<class 'bool'>
+logiz2=bool(0); logiz2; type(logiz2)
+False
+<class 'bool'>
+logiz3=bool("Beta"); logiz3; type(logiz3)
+True
+<class 'bool'>
+logiz4=bool(""); logiz4; type(logiz4)
+False
+<class 'bool'>
+```
+
+### 2.2 Преобразование в целое десятичное или вещественное число
+
+С помощью функции int() были преобразованы объекты в целочисленный тип данных. Вторым аргументом можно указывать систему счисления, в которой представлен объект. По умолчанию десятичная.
+
+```
+tt1=int(198.6); tt1; type(tt1)
+198
+<class 'int'>
+tt2=int("-76"); tt2; type(tt2)
+-76
+<class 'int'>
+tt3=int("B",16); tt3; type(tt3)
+11
+<class 'int'>
+tt4=int("71",8); tt4; type(tt4)
+57
+<class 'int'>
+tt5=int("98.76"); tt5; type(tt5)
+Traceback (most recent call last):
+  File "<pyshell#18>", line 1, in <module>
+    tt5=int("98.76"); tt5; type(tt5)
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+При передаче строки, в которой записано вещественное число, возникает ошибка, потому как функция принимает строку только с цифровыми символами.
+Было произведено преобразование целых чисел или строк символов в вещественное число – с помощью функции float().
+
+```
+flt1=float(789); flt1; type(flt1)
+789.0
+<class 'float'>
+flt2=float(-6.78e2); flt2; type(flt2)
+-678.0
+<class 'float'>
+flt3=float("Infinity"); flt3; type(flt3)
+inf
+<class 'float'>
+flt4=float("-inf"); flt4; type(flt4)
+-inf
+<class 'float'>
+```
+
+### 2.3 Преобразование десятичных чисел в другие системы счисления.
+
+Было произведено преобразование десятичного числа 123 соотвественно в двоичную, восьмеричную и шестнадцатеричную системы счисления. Для проверки были проведены обратные преобразования.
+
+```
+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().
+
+Было продемонстрировано преобразование объектов различных типов в строку.
+
+```
+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})
+``` 
+
+### 3.2 Преобразование элементов объекта в список с помощью функции list().
+
+Были преобразованы объекты различных типов в списки.
+
+```
+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().
+
+```
+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 Удаление объектов
+
+Была очищена оперативная память от ранее созданных объектов с помощью инструкции del. Затем формально было проверено отсутствие указанных объектов.
+
+```
+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', 'spis44', 'spis5', 'spis55', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+
+По заданию была создана строка с фамилией и инициалами, преобразована в список, затем список – в кортеж, кортеж – в строку.
+
+```
+str0='Девятова М.Е.'
+spis0=list(str0)
+spis0
+['Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.']
+kort0=tuple(spis0); kort0
+('Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.')
+str00=str(kort0); str00
+"('Д', 'е', 'в', 'я', 'т', 'о', 'в', 'а', ' ', 'М', '.', 'Е', '.')"
+```
+
+## 4 Арифметические операции.
+
+### 4.1 Сложение/вычитание.
+
+```
+12+7+90
+109
+5.689e-1 - 0.456
+0.11289999999999994
+23.6+54
+77.6
+14-56.7+89
+46.3
+```
+
+### 4.2 Умножение.
+
+```
+-6.7*12
+-80.4
+```
+
+### 4.3 Деление.
+
+```
+-234.5/6
+-39.083333333333336
+a=178/45; a; type(a)
+3.9555555555555557
+<class 'float'>
+```
+
+### 4.4 Деление с округлением вниз.
+
+```
+b=178//45; b; type(b)
+3
+<class 'int'>
+c=-24.6//12.1; c; type(c)
+-3.0
+<class 'float'>
+d=120//54.5; d; type(d)
+2.0
+<class 'float'>
+e=120.1//54; e; type(e)
+2.0
+<class 'float'>
+```
+
+### 4.5 Получение остатка от деления.
+
+```
+148%33
+16
+12.6%3.8
+1.2000000000000002
+12.6%3
+0.5999999999999996
+12%3.8
+0.6000000000000005
+```
+
+### 4.6 Возведение в степень. Операции над комплексными числами
+
+```
+14**3
+2744
+2.7**3.6
+35.719843790663525
+2.7**3
+19.683000000000003
+2**3.6
+12.125732532083186
+```
+
+Были проделаны различные операции над комплексными числами. Операции деления с округлением вниз и получения остатка от деления не применяются для чисел такого типа.
+
+```
+c1=5+7j
+c2=1-3j
+c1+c2
+(6+4j)
+c1-c2
+(4+10j)
+c1*c2
+(26-8j)
+c1/c2
+(-1.6+2.1999999999999997j)
+c2**4.6
+(171.38366786889966+102.16827023666599j)
+c1//2
+Traceback (most recent call last):
+  File "<pyshell#87>", line 1, in <module>
+    c1//2
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+c1%c2
+Traceback (most recent call last):
+  File "<pyshell#88>", line 1, in <module>
+    c1%c2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+
+## 5 Операции с двоичными представлениями целых чисел.
+
+### 5.1 Двоичная инверсия (~).
+
+Значение каждого бита в представлении числа заменяется на противоположное значение.
+
+```
+dv1=9; bin(dv1)
+'0b1001'
+dv2=~dv1; bin(dv2); dv2
+'-0b1010'
+-10
+```
+
+### 5.2 Двоичное «И» (&).
+
+Логическое умножение, возвращает 1, если оба соответствующих бита сравниваемых чисел равны 1.
+
+```
+dv3=7; dv4=8
+bin(dv3); bin(dv1)
+'0b111'
+'0b1001'
+dv3&dv1
+1
+bin(dv3&dv1)
+'0b1'
+bin(dv3); bin(dv4)
+'0b111'
+'0b1000'
+bin(dv3&dv4)
+'0b0'
+```
+
+### 5.3 Двоичное «ИЛИ» (|).
+
+Логическое сложение, 0 получается, только если оба сравниваемых разряда равны 0.
+
+```
+bin(dv3); bin(dv1)
+'0b111'
+'0b1001'
+dv3|dv1
+15
+bin(dv3|dv1)
+'0b1111'
+bin(dv3); bin(dv4)
+'0b111'
+'0b1000'
+dv3|dv4
+15
+bin(dv3|dv4)
+'0b1111'
+dv5=5; dv6=14
+bin(dv5); bin(dv6)
+'0b101'
+'0b1110'
+dv5|dv6
+15
+bin(dv5|dv6)
+'0b1111'
+```
+
+### 5.4 Двоичное «исключающее ИЛИ»(^).
+
+Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+
+```
+bin(dv5); bin(dv6)
+'0b101'
+'0b1110'
+dv5^dv6
+11
+bin(dv5^dv6)
+'0b1011'
+```
+
+### 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>).
+
+```
+h=14; bin(h)
+'0b1110'
+g=h<<2; g; bin(g)
+56
+'0b111000'
+g1=h>>1; g1; bin(g1)
+7
+'0b111'
+g2=h>>2; g2; bin(g2)
+3
+'0b11'
+```
+
+Были проделаны операции над двумя числами в двоичном представлении.
+
+```
+b1=int("0110011", 2); b2=int("0010110", 2); b1; b2
+51
+22
+bin(~b1)
+'-0b110100'
+~b1
+-52
+b1&b2; bin(b1&b2)
+18
+'0b10010'
+b1|b2; bin(b1|b2)
+55
+'0b110111'
+b1^b2; bin(b1^b2)
+37
+'0b100101'
+b1<<2; bin(b1<<2)
+204
+'0b11001100'
+b2>>3; bin(b2>>3)
+2
+'0b10'
+```
+
+## 6 Операции при работе с последовательностями (строками, списками, кортежами).
+
+### 6.1 Объединение последовательностей (конкатенация)(+).
+
+```
+'Система '+'регулирования'
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+### 6.2 Повторение (*).
+
+```
+'ля-'*5
+'ля-ля-ля-ля-ля-'
+['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99; signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2=(0,)*3+(1,)*5+(0,)*7; signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+### 6.3 Проверка наличия заданного элемента в последовательности (in).
+
+```
+stroka='Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку','-']*3
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+
+### 6.4 Подстановка значений в строку с помощью оператора «%».
+
+```
+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 Обычное присваивание значения переменной (=)
+
+```
+zz=-12
+```
+
+### 7.2 Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=). 
+
+Для последовательностей (например, строка) операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+
+```
+zz+=5; zz
+-7
+zz-=3; zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+```
+
+### 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=).
+
+Для строк операция (*=) означает повторение текущего значения объекта заданное число раз.
+
+```
+zz/=2; zz
+-5.0
+zz*=5; zz
+-25.0
+stroka*=2; stroka
+'Система регулированияСистема регулирования'
+```
+
+### 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень (**=).
+
+```
+zz//=7; zz
+-4.0
+zz%=3; zz
+2.0
+zz
+2.0
+zz**=5; zz
+32.0
+```
+
+### 7.5 Множественное присваивание.
+
+```
+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"; n1; n2; n3
+'11'
+'-3'
+'all'
+n1,n2,n3=[11,-3,'all']; n1; n2; n3
+11
+-3
+'all'
+n1,n2,n3={11: 0,-3: 3,'all': 1}; n1; n2; n3
+11
+-3
+'all'
+n1,n2,n3={11,-3,'all'}; n1; n2; n3
+11
+'all'
+-3
+```
+
+## 8 Логические операции
+
+### 8.1 Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=).
+
+```
+w==v
+True
+w!=v
+False
+v+=8
+w>v
+False
+w<v
+True
+v>=w
+True
+v<=w
+False
+```
+
+### 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in).
+
+```
+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).
+
+```
+a=17; b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a==b) or (145 in dic1.values()) or not ('VMSS' in dct1['Depart'])
+True
+(a>0) or ('pen' in mnoz1) and ('Moscow' in dic1)
+False
+```
+
+### 8.4 Проверка ссылок переменных на один и тот же объект (is).
+
+```
+w=v=10
+w is v
+True
+w1=['A','B']; v1=['A','B']
+w1 is v1
+False
+```
+
+## 9 Операции с объектами, выполняемые с помощью методов.
+
+Полный список атрибутов объекта с использованием dir():
+
+```
+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 Методы для работы со строками.
+
+```
+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); strk1
+'Момент времени 1, значение = 89.7'
+'Момент времени {}, значение = {}'
+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 Методы работы со списками.
+
+```
+spsk=[1, 'abc', (8, 5), [2, 5], 1+7j]
+spsk.pop(2); spsk
+(8, 5)
+[1, 'abc', [2, 5], (1+7j)]
+spsk.append('c'); spsk
+[1, 'abc', [2, 5], (1+7j), 'c']
+spsk.insert(2,'a'); spsk
+[1, 'abc', 'a', [2, 5], (1+7j), 'c']
+spsk.count('a')
+1
+```
+
+### 9.3 Методы работы с кортежами.
+
+```
+kort_m=(1, 5, 8+6j, 'u')
+dir(kort_m)
+['__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']
+kort_m.count(5)
+1
+kort_m.index('u')
+3
+```
+
+### 9.4 Методы работы со словарями и множествами.
+
+Словари:
+
+```
+dict_m={'a': '21', 'b': 't', 'c': 90}
+dir(dict_m)
+['__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']
+dict_m.items()
+dict_items([('a', '21'), ('b', 't'), ('c', 90)])
+dict_m.values()
+dict_values(['21', 't', 90])
+dict_m.keys()
+dict_keys(['a', 'b', 'c'])
+dict_m.get('b')
+'t'
+dict_m.popitem()
+('c', 90)
+dict_m.pop('b')
+'t'
+dict_m
+{'a': '21'}
+dict_m.update({'v': 0, 'q': 'x'})
+dict_m
+{'a': '21', 'v': 0, 'q': 'x'}
+dict_m.clear()
+dict_m
+{}
+```
+
+Множества:
+
+```
+mn_m={'red','blue','green','black','blue'}
+mn_m
+{'green', 'red', 'blue', 'black'}
+dir(mn_m)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+mn_m.add('white')
+mn_m
+{'white', 'blue', 'black', 'red', 'green'}
+mn_m.remove('green')
+mn_m
+{'white', 'blue', 'black', 'red'}
+mn_m1=mn_m.copy()
+mn_m1
+{'red', 'white', 'blue', 'black'}
+mn_m1.add('yellow')
+mn_m
+{'white', 'blue', 'black', 'red'}
+mn_m1
+{'white', 'blue', 'black', 'yellow', 'red'}
+mn_m.difference(mn_m1)
+set()
+mn_m1.difference(mn_m)
+{'yellow'}
+mn_m2={'orange', 'violet', 'black'}
+mn_m3=mn_m.union(mn_m2); mn_m3
+{'violet', 'white', 'blue', 'black', 'orange', 'red'}
+mn_m3.symmetric_difference(mn_m2)
+{'blue', 'white', 'red'}
+mn_m3.intersection(mn_m2)
+{'violet', 'black', 'orange'}
+mn_m.issubset(mn_m1)
+True
+mn_m.isdisjoint(mn_m1)
+False
+```

TEMA3/task.md

@@ -0,0 +1,93 @@
+# Общее контрольное задание по теме 3
+
+Девятова Мария, А-03-23
+
+## Задание
+
+1) Преобразовать восьмеричное значение 45 в целое число.
+2) Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+3) Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+4) Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+5) Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+6) Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+7) Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+1)
+
+```
+int('45', 8)
+37
+```
+
+2)
+
+```
+D={"усиление":23, "запаздывание":12, "постоянная времени":78}
+D_k=list(D.keys()); D_k
+['усиление', 'запаздывание', 'постоянная времени']
+D_v=list(D.values()); D_v
+[23, 12, 78]
+K=tuple(D_k+D_v); K
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+```
+
+3)
+
+```
+((1768//24.8)%3)**2.4
+5.278031643091577
+```
+
+4)
+
+```
+((~(13&27))^14)<<2
+-32
+```
+
+5)
+
+```
+spis=["колебат"]*4
+spis
+['колебат', 'колебат', 'колебат', 'колебат']
+"аткол" in spis[1]+spis[2]
+True
+```
+
+6)
+
+```
+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']
+help(D.keys)
+Help on built-in function keys:
+
+keys() method of builtins.dict instance
+    Return a set-like object providing a view on the dict's keys.
+
+D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+help(D.values)
+Help on built-in function values:
+
+values() method of builtins.dict instance
+    Return an object providing a view on the dict's values.
+
+D.values()
+dict_values([23, 12, 78])
+```
+
+7)
+
+```
+strok='Создать объект - символьную строку с текстом данного предложения'
+st_list=list(strok.split()); st_list
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+st_list[st_list.index('-')]=','; st_list
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+st_list.remove('данного'); st_list
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/test.md

@@ -0,0 +1,60 @@
+# Тест по модулю 1
+
+Девятова Мария, А-03-23
+
+## Задание, вариант M1_24
+
+1)Какое назначение имеют демонстрационные примеры в системе помощи?
+
+2)Создайте объект-кортеж с 5 элементами - произвольными восьмеричными числами. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)Напишите инструкцию, позволяющую определить, сколько элементов в кортеже. Напишите инструкцию, позволяющую выделить из кортежа второе по порядку число и записать его в виде отдельной переменной. Отобразите на экране получившийся объект.
+
+4)Преобразуйте кортеж в список. Вставьте в список на третью позицию число 888. Отобразите получившийся объект. Преобразуйте список в строку и уберите из неё разделители чисел. Отобразите строку.
+
+5)Используя метод форматирования написать инструкцию вывода на экран  заданного номером элемента кортежа по шаблону: "Элемент кортежа №4 = <значение элемента>".
+
+## Выполнение
+
+1) Демонстрационные примеры в системе помощи имеют назначение предоставить пользователю, который обратился к справочной информации, например, о какой-либо функции, реальный пример применения функции или метода, который можно реализовать и проверить его выполнение.
+
+2) 
+
+```
+v=(oct(21), oct(7), oct(62), oct(32), oct(11)); v
+('0o25', '0o7', '0o76', '0o40', '0o13')
+type(v)
+<class 'tuple'>
+dir(v)
+['__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']
+```
+
+3)
+
+```
+len(v)
+5
+v2=v[1]; v2
+'0o7'
+```
+
+4)
+
+```
+spisv=list(v); spisv
+['0o25', '0o7', '0o76', '0o40', '0o13']
+spisv.insert(2, 888); spisv
+['0o25', '0o7', 888, '0o76', '0o40', '0o13']
+strv=str(spisv); strv
+"['0o25', '0o7', 888, '0o76', '0o40', '0o13']"
+strv=strv.replace(', ', ' '); strv
+"['0o25' '0o7' 888 '0o76' '0o40' '0o13']"
+```
+
+5)
+
+```
+sss='Элемент кортежа №4 = {}'
+sss.format(v[3])
+'Элемент кортежа №4 = 0o40'
+```

TEMA4/report.md

@@ -0,0 +1,367 @@
+# Отчет по теме 4
+
+Девятова Мария, А-03-23
+
+## 1 Запуск IDLE
+
+## 2  Стандартные функции
+
+### 2.1 Функция round 
+
+Округление числа с заданной точностью
+
+```
+a=round(123.456,1); a; type(a)
+123.5
+<class 'float'>
+b=round(123.456,0); b; type(b)
+123.0
+<class 'float'>
+c=round(123.456); c; type(c)
+123
+<class 'int'>
+```
+
+### 2.2 Функция range
+
+Создание последовательности целых чисел с заданным шагом (по умолчанию с шагом 1).
+
+```
+gg=range(76,123,9)
+gg
+range(76, 123, 9)
+list(gg)
+[76, 85, 94, 103, 112, 121]
+gg1=range(23); list(gg1)
+[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
+
+Создание общего объекта, элементами которого являются кортежи, составленные из элементов двух или более объектов-последовательностей
+
+```
+qq=['Девятова', 'Ефимова', 'Беженарь', 'Гордиевских']
+ff=zip(gg,qq)
+ff
+<zip object at 0x000002B6596E6C00>
+tuple(ff)
+((76, 'Девятова'), (85, 'Ефимова'), (94, 'Беженарь'), (103, 'Гордиевских'))
+ff[1]
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+
+### 2.4 Функция eval
+
+Вычисление значения выражения, записанного в виде символьной строки
+
+```
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=81
+dan
+249.0
+```
+
+### 2.5 Функция exec
+
+Выполнение инструкций, переданных в аргумент функции в строковом виде
+
+```
+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(-9) 
+9
+pow(7, 3) 
+343
+max(7, 9, 0) 
+9
+min(-9, 0, 8)
+-9
+sum([1, -8, 7, 2]) 
+2
+divmod(43, 6) 
+(7, 1)
+divmod(-43, 6)
+(-8, 5)
+divmod(-43, -6)
+(7, -1)
+len(qq) 
+4
+length_words=map(len, qq); list(length_words)
+[8, 7, 8, 11]
+```
+
+## 3 Функции из стандартного модуля math
+
+```
+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!.
+
+    Raise a ValueError if x is negative or non-integral.
+
+math.factorial(5)
+120
+math.pi
+3.141592653589793
+math.degrees(1)
+57.29577951308232
+math.radians(60)
+1.0471975511965976
+math.sin(math.radians(30))
+0.49999999999999994
+math.degrees(math.acos(0.5))
+60.00000000000001
+math.degrees(math.acos(12))
+Traceback (most recent call last):
+  File "<pyshell#70>", line 1, in <module>
+    math.degrees(math.acos(12))
+ValueError: math domain error
+math.exp(2)
+7.38905609893065
+math.log(math.e)
+1.0
+math.log(49, 7)
+2.0
+math.log(-49, 7)
+Traceback (most recent call last):
+  File "<pyshell#73>", line 1, in <module>
+    math.log(-49, 7)
+ValueError: math domain error
+math.log10(10)
+1.0
+math.sqrt(121)
+11.0
+math.sqrt(-49)
+Traceback (most recent call last):
+  File "<pyshell#79>", line 1, in <module>
+    math.sqrt(-49)
+ValueError: math domain error
+math.ceil(11/2)
+6
+math.floor(11/2)
+5
+```
+
+## 4 Функции из модуля cmath
+
+```
+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 Стандартный модуль random
+
+```
+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()
+random.random()
+0.03177690077737194
+random.random()
+0.42660420133444044
+random.random()
+0.6029016351661705
+random.uniform(3, 8)
+3.349556259329991
+random.randint(3, 8)
+7
+random.gauss()
+1.3115168238883617
+random.gauss(5, 8)
+18.723843368888335
+lst=[13, 'cat', 5-8j, (1, 7), 67.8]
+random.choice(lst)
+(1, 7)
+random.shuffle(lst)
+lst
+[(1, 7), 13, 'cat', (5-8j), 67.8]
+random.sample(lst, 3)
+['cat', 67.8, (5-8j)]
+help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha / (alpha + beta)
+        Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1))
+
+random.betavariate(3, 7)
+0.5892004380254151
+help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+
+    The probability distribution function is:
+
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha * beta
+        Var[X] = alpha * beta ** 2
+
+random.gammavariate(4, 6)
+21.738935796671953
+rand=[random.uniform(1,2), random.gauss(), random.betavariate(2,5), random.gammavariate(3, 4)]
+rand
+[1.0853816485082923, -1.2263412989631917, 0.44973003958419866, 8.863321797224248]
+```
+
+## 6 Функции из модуля time
+
+```
+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
+1761126046.1433933
+c2=time.time()-c1; c2
+12.040217399597168
+dat=time.gmtime(); dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=9, tm_min=41, tm_sec=17, tm_wday=2, tm_yday=295, tm_isdst=0)
+type(dat)
+<class 'time.struct_time'>
+KeyboardInterrupt
+dat.tm_mon
+10
+dat.tm_yday
+295
+msc=time.localtime()
+msc
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=12, tm_min=43, tm_sec=12, tm_wday=2, tm_yday=295, tm_isdst=0)
+time.asctime()
+'Wed Oct 22 12:57:32 2025'
+time.ctime()
+'Wed Oct 22 12:58:08 2025'
+time.sleep(5)
+time.mktime(msc)
+1761126192.0
+time.localtime(c1)
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=22, tm_hour=12, tm_min=40, tm_sec=46, tm_wday=2, tm_yday=295, tm_isdst=0)
+```
+
+## 7 Графические функции
+
+```
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000002B66266AD50>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+![Первый график](Ris1.png)
+
+```
+X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000002B664343610>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000002B664343750>]
+pylab.show()
+```
+![Второй график](Ris11.png)
+
+```
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000002B66264DD30>, <matplotlib.patches.Wedge object at 0x000002B663849090>, <matplotlib.patches.Wedge object at 0x000002B663849450>, <matplotlib.patches.Wedge object at 0x000002B6638496D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+```
+
+![Круговая диаграмма](Ris2.png)
+
+```
+pylab.hist([2, 3, 4, 21, 14, 0, 13, 19, 7, 9, 11], bins=4)
+(array([4., 2., 3., 2.]), array([ 0.  ,  5.25, 10.5 , 15.75, 21.  ]), <BarContainer object of 4 artists>)
+pylab.show()
+```
+
+![Гистограмма](Ris3.png)
+
+```
+pylab.bar(region, naselen)
+<BarContainer object of 4 artists>
+pylab.show()
+```
+
+![Столбчатая диаграмма](Ris4.png)
+
+## 8 Некоторые функции статистического модуля statistics
+
+```
+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']
+statistics.mode(['banana', 'apple', 'strawberry', 'lemon', 'apple', 'pineapple', 'lemon', 'apple'])
+'apple'
+statistics.mode(['banana', 'apple', 'strawberry', 'lemon', 'apple', 'pineapple', 'lemon', 'banana'])
+'banana'
+statistics.correlation(X1, X2)
+-0.3939192985791677
+statistics.stdev(X1)
+2.4083189157584592
+statistics.mean(X1)
+8.6
+```

TEMA4/task.md

@@ -0,0 +1,50 @@
+# Общее контрольное задание по теме 4
+
+Девятова Мария, А-03-23
+
+## Задание
+
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Выполнение
+
+```
+import cmath
+divmod((round(cmath.phase(0.2+0.8j), 2))*20, 3)
+(8.0, 2.6000000000000014)
+import time
+t=time.localtime()
+t
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=23, tm_hour=23, tm_min=15, tm_sec=34, tm_wday=3, tm_yday=296, tm_isdst=0)
+msc_time=str(t.tm_hour)+':'+str(t.tm_min); msc_time
+'23:15'
+week=['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
+import random
+random.sample(week, 3)
+['sunday', 'tuesday', 'friday']
+random.choice(range(14, 32, 3))
+20
+N=round(random.gauss(15, 4))
+N
+11
+alphabet=[]
+for i in range(ord('a'), ord('z')+1):
+    alphabet.append(chr(i))
+
+    
+for i in range(ord('A'), ord('Z')+1):
+    alphabet.append(chr(i))
+
+    
+alphabet
+['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
+R=random.sample(alphabet, N); R
+['j', 'u', 'U', 'w', 'p', 'I', 'g', 'R', 'h', 'P', 'G']
+time.localtime().tm_min-t.tm_min
+20
+```

TEMA4/test.md

@@ -0,0 +1,30 @@
+# Индивидуальное контрольное задание по теме 4
+
+Девятова Мария, А-03-23
+
+## Задание
+
+Напишите инструкцию запоминания текущего Московского времени в некоторой переменной. 
+Создайте кортеж с целочисленными значениями от 0 до 136 с шагом 17. Подсчитайте число элементов в кортеже. 
+Создайте нормально распределенное число Z с математическим ожиданием 47 и стандартным отклонением 22. 
+Нацело разделите сумму элементов кортежа на округленное до целого значения Z. 
+Отобразите результат в виде символьной строки вида «Результат = ХХ» с использование формата. 
+Определите время в минутах, прошедшее с начала выполнения данного задания.
+
+## Выполнение
+
+```
+import time; import random
+t1=time.localtime(); t1
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=4, tm_sec=41, tm_wday=4, tm_yday=297, tm_isdst=0)
+cort=tuple(range(0, 136, 17)); cort; len(cort)
+(0, 17, 34, 51, 68, 85, 102, 119)
+8
+Z=random.gauss(47, 22); Z
+107.92112395720454
+res=sum(cort)//round(Z)
+print("Результат = {}".format(res))
+Результат = 4
+time.localtime().tm_min-t1.tm_min
+5
+```