ИКЗ первого модуля, а не 3

TEMA1/pr0.py

@@ -0,0 +1,5 @@
+
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1')

TEMA1/report.md

@@ -0,0 +1,188 @@
+## Отчет по теме 1
+ Володин Денис, А-02-23
+
+
+## Пункт 1
+
+На рабочем столе создан клон репозитория
+
+## Пункт 2
+
+Запущен интерпретатор Python
+
+## Пункт 3-5 проверка базовых функций Питона
+
+```py
+>>> print("hello")
+hello
+
+>>> h = input('Your name = ')
+Your name = Den
+>>> h
+'Den'
+
+>>> exit()
+```
+
+## Пункты 6-7
+
+Запущена IDLE Python, изучено устройство главного командного окна среды
+
+## Пункт 8 настройка рабочего каталога
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1')
+```
+
+## Пункт 9
+
+Шрифт изменен на Arial CYR, кегль 11, размер начального окна 50*100 символов,
+комментарии подсвечиваются коричневым
+
+## Пункт 10 создание простейшей программы и проверка различных запусков
+
+В текстовом редакторе IDLE создана программа следующего содержания:
+
+#Программа по теме 1 Володин Д.В.
+
+```py
+import os
+print("hello")
+h = input('Your name = ')
+os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1')
+
+
+======== RESTART: C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1\pr0.py ========
+hello
+Your name = 
+```
+
+Другой вариант запуска:
+
+```py
+>>> import pr0
+	     
+hello
+Your name = 
+```
+
+При нажатии f5 в активном окне редактора:
+
+```py
+======== RESTART: C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1\pr0.py ========
+hello
+Your name = 
+```
+
+## Пункт 11 проверка работы программ из рабочего каталога
+
+Из консоли вызван файл prb1.py
+
+```py
+>>> import prb1
+	     
+Как Вас зовут? Den
+Привет, Den
+```
+
+## Пункт 12 проверка содержимого кэша программы
+![](figure0.png)
+
+Файл Pr0.cpython-34.pyc открыт в Блокноте. Видно, что
+разультат компиляции тяжел для восприятия человеком, вероятно, из-за 
+несоответствия кодировок. Комплиляция программ необходима, чтобы
+перевести команды из человекопонятной формы в машинный код, который
+может быть обработан процессором. При выполнении скрипта Python сначала
+преобразовывает его в байт-код (.рус), а затем уже он компилируется с
+помощью виртуальный машины. Это ускорит повторную загрузку программы.
+
+## Пункт 13
+
+Все верные команды из командного окна IDLE скопированы в отдельный файл для отчета
+
+## Пункт 14 проверка функции help
+
+В разделе помощи help можно найти следующие опции:
+
+About IDLE - описание характеристик текущей среды (версия, путь и пр.)
+
+IDLE Help - помощь по работе со средой
+
+Python Docs - документация по языку
+
+Turtle Demo - окно работы и помощь модуля для работы с графикой turtle
+
+```py
+>>> help (print)
+	     
+Help on built-in function print in module builtins:
+
+print(...)
+    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    
+    Prints the values to a stream, or to sys.stdout by default.
+    Optional keyword arguments:
+    file:  a file-like object (stream); defaults to the current sys.stdout.
+    sep:   string inserted between values, default a space.
+    end:   string appended after the last value, default a newline.
+    flush: whether to forcibly flush the stream.
+
+>>> help(print), help(input)
+	     
+Help on built-in function print in module builtins:
+
+print(...)
+    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    
+    Prints the values to a stream, or to sys.stdout by default.
+    Optional keyword arguments:
+    file:  a file-like object (stream); defaults to the current sys.stdout.
+    sep:   string inserted between values, default a space.
+    end:   string appended after the last value, default a newline.
+    flush: whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt=None, /)
+    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.
+
+(None, None)
+```
+
+F1 -> Указатель -> print() (built-in function) выводит справку по этой
+функции
+
+То же диалоговое окно появляется при help - Python Docs
+
+## Пункт 15 ознакомление с работой при нескольких открытых окнах, знакомство со встроенными функциями Turtle
+
+File - Open - prb1.py
+
+С помощью Window можно переключаться между всеми открытыми окнами
+
+```py
+prb1.py - Run
+
+======== RESTART: C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA1\prb1.py ========
+Как Вас зовут? Den
+Привет, Den
+```
+
+```py
+>>> import tdemo_chaos
+```
+![График tdemo_chaos](figure1.png)
+Эта программа строит графики 3 функций, которые по началу кажутся одинаковыми, но начиная с некоторого значения параметра, графики "превращаются в хаос"
+ 
+Help - Turtle Demo - clock - Start выводит на экран графическое представление
+программы - циферблат с часами. Есть и другие примеры программ модуля turtle,
+которые запускают различные графические анимации 
+
+16. Завершена работа со средой: File - exit

TEMA1/test.md

@@ -0,0 +1,11 @@
+## Индивидуальное конрольное задание по Теме 1
+
+Володин Денис, А-02-23
+
+## Вопрос
+
+Можно ли с помощью оболочки IDLE создавать исполняемые файлы (*.exe, *.com)?
+
+## Ответ
+
+На прямую создать исполняемые файлы нельзя. Можно создать скрипт *.py и с помощью сторонних програм преобразовать его в *.ехе

TEMA2/report.md

@@ -0,0 +1,696 @@
+# Отчет по теме 2
+ 
+Володин Денис, А-02-23
+
+
+## Пункт 1
+
+Рабочая среда настроена на нахождение в нужной директории:
+
+```py
+>>> import os
+>>> os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA2')
+```
+
+## Пункт 2
+
+Создадим два простых объекта - переменные f1 и f2. Это можно сделать в одну строку:
+
+```py
+>>> f1 = 16; f2 = 3
+```
+
+Можно вывести эти переменные через запятую. Тогда они будут отображены как кортеж:
+
+```py
+>>> f1, f2
+(16, 3)
+```
+
+Или через точку с запятой. тогда друг за другом:
+
+```py
+>>> f1; f2
+16
+3
+```
+
+Функция dir() покажет, какие объекты находятся в текущем рабочем пространстве:
+
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+
+Еще эта функция может показать атрибуты объекта:
+
+```py
+>>> dir (f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__',
+ '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__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__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag',
+ 'numerator', 'real', 'to_bytes']
+```
+
+Для определения классовой принадлежности любого объекта следует использовать функцию type():
+
+```py
+>>> type(f2)
+<class 'int'>
+```
+
+Удалим объекты из рабочего пространства:
+
+```py
+>>> del f1, f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+## Пункт 3
+
+Правила именования объектов:
+
+```py
+>>> gg1 = 1.6
+>>> hh1 = 'example'
+>>> 73sr = 3
+SyntaxError: invalid syntax  --- ошибка, т.к. имя не может начинаться с числа
+>>> and = 7
+SyntaxError: invalid syntax  --- ошибка, т.к. имя не может совпадать с ключевым словом языка
+```
+
+## Пункт 4
+
+Можно просмотреть все ключевые слова:
+
+```py
+>>> import keyword
+>>> keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', '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']
+
+>>> keyWordList = keyword.kwlist
+>>> keyWordList
+['False', 'None', 'True', 'and', 'as', 'assert', '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
+>>> import builtins
+>>> dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError',
+ 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError',
+ 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', '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', 'all', 'any', 'ascii', 'bin', 'bool', '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']
+```
+
+Среди этих имен есть полезные функции, например:
+
+Взятие модуля
+
+```py
+>>> abs(-10)
+10
+```
+
+Длина объекта
+
+```py
+>>> len([1, 2, 3])
+3
+```
+
+Максимум значений:
+
+```py
+>>> max(15, 14)
+15
+```
+
+Минимум значений:
+
+```py
+>>> min (15,10)
+10
+```
+
+Возведение в степень:
+
+```py
+>>> pow (5, 2)
+25
+```
+
+Округление:
+
+```py
+>>> round (3,124)
+3
+```
+
+Суммирование:
+
+```py
+>>> sum ([7, 3, 5])
+15
+```
+
+Сортировка по возрастанию или по убыванию:
+
+```py
+>>> sorted ([3, 7, 9, 75, 0, -1])
+[-1, 0, 3, 7, 9, 75]
+
+>>> sorted ([3, 7, 9, 75, 0, -1], reverse = True)
+[75, 9, 7, 3, 0, -1]
+```
+
+Объединение объектов в кортеж:
+
+```py
+>>> list1 = [1, 2, 3]
+>>> list2 = [4, 5, 6]
+>>> zip (list1, list2)
+<zip object at 0x0000000002C42E88>
+
+>>> list(zipped)
+[(1, 4), (2, 5), (3, 6)]
+```
+
+## Пункт 6
+
+Питон - язык, чувствительный к регистрам
+
+```py
+>>> Gg1 = 45
+>>> gg1, Gg1
+(1.6, 45)
+>>> gg1 == Gg1
+False
+```
+
+## Пункт 7
+
+Изучим базовые типы объектов
+
+Логический тип:
+
+```py
+>>> bb1 = True
+>>> bb2 = False
+>>> type(bb1)
+<class 'bool'>
+```
+
+Целое число:
+
+```py
+>>> ii1 = 1234567890
+>>> type(ii1)
+<class 'int'>
+```
+
+Экспоненциальная форма записи числа:
+
+```py
+>>> ff1 = 8.987e-12
+>>> type(ff1)
+<class 'float'>
+```
+
+Двоичное число:
+
+```py
+>>> dv1 = 0b1100101
+>>> type(bb1)
+<class 'bool'>
+```
+
+Восьмеричное число:
+
+```py
+>>> vsm1 = 0o52765
+>>> type(vsm1)
+<class 'int'>
+```
+
+Шестнадцатеричное число:
+
+```py
+>>> shest1 = 0x7109af6 
+>>> type(shest1)
+<class 'int'>
+```
+
+Комплексное число:
+
+```py
+>>> cc1 = 2 - 3j
+>>> type(cc1)
+<class 'complex'>
+
+>>> a = 3.67
+>>> b = 0.45
+>>> cc2 = complex (a, b)
+>>> cc2
+(3.67+0.45j)
+>>> type (cc2)
+<class 'complex'>
+```
+
+Строки:
+
+```py
+>>> ss1 = "Это - строка символов"
+>>> ss2 = 'Это - строка символов'
+>>> ss1 == ss2
+True
+
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+
+>>> ss1b = 'Меня зовут: \n Володин Д.В.'
+>>> print(ss1b)
+Меня зовут: 
+ Володин Д.В.
+```
+
+Большую строку можно записать в тройных кавычках:
+
+```py
+>>> mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Обратимся к отдельным элементам с помощью квадратных кавычек:
+
+```py
+>>> mnogo[3]
+'р'
+>>> ss1b[-1]
+'.'
+```
+
+Срезы:
+
+```py
+>>> ss1[6:9]
+'стр'
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[5:-8]
+' строка '
+>>> ss1[::-1]
+'воловмис акортс - отЭ'
+>>> ss1[17:3:-2]
+'омсаот '
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+
+Строка - неизменяемый тип данных:
+
+```py
+>>> ss1[4] = "="
+Traceback (most recent call last):
+  File "<pyshell#108>", line 1, in <module>
+    ss1[4] = "="
+TypeError: 'str' object does not support item assignment
+```
+
+Но если возникает необходимость изменить строку, то можно пересобрать ее из исходной строки:
+
+```py
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> ss1
+'Это = строка символов'
+```
+
+Собственное создание разных типов данных:
+
+```py
+>>> num10 = 26
+>>> type(num10)
+<class 'int'>
+
+>>> num16 = hex(num10)
+>>> num16
+'0x1a'
+>>> type(num16)
+<class 'str'>
+
+>>> str1 = str(num10) + ' в десятичной - это ' + str(num16) + ' в шестнадцатеричной '
+>>> str1
+'26 в десятичной - это 0x1a в шестнадцатеричной '
+>>> str1[5:16:3]
+'дячй'
+>>> 
+```
+
+## Пункт 8
+
+Список list - изменяемый тип данных. Это упорядоченная последовательность из элементов одного или разных типов.
+
+```py
+>>> spis1 = ["111", 'spisok', 5 - 9j]
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> 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(spis1)
+3
+```
+
+Методы списков:
+
+1. Добавление в конец:
+
+```py  
+>>> 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']
+```    
+
+2. Сложение строк:
+
+```py
+>>> spis1 += ss1b
+>>> spis1
+[111, 'Список', (5-9j), 'New item', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т',
+ ':', ' ', '\n', ' ', 'И', 'ш', 'у', 'т', 'и', 'н', 'а', ' ', 'Е', '.', ' ', 'И', '.']
+>>> spis1 = [111, 'Список', (5-9j), 'New item']
+>>> spis1.append(ss1b)
+>>> spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Володин Д.В.']
+```
+3. Удаление элемента по индексу:
+
+```py       
+>>> spis1.pop(1)
+'Список'
+>>> spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Володин Д.В.']
+>>> spis1.pop(7)
+Traceback (most recent call last):
+  File "<pyshell#41>", line 1, in <module>
+    spis1.pop(7)
+IndexError: pop index out of range
+```
+
+4. Вставка элемента в определенное место по индексу:
+
+```py
+>>> help(spis1.insert)
+Help on built-in function insert:
+
+insert(index, object, /) method of builtins.list instance
+    Insert object before index.
+
+>>> spis1.insert(2, "hello")
+>>> spis1
+[111, (5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.']
+>>> spis1.insert(8, "test")
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.', 'test']
+```
+
+5. Удаление элемента по значению:
+
+```py   
+>>> help(spis1.remove)
+Help on built-in function remove:
+
+remove(value, /) method of builtins.list instance
+    Remove first occurrence of value.
+    
+    Raises ValueError if the value is not present.
+
+>>> spis1.remove(111)
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.']
+>>> spis1.remove('kitten')
+Traceback (most recent call last):
+  File "<pyshell#39>", line 1, in <module>
+    spis1.remove('kitten')
+```
+6. Добавление элементов объекта в конец другого объекта:
+
+```py   
+>>> help(spis1.extend)
+Help on built-in function extend:
+
+extend(iterable, /) method of builtins.list instance
+    Extend list by appending elements from the iterable.
+>>> end1 = [123, "mew", (1,2)]
+>>> spis1.extend(end1)
+>>> spis1
+[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)]
+```    
+  
+7. Полное очищение списка:
+
+```py
+>>> help(spis1.clear)
+Help on built-in function clear:
+
+clear() method of builtins.list instance
+    Remove all items from list.
+
+>>> end1.clear()
+>>> end1
+[]
+```
+
+8. Сортировка списка БЕЗ создания нового объекта:
+
+```py
+>>> help(spis1.sort)
+Help on built-in function sort:
+
+sort(*, key=None, reverse=False) method of builtins.list instance
+    Sort the list in ascending order and return None.
+    
+    The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
+    order of two equal elements is maintained).
+    
+    If a key function is given, apply it once to each list item and sort them,
+    ascending or descending, according to their function values.
+    
+    The reverse flag can be set to sort in descending order.
+>>> end1 = [5, 6, 9.99999, 384, 0, -5]
+>>> end1.sort(key = abs, reverse = True)
+>>> end1
+[384, 9.99999, 6, 5, -5, 0]
+```
+
+При этом некоторые key's не применимы для некоторых типов (у string нет abs,
+у complex нет длины и т.д.)
+
+9. Создание копии списка:
+
+```py
+>>> help(end1.copy)
+Help on built-in function copy:
+
+copy() method of builtins.list instance
+    Return a shallow copy of the list.
+
+    
+>>> endcopy = end1.copy()
+>>> endcopy
+[384, 9.99999, 6, 5, -5, 0]
+```
+
+10. Поиск индекса по значению:
+
+```py
+>>> help(endcopy.index)
+Help on built-in function index:
+
+index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
+    Return first index of value.
+    
+    Raises ValueError if the value is not present.
+
+>>> endcopy.index(0)
+5
+>>> endopy.index("lalala")
+Traceback (most recent call last):
+  File "<pyshell#71>", line 1, in <module>
+    endcopy.index("lalala")
+ValueError: 'lalala' is not in list
+```
+
+11. Подсчет количества элементов по значению:
+
+```py
+>>> help(endcopy.count)
+Help on built-in function count:
+
+count(value, /) method of builtins.list instance
+    Return number of occurrences of value.
+
+>>> endcopy.count(5)
+1
+>>> endcopy.count(666666)
+0
+>>> spis2=[spis1,[4,5,6,7]]
+>>> spis2
+[[(5-9j), 'hello', 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)], [4, 5, 6, 7]]
+>>> spis2[0][1]
+'hello'
+>>> spis2[0][1]=78
+>>> spis2
+[[(5-9j), 78, 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)], [4, 5, 6, 7]]
+>>> spis1
+[(5-9j), 78, 'New item', 'Меня зовут: \n Володин Д.В.', 'test', 123, 'mew', (1, 2)]
+```
+
+Как видно, spis1 тоже изменился. Это происходит потому, что python работает не просто с
+объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке,
+а не по значению.
+Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]]
+мы не создаем копию spis1, а сообщаем именно тот список, поэтому его изменения в составе
+spis2 отобраажются на исходном spis1.
+
+Кортеж - последовательность как список, но неизменяемая как строка.
+
+```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 Володин Д.В.')
+>>> kort1.index(2)
+4
+>>> kort1.count(222)
+1
+>>> kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#91>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+>>> kortstr = ("h", "lambda", "always", 54, [1,2,3], (6,7))
+>>> kortstr
+('h', 'lambda', 'always', 54, [1, 2, 3], (6, 7))
+>>> type(kortstr[5])
+<class 'tuple'>
+>>> type(kortstr[4])
+<class 'list'>
+>>> 
+```
+
+Словарь (dictionary) - содержит в себе совокупность пар
+"ключ (key) (неизменяемый)": "значение (value) (любого типа)"
+
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> dic1[1]
+Traceback (most recent call last):
+  File "<pyshell#99>", line 1, in <module>  #как видно, обратиться по индексу нельзя
+    dic1[1]
+KeyError: 1
+>>> 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]
+>>> 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 Володин Д.В.'}
+```
+
+Создание собственного словаря на основе кортежа из семи элементов и списка из пяти:
+
+```py
+>>> terms_tuple = ("mean", "median", "mode", "variance", "standard deviation", "correlation", "regression")
+>>> count_list = ["one", "two", "three", "four", "five"]
+>>> terms_dict = dict(zip(count_list, terms_tuple))
+>>> terms_dict
+{'one': 'mean', 'two': 'median', 'three': 'mode', 'four': 'variance', 'five': 'standard deviation'}
+```
+
+Как видно, в итоговом словаре пять объектов. Это связано с работой функции zip:
+длина итогового объекта будет соответствовать минимальной длине составляющего
+объекта.
+
+Словари: состоят из Неповторяющихся неизменяемых элементов
+
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>> mnoz1
+{'двигатель', 'линия связи', 'датчик', 'микропроцессор'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле')
+>>> mnoz1.remove('линия связи')
+>>> mnoz1
+{'реле', 'микропроцессор', 'датчик', 'двигатель'}
+```
+
+

TEMA2/task.md

@@ -0,0 +1,70 @@
+# Общее контрольное задание по теме 2
+
+Володин Денис, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+• Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+• Создать переменную со значением, совпадающим с первой буквой из familia.
+
+• Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+• Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+• Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+• Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+• Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+• Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+## Решение
+
+```py
+>>> familia = 'Volodin'
+
+>>> fam1 = familia[0]
+>>> fam1
+'V'
+
+>>> import keyword
+>>> sp_kw = keyword.kwlist
+>>> sp_kw
+['False', 'None', 'True', '__peg_parser__', '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', '__peg_parser__', '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 = ("Denis", "Liza", "Yra", "Lena")
+>>> type(kort_nam)
+<class 'tuple'>
+
+>>> kort_nam += ("Alena", "Nasty")
+>>> kort_nam
+('Denis', 'Liza', 'Yra', 'Lena', 'Alena', 'Nasty')
+
+>>> kort_nam.count("Dima")
+0
+
+>>> dict_bas = {"строка": familia, "символ": fam1, "список": sp_kw,
+                "кортеж": kort_nam,}
+>>> dict_bas
+{'строка': 'Volodin', 'символ': 'V', 'список': ['False', 'None', 'True',
+'__peg_parser__', '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'], 'кортеж': ('Denis', 'Liza', 'Yra', 'Lena', 'Alena', 'Nasty')}
+```

TEMA2/test.md

@@ -0,0 +1,26 @@
+## Индивидуально контрольное задание по Теме 2
+
+Володин Денис, А-02-23
+
+## Задание
+
+
+18. Создайте объект-строку с текстом данного задания. Определите класс объекта, его атрибуты. Напишите инструкцию, обеспечивающую расчет числа символов в объекте и вывод этого числа в виде: «Число символов = ХХХ». Создайте новый объект-строку, в который включите только четные элементы из первой строки.
+
+## Решение
+
+```py
+>>>str1="""Создайте объект-строку с текстом данного задания. Определите класс объекта, его атрибуты.
+Напишите инструкцию, обеспечивающую расчет числа символов в объекте и вывод этого
+числа в виде: «Число символов = ХХХ». Создайте новый объект-строку, в который включите
+только четные элементы из первой строки"""
+>>>type(str1)
+<class 'str'>
+>>>dir(str1)
+['__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']
+>>>ans='Число символов = '+str(len(str1))
+>>>ans
+'Число символов = 298'
+>>>str3=str1[1::2]
+>>>str3
+'одйеоък-тоустктмднооздня пееиекасоъка г тиуы\nаииеисрки,оепчвюу ачтчсасмоо  бет  ыо тг\nил  ие Чсосмоо  Х» одйенвйоък-тоу  ооы кюиетлк енеэеет зпро тои'

TEMA3/task.md

@@ -0,0 +1,69 @@
+# Общее контрольное задание по теме 3
+
+Володин Денис, А-02-23
+
+## Задание
+    • Преобразовать восьмеричное значение 45 в целое число.
+    • Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+    • Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+    • Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+    • Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+    • Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+    • Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>> octv = '45'
+>>> decv = int(octv, 8)
+>>> decv
+37
+>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78}
+>>> keyD = list(D.keys())
+>>> keyD
+['усиление', 'запаздывание', 'постоянная времени']
+>>> valD = list(D.values())
+>>> valD
+[23, 12, 78]
+>>> tupD = (keyD, valD)
+>>> tupD
+(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78])
+>>> ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+>>> ((~(13 & 27)) ^ 14) << 2
+-32
+>>> lst = ["колебат"] * 4
+>>> lst[1] += lst[2]
+>>> lst
+['колебат', 'колебатколебат', 'колебат', 'колебат']
+>>> lst.pop(2)
+'колебат'
+>>> lst
+['колебат', 'колебатколебат', 'колебат']
+>>> 'аткол' in lst[1]
+True
+>>> D
+{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78}
+>>> dir(D)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__',
+ '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
+ '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__',
+ '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__',
+ '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__',
+ '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items',
+ 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+>>> D.values()
+dict_values([23, 12, 78])
+>>> sen = "Создать объект - символьную строку с текстом данного предложения"
+>>> senl = sen.split()
+>>> senl
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl[senl.index("-")] = ","
+>>> senl
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> senl.remove("данного")
+>>> senl
+['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+

TEMA3/test.md

@@ -0,0 +1,49 @@
+## Индивидуально контрольное задание по Теме 3
+
+Володин Денис, А-02-23
+
+## Задание
+
+В-20
+
+1. Какое назначение имеют демонстрационные примеры в системе помощи?
+
+2. Создайте объект-список с числовыми четными целыми значениями от -10 до +26. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3. Напишите инструкцию, позволяющую определить число элементов в созданном списке. Напишите инструкции, заменяющие первое значение в списке на -1000, а последнее - на +1000. Отобразите получившийся объект.
+
+4. Напишите инструкцию, вставляющую в список на 4-ю позицию от начала число 123. Удлините список за счет его повторения ещё два раза. Отобразите получившийся объект. Подсчитайте число элементов в получившемся списке.
+
+4. Преобразуйте список в кортеж. Создайте два кортежа, содержащих, соответственно первую и вторую половину элементов из исходного кортежа. Отобразите созданные объекты.
+
+## Решение
+
+Модуль М1
+```py
+>>> obsp=list(range(-10,26,2))
+>>> type(obsp)
+<class 'list'>
+>>> dir(obsp)
+['__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']
+>>> kol_elem=len(obsp)
+>>> kol_elem
+18
+>>> obsp[0]=-1000
+>>> obsp[-1]=1000
+>>> obsp
+[-1000, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000]
+>>> obsp.insert(3,123)
+>>> long_l=obsp*3
+>>> long_l
+[-1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000]
+>>> len(long_l)
+57
+>>> kurt_n=tuple(long_l)
+>>> mid=len(kurt_n)//2
+>>> f_half=kurt_n[:mid]
+>>> s_half=kurt_n[mid:]
+>>> f_half
+(-1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4)
+>>> s_half
+(6, 8, 10, 12, 14, 16, 18, 20, 22, 1000, -1000, -8, -6, 123, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 1000)
+```

TEMA4/report.md

@@ -0,0 +1,880 @@
+# Отчет по теме 4
+
+Володин Денис, А-02-23
+
+## Пункт 1
+
+Рабочая среда настроена на нахождение в нужной директории:
+
+```py
+>>> import os
+>>> os.chdir(r"C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA4")
+```
+
+## Пункт 2
+
+Стандартные функции (модуль builtins, импортированный по умолчанию во все скрипты)
+
+## Пункт 2.1
+
+round() - округление с заданной точностью
+
+```py
+>>> help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+    
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+>>> round(123.456,1)
+123.5
+>>> type(round(123.456,1))
+<class 'float'>
+>>> round(123.456,0)
+123.0
+>>> type(round(123.456,0))
+<class 'float'>
+>>> round(123.456)
+123
+>>> type(round(123.456))
+<class 'int'>
+```
+
+!!! round использует банковское округление. Это значит, что eсли округляемое число
+равноудалено от соседних чисел, то оно округляется до ближайшей чётной цифры
+заданного десятичного разряда. Пример:
+
+```py
+>>> round(0.5)
+0
+>>> round(1.5)
+2
+```
+
+## Пункт 2.2
+
+range() - генерация последовательности
+
+```py
+>>> help(range)
+Help on class range in module builtins:
+
+class range(object)
+ |  range(stop) -> range object
+ |  range(start, stop[, step]) -> range object
+ |  
+ |  Return an object that produces a sequence of integers from start (inclusive)
+ |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
+ |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
+ |  These are exactly the valid indices for a list of 4 elements.
+ |  When step is given, it specifies the increment (or decrement).
+
+>>> gg=range(76,123,9)
+>>> gg
+range(76, 123, 9)
+>>> type(range(76,123,9))
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> tuple(gg)
+(76, 85, 94, 103, 112, 121)
+>>> g1 = range(23)
+>>> list(g1)
+[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() - создание итерируемого объекта из кортежей
+
+```py
+>>> qq = ["Volodin", "Antonov", "Kireev", "Begenar"]
+>>> ff = zip (gg, qq)
+>>> ff
+<zip object at 0x00000158BF1BB280>
+>>> tuple(ff)
+((76, 'Volodin'), (85, 'Antonov'), (94, 'Kireev'), (103, 'Begenar'))
+```
+
+1. Длина получившегося объекта - меньшая из длин объектов-параметров. В данном случае, это 4.
+2. Объект класса zip не итерируемый и не изменяемый
+
+```py
+>>> ff[1]
+Traceback (most recent call last):
+  File "<pyshell#34>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+
+## Пункт 2.4
+
+eval - вычисление выражения строкой
+
+```py
+>>> help(eval)
+Help on built-in function eval in module builtins:
+
+eval(source, globals=None, locals=None, /)
+    Evaluate the given source in the context of globals and locals.
+    
+    The source may be a string representing a Python expression
+    or a code object as returned by compile().
+    The globals must be a dictionary and locals can be any mapping,
+    defaulting to the current globals and locals.
+    If only globals is given, locals defaults to it.
+
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=73
+>>> fff
+73.0
+>>> dan
+209.0
+```
+
+## Пункт 2.5
+
+exec - выполнение операций строкой
+
+```py
+>>> help(exec)
+Help on built-in function exec in module builtins:
+
+exec(source, globals=None, locals=None, /)
+    Execute the given source in the context of globals and locals.
+    
+    The source may be a string representing one or more Python statements
+    or a code object as returned by compile().
+    The globals must be a dictionary and locals can be any mapping,
+    defaulting to the current globals and locals.
+    If only globals is given, locals defaults to it.
+
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456; gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+```
+
+## Пункт 2.6
+
+--Возвращение модуля (abs)--
+
+```py
+>>> abs(-98)
+98
+>>> abs(5 + 4j)
+6.4031242374328485
+```
+
+--Возведение в степень--
+
+```py
+>>> pow(5,4)
+625
+>>> pow(5,4,10)
+5
+```
+
+--Максимальное из значений--
+
+```py
+>>> max(38,15,-6)
+38
+>>> max([-4,0,5])
+5
+>>> max({'a': 11, 'b': 2, 'c': 3})
+'c'
+```
+
+Пояснение:
+    1. Видно, что выбор большего происходит из ключей
+    2. Видно, что среди буквенных символов больше то, которое ближе к концу алфавита
+
+```py
+>>> max([34,5,6, "hehe", 5+2j])
+Traceback (most recent call last):
+  File "<pyshell#60>", line 1, in <module>
+    max([34,5,6, "hehe", 5+2j])
+TypeError: '>' not supported between instances of 'str' and 'int'
+>>> max(["hehe", "hehehe", "hehehehe"], key = len)
+'hehehehe'
+
+>>> max("b", "B")
+'b'
+```
+
+Пояснение: тут python сравнивает коды символов в unicode. у "b" это 98, а у "B" - 66.
+
+--Поиск минимума--
+
+Aналогичнo максимуму
+
+```py
+>>> min(float("-inf"), -99, 0, 12)
+-inf
+```
+
+--Сумма элементов--
+
+```py
+>>> sum([1,2,3,4])
+10
+>>> sum([1,2,3,4], -5)
+5
+>>> sum("hehe", "haha")
+Traceback (most recent call last):
+  File "<pyshell#79>", line 1, in <module>
+    sum("hehe", "haha")
+TypeError: sum() can't sum strings [use ''.join(seq) instead]
+```
+
+--Возвращение кортежа из целой части и остатка от деления--
+
+```py
+>>> help(divmod)
+Help on built-in function divmod in module builtins:
+divmod(x, y, /)
+    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
+
+>>> divmod(14, 3)
+(4, 2)
+>>> divmod(14, -3)
+(-5, -1)
+```
+
+--Длина объекта--
+
+```py
+>>> len((4,2,1))
+3
+>>> len("mewmewmewmewm")
+13
+>>> len(["mewmewmewmewm", "mewmew"])
+2
+>>> len({'a': 1, 'b': 2, 'c': 3})
+3
+>>> len(43)
+Traceback (most recent call last):
+  File "<pyshell#90>", line 1, in <module>
+    len(43)
+TypeError: object of type 'int' has no len()
+```
+
+--Применение функции к каждому элементу коллекции--
+
+```py
+>>> help(map)
+Help on class map in module builtins:
+class map(object)
+ |  map(func, *iterables) --> map object
+ |  
+ |  Make an iterator that computes the function using arguments from
+ |  each of the iterables.  Stops when the shortest iterable is exhausted.
+
+>>> map(int, ["1", "14"])
+<map object at 0x00000158BF19F250>
+>>> list(map(int, ["1", "14"]))
+[1, 14]
+```
+
+Как следует из справки, если сообщается несколько коллекций, map закончится, когда применит
+функцию к самой короткой из них.
+
+## Пункт 3
+
+Стандартный модуль math
+
+```py
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin',
+ 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees',
+ 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', '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', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(x, /)
+    Find x!.
+    
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+```
+
+--Нахождение синуса--
+
+```py
+>>> help(math.sin)
+Help on built-in function sin in module math:
+sin(x, /)
+    Return the sine of x (measured in radians).
+
+>>> math.sin(3.141)
+0.0005926535550994539
+>>> math.sin(-1)
+-0.8414709848078965
+```
+
+--Нахождение арккосинуса--
+
+```py
+>>> math.acos(1)
+0.0
+>>> math.acos(11)
+Traceback (most recent call last):
+  File "<pyshell#120>", line 1, in <module>
+    math.acos(11)
+ValueError: math domain error
+
+>>> math.acos(-1)
+3.141592653589793
+```
+
+--Перевод из радиан в градусы--
+
+```py
+>>> help(math.degrees)
+Help on built-in function degrees in module math:
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+>>> math.degrees(6.28)
+359.817495342157
+
+>>> math.degrees(1)
+57.29577951308232
+```
+
+--Перевод из градусов в радианы--
+
+```py
+>>> help(math.radians)
+Help on built-in function radians in module math:
+radians(x, /)
+    Convert angle x from degrees to radians.
+
+>>> math.radians(360)
+6.283185307179586
+>>> math.radians(90)
+1.5707963267948966
+>>> math.radians(57)
+0.9948376736367679
+>>> math.radians(3.1415)
+0.05482951845140187
+```
+
+--Число е в степени заданного--
+
+```py
+>>> help(math.exp)
+Help on built-in function exp in module math:
+exp(x, /)
+    Return e raised to the power of x.
+    
+>>> math.exp(0)
+1.0
+>>> math.exp(1)
+2.718281828459045
+>>> math.exp(-5)
+0.006737946999085467
+```
+
+--Нахождение логарифма--
+
+```py
+>>> help(math.log)
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+    If the base not specified, returns the natural logarithm (base e) of x.
+
+>>> math.log(math.e)
+1.0
+>>> math.log(25,5)
+2.0
+```
+
+Согласно нормам математики, логарифмируемое выражение и основание логарифма не могут быть
+отрицательными. Это есть и в python, попытка задать такие значения вернет ValueError.
+
+--Десятичный логарифм--
+
+```py
+>>> math.log10(0.0001)
+-4.0
+>>> math.log10(10000)
+4.0
+```
+
+--Извлечение квадратного корня--
+
+```py
+>>> math.sqrt(49)
+7.0
+```
+
+В данном случае, в отличие от канонов матанализа, задание отрицательного аргумента вернет
+ValueError, а не комплексное число.
+
+--Округление числа до ближайшего целого вверх--
+
+```py
+>>> 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(5.77)
+6
+>>> math.ceil(6.00001)
+7
+>>> math.ceil(-6.7)
+-6
+```
+
+--Округление вниз--
+
+```py
+>>> math.floor(7.99)
+7
+>>> math.floor(-3.7)
+-4
+```
+
+--Константа: число пи--
+
+```py
+>>> math.pi
+3.141592653589793
+```
+
+Пример комбинированного использования:
+
+```py
+>>> math.sin(2 * math.pi / 7 + math.exp(0.23))
+0.8334902641414562
+```
+
+## Пункт 4
+
+Модуль 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
+
+Модуль random для генерации псевдослучайных чисел и работы с ними
+
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom',
+ 'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__',
+ '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos',
+ '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi',
+ '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom',
+ '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss',
+ 'getrandbits', 'getstate', 'lognormvariate', '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.seed() вызывает time.time(), а эта функция, в свою очередь,
+возвращает время в Unix-формате. То есть в качестве сида используется текущее время.
+
+--Случайное число от 0 до 1--
+
+```py
+>>> help(random.random)
+Help on built-in function random:
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+>>> random.random()
+0.009279717292968392
+>>> random.random()
+0.8044346046065457
+>>> random.random()
+0.2928444484701447
+```
+
+--Равномерно распределенное случайное число--
+
+```py
+>>> help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+>>> random.uniform(2,5)
+4.803201121309196
+```
+
+--Равномерное случайное целое--
+
+```py
+>>> help(random.randint)
+Help on method randint in module random:
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+>>> random.randint(3,18)
+5
+>>> random.randint(3,18)
+13
+```
+
+--Случайное из коллекции--
+
+```py
+>>> help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+>>> random.choice([False, "hehehe", 67, 90.7, 5+8j])
+90.7
+```
+
+--Случайное перемешивание элементов коллекции--
+
+```py
+>>> help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x, random=None) method of random.Random instance
+    Shuffle list x in place, and return None.
+    Optional argument random is a 0-argument function returning a
+    random float in [0.0, 1.0); if it is the default None, the
+    standard random.random will be used.
+
+>>> lst = [False, "hehehe", 67, 90.7, 5+8j]
+>>> random.shuffle(lst)
+>>> lst
+[67, False, 90.7, (5+8j), 'hehehe']
+```
+
+Возвращает None, изменяет исходный объект. Работает только с изменяемыми типами.
+
+--Нормально распределенное случайное число--
+
+```py
+>>> help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu, sigma) method of random.Random instance
+    Gaussian distribution.
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+    Not thread-safe without a lock around calls.
+
+>>> random.gauss(0,1)
+1.1859475053515318
+```
+
+--Случайное подмножество--
+
+```py
+>>> help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence or set.
+    
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  <...>
+
+>>> random.sample(lst, 5)
+['cherry', 'tangerine', 'banana', 'pineapple', 'peach']
+>>> random.sample(lst, 1)
+['tangerine']
+>>> random.sample(lst, 0)
+[]
+```
+
+--Случайное число, подчиняющееся бета-распределению--
+
+```py
+>>> 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.
+
+>>> random.betavariate(1,2)
+0.4074810441922475
+```
+
+--Случайное число, подчиняющееся гамма-распределению--
+
+```py
+>>> 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
+
+>>> random.gammavariate(2,4)
+1.9359228890418254
+```
+
+Список из четырех чисел с разными законами распределения:
+
+```py
+>>> rl = [0] * 4
+>>> rl[0] = random.uniform(2,6)
+>>> rl[1] = random.gauss(2, 0.5)
+>>> rl[2] = random.betavariate(2,6)
+>>> rl[3] = random.gammavariate(2,6)
+>>> rl
+[2.6190336401985204, 1.82010731374589, 0.18732603571429413, 20.348843073887398]
+```
+
+## Пункт 6
+
+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']
+```
+
+--UNIX-время--
+
+```py
+>>> c1 = time.time()
+>>> c1
+1727645502.8504922
+>>> c2=time.time()-c1
+>>> c2
+12.900742053985596
+```
+
+Возвращается время в секундах с начала эпохи UNIX: 00:00:00 UTC 1 января 1970 года.
+
+--Текущее время--
+
+```py
+>>> time.gmtime
+<built-in function gmtime>
+
+>>> help(time.gmtime)
+Help on built-in function gmtime in module time:
+
+gmtime(...)
+    gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,
+                           tm_sec, tm_wday, tm_yday, tm_isdst)
+
+>>> dat=time.gmtime()
+>>> list(dat)
+[2025, 10, 4, 8, 45, 23, 6, 278, 0]
+>>> dat.tm_mon
+10
+>>> dat.tm_year
+2025
+>>> dat.tm_yday
+278
+```
+
+--Текущее время с учетом часового пояса--
+
+```py
+>>> here = time.localtime()
+>>> list(here)
+[2025, 10, 4, 11, 45, 23, 6, 278, 0]
+```
+
+--Время из кортежа в строку--
+
+```py
+>>> time.asctime(here)
+'Sut Oct 4 11:48:09 2025'
+```
+
+--Пауза--
+
+```py
+>>> time.sleep(5)
+```
+
+--Из кортежа в секунды с начала эпохи--
+
+```py
+>>> time.mktime(here)
+1728590215.0
+```
+
+## Пункт 7
+
+Графические функции модуля pylab пакета matplotlib
+
+```py
+>>> import matplotlib
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x) 
+>>> pylab.title('Первый график')
+>>> pylab.xlabel('время')
+>>> pylab.ylabel('сигнал')
+>>> pylab.show()
+```
+![](figure0.png)
+
+Два графика на одном окне:
+
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+>>> pylab.plot(X2)
+>>> pylab.show()
+```
+
+![](figure1.png)
+
+Гистограмма:
+
+```py
+>>> data = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]  
+>>> pylab.hist(data, bins=5)  
+>>> pylab.show() 
+```
+![](figure3.png)
+
+Круговая диаграмма:
+
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.hist(naselen,labels=region)
+>>> pylab.show()
+```
+
+![](figure2.png)
+
+Столбиковая диаграмма:
+
+```py
+>>> fruits = ["apple", "date", "apricot", "raspberry", "watermelon"]
+>>> values = [10, 15, 7, 20, 3]
+>>> pylab.bar(fruits, values, color='skyblue')
+<BarContainer object of 5 artists>
+>>> pylab.show()
+```
+
+![](figure4.png)
+
+## Пункт 8
+
+Статистический модуль statistics
+
+```py
+>>> dir(s)
+['Counter', 'Decimal', 'Fraction', 'NormalDist', 'StatisticsError', '__all__',
+ '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
+ '__package__', '__spec__', '_coerce', '_convert', '_exact_ratio', '_fail_neg',
+ '_find_lteq', '_find_rteq', '_isfinite', '_normal_dist_inv_cdf', '_ss', '_sum',
+ 'bisect_left', 'bisect_right', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean',
+ 'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'log', 'math', 'mean', 'median',
+ 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'numbers', 'pstdev',
+ 'pvariance', 'quantiles', 'random', 'sqrt', 'stdev', 'tau', 'variance']
+```
+
+--Математическое ожидание--
+
+```py
+>>> data = [10, 20, 30, 40, 50]
+>>> s.mean(data)
+30
+```
+
+--Медиана--
+
+```py
+>>> s.median(data)
+30
+```
+
+--Среднеквадратичное отклонение--
+
+```py
+>>> s.stdev(data)
+15.811388300841896
+```
+
+--Дисперсия--
+
+```py
+>>> s.variance(data)
+250
+```
+
+--Квантили--
+
+```py
+>>> data = [10, 56, 73, 7, 20, 30, 40, 50, 56, 77, 3]
+>>> s.quantiles(data)
+[10.0, 40.0, 56.0]
+```
+
+По умолчанию n = 4, это квартили. Можно указать 100, например, для процентилей.

TEMA4/task.md

@@ -0,0 +1,44 @@
+# Общее контрольное задание по теме 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)
+>>> nowtime=time.gmtime(time.time()+3*3600)
+>>> nowtime
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=25, tm_sec=58, tm_wday=0, tm_yday=293, tm_isdst=0)
+>>> nows = str(nowtime.tm_hour) + ":" + str(nowtime.tm_min)
+>>> nows
+'10:25'
+>>> week = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+>>> random.sample(week, 3)
+['вторник', 'суббота', 'четверг']
+>>> random.choice(range(14, 32, 3))
+26
+>>> random.choice(range(14, 32, 3))
+14
+>>> N = round(random.gauss(15,4))
+>>> N
+13
+>>> lst = list("abcdefghijgklmnopqrstuvwxyz")
+>>> random.sample(lst, N)
+['i', 'g', 'g', 'j', 't', 's', 'r', 'v', 'f', 'y', 'b', 'z', 'l']
+>>> current_time = time.time()+3*3600
+>>> t_sec = current_time - (time.mktime(nowtime))
+>>> t_min = round(t_sec / 60; 4)
+0.0075
+
+```

TEMA4/test.md

@@ -0,0 +1,37 @@
+## Индивидуально контрольное задание по Теме 4
+
+Володин Денис, А-02-23
+
+##Задание
+
+В-20
+Напишите инструкцию запоминания в переменной текущего времени в секундах с начала эпохи. Преобразуйте это время в Московское региональное время. Создайте кортеж с элементами – целыми числами от 27 до 147 через 15. Рассчитайте сумму элементов кортежа и определите значение отношения синуса этой суммы к корню квадратному из неё. Отобразите полученное значение в виде: «Результат = ХХХ» с округлением до 5 знаков после точки.
+
+##Решение
+
+```py
+import time
+import datetime
+import math
+current_time_seconds = time.time()
+print(f"Текущее время в секундах с начала эпохи: {current_time_seconds}")
+utc_time = datetime.datetime.utcfromtimestamp(current_time_seconds)
+moscow_time = utc_time + datetime.timedelta(hours=3)
+print(f"Московское время: {moscow_time.strftime('%Y-%m-%d %H:%M:%S')}")
+numbers_tuple = tuple(range(27, 148, 15))
+print(f"Кортеж чисел: {numbers_tuple}")
+tuple_sum = sum(numbers_tuple)
+print(f"Сумма элементов кортежа: {tuple_sum}")
+result =round(math.sin(tuple_sum) / math.sqrt(tuple_sum), 5)
+print(f"Результат = {result}")
+```
+
+##Вывод
+
+```py
+Текущее время в секундах с начала эпохи: 1760950212.7861652
+Московское время: 2025-10-20 11:50:12
+Кортеж чисел: (27, 42, 57, 72, 87, 102, 117, 132, 147)
+Сумма элементов кортежа: 783
+Результат = -0.02419
+```