Индивидуальное контрольное задание

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Ходюк Максим Романович
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('D:\\POAS\\Hodyuk\\Tema1\\')

TEMA1/report.md

@@ -0,0 +1,156 @@
+# Отчёт по Теме 1 Ходюк Максим Романович
+
+## Пункт 1
+Создал на рабочем диске в папке со своей фамилией папку Tema1 
+и записал туда файлы из архива Tema1.rar
+
+## Пункт 2
+Запустил программу-интерпретатор Python 3.11
+
+## Пункт 3
+Ввел инструкцию в диалоговом окне интерпретатора
+```
+>>> print('Hello')
+Hello
+```
+
+## Пункт 4
+Ввёл ещё одну инструкцию и в появившейся строке ввёл своё имя
+```
+>>> h=input('Your name=')
+Your name=Maxim
+```
+
+## Пункт 5
+Завершил работу интерпретатора
+```
+>>> exit()
+```
+
+## Пункт 6-7
+Открыл интерактивную графическую оболочку IDLE среды Python и изучил устройство главного командного окна среды
+
+## Пункт 8
+Ввёл инструкции настройки рабочего каталога среды
+```
+import os
+os.chdir('L:\III курс\А-1-23\HodyukMR\POAS\\Tema1\\')
+```
+## Пункт 9
+В меню Options Установил шрифт типа Arial CYR, 11 размер, высота начального окна 50 символов, ширина 100 символов, подкраска комментариев - коричневая
+
+## Пункт 10
+Открыл текстовый редактор среды и согдал программу [Pr0.py](Pr0.py) следующего содержания
+```
+## Программа по Теме 1 Ходюк Максим Романович
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('L:\III курс\А-1-23\HodyukMR\POAS\\Tema1\\')
+```
+
+При запуске программы с помощью меню Run module получаю следующий вывод
+```
+============ RESTART: L:/III курс/А-1-23/HodyukMR/POAS/Tema1/Pr0.py ============
+Hello
+Your name=Maxim
+```
+Использую другой вариант запуска программы:
+```
+import Pr0
+Hello
+Your name=Maxim
+```
+Также использую третий вариант запуска, с помощью горячей клавиши F5, вывод получаю такой же, как при первом варианте запуска
+
+## Пункт 11
+Запускаю на выполнение программу из файла [prb1.py](prb1.py)
+```
+import prb1
+Как Вас зовут? Максим
+Привет, Максим
+```
+
+## Пункт 12
+Открыл файл Pr0.cpython-311.рус, внутри находится байт-код - скомпилированная версия исходного кода python
+Компиляция программ в Python нужна для для преобразования кода на понятном человеку языке в байт-код, который затем выполняется виртуальной машиной Python
+
+## Пункт 13
+Скопировал все верно выполненные команды в отдельный файл
+
+## Пункт 14
+Изучил раздел помощи Help главного меню
+Ввёл инструкцию обращения к оперативной помощи по функции print()
+```
+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.
+
+(None, None)
+```
+
+Изучил возможность вызова оперативной помощи с помощью функциональной клафиши F1 и с помощью предложения Help главного меню
+
+## Пункт 15
+Выбрал предложения File - Open и открыл файл prb1.py и изучил возможность переключения между открытыми окнами используя предложения Window
+Сделал активным окно prb1.py и запустил на выполнение программу с помощью Run - Run Module
+```
+=========== RESTART: L:\III курс\А-1-23\HodyukMR\POAS\Tema1\prb1.py ==========
+Как Вас зовут? Максим
+Привет, Максим
+```
+
+Открыл Pr0.py и закрыл окна с помощью File - Close
+
+Используя инструкцию import запустил программу [tdemo_chaos.py](tdemo_chaos.py) на выполнение
+```
+import tdemo_chaos
+```
+
+Используя предложения Help - Turtle Demo - Examples - Clock запустил программу, которая выводит графическое представление - циферблат часов,
+на котором можно наблюдать движение стрелок часов
+В окне демонстраций есть много примеров, которые очень удобны, так как на основе примеров можно изучать графические возможности языка,
+а так же брать их за основу своих программ либо брать оттуда готовые части кода
+
+## Пункт 16
+Завершил работу со средой, используя предложения File - Exit

TEMA1/test.md

@@ -0,0 +1,15 @@
+# Индивидуальное контрольное задание по Теме 1
+Ходюк Максим Романович, А-01-23, 
+Вопрос №4
+## Вопрос
+Можно ли писать несколько инструкций в одной строке командного окна?
+
+## Ответ
+
+Да, в одной строке командного окна можно писать несколько инструкций, разграничивая их с помощью знака ;
+Например:
+```
+>>> a=13;b=15;c=14
+>>> print(a,b,c)
+13 15 14
+```

TEMA2/OKZ.py

@@ -0,0 +1,13 @@
+familia = 'Hodyuk'
+first=familia[0]
+import keyword
+sp_kw=keyword.kwlist
+sp_kw.remove('nonlocal')
+print(sp_kw)
+kort_nam=("Максим","Дима","Даня","Саня")
+type(kort_nam)
+kort_nam=kort_nam+("Лиза","Паша")
+kort_nam.count("Дима")
+dict_bas=dict(zip(["Строка","Список","Кортеж"],[familia,sp_kw,kort_nam]))
+print(dict_bas)
+print("\nПрограмма выполнена")

TEMA2/report.md

@@ -0,0 +1,771 @@
+# Отчёт по Теме 2 
+Ходюк Максим Романович, А-01-23
+
+## Пункт 1
+Запустил оболочку IDLE
+
+## Пункт 2
+Изучил простые объекты
+Создал переменные f1 f2 и присвоил им значения
+```
+f1=16; f2=3
+```
+Посмотрел значения созданных переменных двумя способами
+```
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+```
+
+Использовал функцию dir, чтобы узнать, какие обьекты существуют в данный момент в среде
+```
+dir()
+['annotations', 'builtins', 'doc', 'loader', 'name', 'package',
+ 'spec', 'f1', 'f2']
+```
+
+Та же функция используется для получения списка атрибутов любого объекта
+```
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+```
+
+Посмотрел классовую принадлежность ранее созданной переменной f2
+```
+type(f2)
+<class 'int'>
+```
+
+Удалил объекты с помощью функции del и убедился, что объектов больше нет в памяти 
+```
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
+```
+
+## Пункт 3
+Изучение правил именования объектов
+Задал значение в виде вещественного числа:
+```
+gg1=1.6
+```
+Задал значение в виде символьной строки
+```
+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']
+```
+Cохранил выведенный список в отдельную переменную
+```
+SpisKeyword=keyword.kwlist
+SpisKeyword
+['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', 'PythonFinalizationError', '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', '_', '_IncompleteInputError', '__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']
+```
+
+Самостоятельно изучил назначение и применил некоторые из встроенных функций
+```
+help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+
+help(len)
+Help on built-in function len in module builtins:
+
+len(obj, /)
+    Return the number of items in a container.
+
+help(max)
+Help on built-in function max in module builtins:
+
+max(...)
+    max(iterable, *[, default=obj, key=func]) -> value
+    max(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its biggest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the largest argument.
+
+help(min)
+Help on built-in function min in module builtins:
+
+min(...)
+    min(iterable, *[, default=obj, key=func]) -> value
+    min(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its smallest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the smallest argument.
+
+help(pow)
+Help on built-in function pow in module builtins:
+
+pow(base, exp, mod=None)
+    Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
+
+    Some types, such as ints, are able to use a more efficient algorithm when
+    invoked using the three argument form.
+
+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.
+
+help(sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new list containing all items from the iterable in ascending order.
+
+    A custom key function can be supplied to customize the sort order, and the
+    reverse flag can be set to request the result in descending order.
+
+help(sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+
+help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables, strict=False)
+ |
+ |  The zip object yields n-length tuples, where n is the number of iterables
+ |  passed as positional arguments to zip().  The i-th element in every tuple
+ |  comes from the i-th iterable argument to zip().  This continues until the
+ |  shortest argument is exhausted.
+ |
+ |  If strict is true and one of the arguments is exhausted before the others,
+ |  raise a ValueError.
+ |
+ |     >>> list(zip('abcdefg', range(3), range(4)))
+ |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+ |
+ |  Methods defined here:
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __next__(self, /)
+ |      Implement next(self).
+ |
+ |  __reduce__(self, /)
+ |      Return state information for pickling.
+ |
+ |  __setstate__(self, object, /)
+ |      Set state information for unpickling.
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+abs(-25)
+25
+len(SpisKeyword)
+35
+max(24,26,91,12341)
+12341
+min(12,-14,241,2)
+-14
+pow(2,4)
+16
+round(2.4231)
+2
+round(2.78)
+3
+sorted([1,2,6,3,7,4])
+[1, 2, 3, 4, 6, 7]
+sum([1,1,1,1,1])
+5
+A=[13,15,2,10]
+sum(A)
+40
+sp1 = ['cat','dog','horse']
+sp2 = [20,3,14]
+sp3 = ['home','cabin','stable']
+zipped = zip(sp1,sp2,sp3)
+list(zipped)
+[('cat', 20, 'home'), ('dog', 3, 'cabin'), ('horse', 14, 'stable')]
+```
+
+## Пункт 6
+Убедился, что малые и большие буквы при именовании объектов различаются
+```
+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=-1234567890 
+```
+Экспоненциальная форма записи вещественного числа
+```
+ff1=-8.9876e-12
+```
+Двоичное число
+```
+dv1=0b1101010
+```
+Восьмеричное число
+```
+vsm1=0o52765
+```
+шестнадцатиричное число
+```
+shest1=0x7109af6
+```
+
+Работа с комплексными числами
+```
+cc1=2-3j
+a=3.67; b=-0.45
+cc2=complex(a,b)
+```
+
+### Пункт 7.3
+Строка символов
+
+Создал строку символов, убедился, что строки можно заключать в апотрофы и двойные кавычки
+```
+ss1='Это - строка символов'
+ss1
+'Это - строка символов'
+ss1="Это - строка символов"
+ss1
+'Это - строка символов'
+```
+
+Применил внутри строки экранированные последовательности, создал следующую строку
+```
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+Создал ещё одну строку, выводимую на двух строках
+```
+ss1b= 'Меня зовут: \n Ходюк М. Р.'
+print(ss1b)
+Меня зовут: 
+ Ходюк М. Р.
+```
+
+Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек
+```
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Изучил возможность обращения к частям строки по индексам символов начиная с 0
+```
+ss1[0]
+'Э'
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+```
+
+При задании отрицательного шага, результатом выполнения будет часть строки, в которую символы будут взяты в обратной последовательности
+```
+ss1[17:3:-2]
+'омсаот '
+```
+Также можно вместо 17 использовать индекс -4, и получить такой же результат
+```
+ss1[-4:3:-2]
+'омсаот '
+```
+Убедился, что строка является неизменяемым объектом
+```
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#78>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+```
+Однако строку можно изменить, переопределив её
+```
+ss1=ss1[:4]+'='+ss1[5:]
+ss1
+'Это = строка символов'
+```
+На основе ранее созданной строки ss1b создал обьекты с разными срезами исходной строки
+```
+ss1b[:15]
+'Меня зовут: \n Х'
+ss1c=ss1b[:3]+'12345'+ss1b[5:]
+ss1c
+'Мен12345зовут: \n Ходюк М. Р.'
+```
+
+Задал несколько объектов разных типов
+```
+Flag = False
+type(Flag)
+<class 'bool'>
+Stroka="СТРОКА"
+A=453
+B=4231
+complex(A,B)
+(453+4231j)
+Flag
+False
+Stroka
+'СТРОКА'
+```
+
+## Пункт 8
+Изучение более сложных типов объектов
+
+### Пункт 8.1
+Списки
+
+Создал примеры списков:
+```
+spis1=[111,'Spisok',5-9j]
+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
+```
+Изучил возможность добавления элементов в списки с помощью метода append и с помощью конкатенации
+```
+spis1.append('New item')
+spis1+['New item']
+[111, 'Список', (5-9j), 'New item', 'New item']
+```
+В последней инструкции объект только выводится, но не сохраняется
+```
+spis1
+[111, 'Список', (5-9j), 'New item']
+```
+Добавил в конец списка spis1 строку ss1b
+```
+spis1.append(ss1b)
+spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Ходюк М. Р.']
+```
+
+Изучил возможность удаления элемента
+```
+spis1.pop(1)
+'Список'
+spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Ходюк М. Р.']
+```
+Метод удалил из списка элемент с индексом 1
+
+Самостоятельно изучил другие методы списков и применил их
+```
+help(spis.insert)
+Help on built-in function insert:
+
+insert(index, object, /) method of builtins.list instance
+    Insert object before index.
+
+spis1.insert(3,'home')
+spis1
+[111, (5-9j), 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.']
+
+help(spis.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.
+
+spis23=[1,2,3,1]
+spis23.remove(1)
+spis23
+[2, 3, 1]
+
+help(spis.extend)
+Help on built-in function extend:
+
+extend(iterable, /) method of builtins.list instance
+    Extend list by appending elements from the iterable.
+
+spis23.extend(spis1)
+spis23
+[2, 3, 1, 111, (5-9j), 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.']
+
+help(spis.clear)
+Help on built-in function clear:
+
+clear() method of builtins.list instance
+    Remove all items from list.
+
+spis24=[1,2,3,4,5]
+spis24
+[1, 2, 3, 4, 5]
+spis24.clear()
+spis24
+[]
+
+spis24=[1,2,8,3,6,4,12,7]
+spis24.sort()
+spis24
+[1, 2, 3, 4, 6, 7, 8, 12]
+
+spis24.reverse()
+spis24
+[12, 8, 7, 6, 4, 3, 2, 1]
+
+help(spis.copy)
+Help on built-in function copy:
+
+copy() method of builtins.list instance
+    Return a shallow copy of the list.
+
+spis25=spis24.copy()
+spis25
+[12, 8, 7, 6, 4, 3, 2, 1]
+
+help(spis.count)
+Help on built-in function count:
+
+count(value, /) method of builtins.list instance
+    Return number of occurrences of value.
+
+stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+stup.count(0)
+2
+
+help(spis.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.
+
+stup.index(1)
+2
+```
+
+Списки могут быть вложенными
+```
+spis2=[spis1,[4,5,6,7]]
+```
+Обратился к элементам вложенного списка и изменение их
+```
+spis2[0][1]
+(5-9j)
+spis2[0][1]=78
+spis2
+[[111, 78, 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.'], [4, 5, 6, 7]]
+```
+При изменении элементов вложенного списка изменяется и сам список, который был вложен в другой
+```
+spis1
+[111, 78, 'New item', 'home', 'Меня зовут: \n Ходюк М. Р.']
+```
+Чтобы spis1 не изменялся при изменении spis2, можно создать их следующим образом
+```
+spis1 = [13,'A',14,'cat','dog']
+spis1
+[13, 'A', 14, 'cat', 'dog']
+spis2 = [list(spis1),'uuuuu',731]
+spis2[0][1]
+'A'
+spis2[0][1]='C'
+spis2
+[[13, 'C', 14, 'cat', 'dog'], 'uuuuu', 731]
+spis1
+[13, 'A', 14, 'cat', 'dog']
+```
+Создал свой объект список
+```
+spisok=[12, 'Strocka', Flag, spis25]
+spisok
+[12, 'Strocka', False, [12, 8, 7, 6, 4, 3, 2, 1]]
+```
+
+### Пункт 8.2
+Объект-кортеж
+Изучил примеры операций с кортежами:
+Создание:
+```
+kort1=(222,'Kortezh',77+8j)
+```
+Переопределение(т.к.кортеж является неизменяемым объектом)
+```
+kort1= kort1+(1,2)
+kort1= kort1+(ss1b,)
+kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Ходюк М. Р.')
+```
+
+Переопределил кортеж с удалением комплексного значения
+```
+kort2=kort1[:2]+kort1[3:]
+kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Ходюк М. Р.')
+```
+Изучил важные методы кортежей
+Получение индекса заданного элемента(index) и подсчёт числа вхождений заданного элемента(count)
+```
+kort1.index(2)
+4
+kort1.count(222)
+1
+```
+Попробовал операцию изменения элемента кортежа и убедился в невозможности его изменения
+```
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#174>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+Самостроятельно создал кортеж:
+```
+kortej=(12, 'Strocka', Flag, spis25)
+kortej
+(12, 'Strocka', False, [12, 8, 7, 6, 4, 3, 2, 1])
+```
+
+### Пункт 8.3
+Словари
+Пример создания словаря и обращения к его элементам по ключам
+```
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Orel']
+56
+```
+
+Пример пополнения словаря
+
+```
+dic1['Pskov']=78
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+Применил методы получения списка ключей и значений в словаре:
+```
+dic1.keys()
+dict_keys(['Saratov', 'Orel', 'Vologda', 'Pskov'])
+dic1.values()
+dict_values([145, 56, 45, 78])
+```
+
+Применил функцию sorted для получения списков, упорядоченные по ключам/значениям
+```
+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'
+```
+
+Создал более сложный словарь с использованием функции dict
+```
+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 Ходюк М. Р.'}
+```
+
+Создал ещё один словарь с использованием функций dict и zip
+```
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Ходюк М. Р.'}
+```
+
+Создал объект-кортеж с 7 элементами и список с 5 элементами, и попробовал создать из них словарь:
+```
+kort801 = (1, 48, 'NICOLAI', '67W', 'Батон', 'name', 1453)
+spisocek = [1,4553, 'Maxim',4,6]
+dic6=dict(zip(kort801, spisocek))
+dic6
+{1: 1, 48: 4553, 'NICOLAI': 'Maxim', '67W': 4, 'Батон': 6}
+```
+Как можно заметить, словарь создался с 5ю элементами, из чего можно сделать вывод, что при неодиноковом количестве задаваемых ключей и значений, словарь создастся с кол-вом 
+элементов, равным меньшему их кол-ву
+
+Пример словаря с описанием состава студентов, обучающихся на АВТИ:
+```
+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={7,'Ronaldo',10,'Messi',18,'Bruno'}
+mnoz2
+{18, 7, 'Bruno', 10, 'Ronaldo', 'Messi'}
+len(mnoz2)
+6
+mnoz2.add('Pele')
+mnoz2
+{18, 'Pele', 7, 'Bruno', 10, 'Ronaldo', 'Messi'}
+mnoz2.remove('Messi')
+mnoz2
+{18, 'Pele', 7, 'Bruno', 10, 'Ronaldo'}
+```
+
+## Пункт 9
+Закончил сеанс работы с IDLE

TEMA2/task.md

@@ -0,0 +1,68 @@
+# Общее контрольное задание Тема 2 Ходюк
+Скрипт для ОКЗ в файле [OKZ.py](OKZ.py)
+
+## Пункт 1
+Создал переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+```
+familia = 'Hodyuk'
+```
+
+## Пункт 2
+Создал переменную со значением, совпадающим с первой буквой из строки familia
+```
+first=familia[0]
+first
+'H'
+```
+
+## Пункт 3
+Создание переменной sp_kw со списком всех ключевых слов языка Python
+```
+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']
+```
+
+## Пункт 4
+Удалил из списка sp_kw значение 'nonlocal' и вывел список
+```
+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']
+```
+
+## Пункт 5
+Создал кортеж kort_nam с 4 именами: моим, и еще 3-х студентов моей группы
+```
+kort_nam=("Максим","Дима","Даня","Саня")
+```
+Вывел тип получившегося объекта
+```
+type(kort_nam)
+<class 'tuple'>
+```
+
+## Пункт 6
+Добавил в кортеж из предыдущего пункта ещё 2 имени
+```
+kort_nam=kort_nam+("Лиза","Паша")
+kort_nam
+('Максим', 'Дима', 'Даня', 'Саня', 'Лиза', 'Паша')
+```
+
+## Пункт 7
+Написал инструкцию для подсчёта количества присутствия имени "Дима" в кортеже
+```
+kort_nam.count("Дима")
+1
+```
+
+## Пункт 8
+Создал словарь, в котором в качестве ключей задал русские названия типов переменных,
+созданных ранее в ОКЗ, и в качестве значений - переменные этих типов
+```
+dict_bas=dict(zip(["Строка","Список","Кортеж"],[familia,sp_kw,kort_nam]))
+dict_bas
+{'Строка': 'Hodyuk', 'Список': ['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'], 'Кортеж': ('Максим', 'Дима', 'Даня', 'Саня', 'Лиза', 'Паша')}
+```

TEMA2/test.md

@@ -0,0 +1,23 @@
+# Индивидуальное контрольное задание по Теме 2
+Ходюк Максим Романович, А-01-23
+
+## Задание
+Вариант 12
+Предполагается выполнить инструкцию
+ fg={'a':23,'b':45,'c':-12}
+К какому классу будет относиться созданный объект? Напишите инструкцию расчета суммы значений первого и третьего элементов.
+
+## Решение
+Созданный объект fg будет относиться к классу dict - словарь
+```
+fg={'a':23,'b':45,'c':-12}
+type(fg)
+<class 'dict'>
+```
+
+Инструкция расчёта суммы значений первого и третьего элементов
+```
+sum([fg['a'],fg['c']])
+11
+```
+

TEMA3/report.md

@@ -0,0 +1,704 @@
+# Отчёт по теме 3 
+Ходюк Максим Романович, А-01-23
+
+# 2. Преобразование простых базовых типов объектов
+## 2.1. Преобразование в логический тип с помощью функции bool(<Объект>).
+Создал 4 переменные логического типа из объектов других типов:
+```    
+logiz1=bool(56)
+logiz2=bool(0)
+logiz3=bool("Beta")
+logiz4=bool("")
+```
+Результат:
+```
+logiz1
+True
+logiz2
+False
+logiz3
+True
+logiz4
+False
+```
+
+## 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]).
+Попробовал применить примеры использования данной функции:
+```
+tt1=int(198.6)
+tt1
+198
+tt2=int("-76")
+tt2
+-76
+tt3=int("B",16)
+tt3
+11
+tt4=int("71",8)
+tt4
+57
+tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#17>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+При применении последней инструкции выдало диагностическое сообщение, потому что функция int при передавании в неё строки ожидает увидеть там целое число, а "98.76" содержит десятичную точку, из-за чего функция int не может её преобразовать
+
+
+Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>).
+Примеры:
+flt1=float(789)
+flt2=float(-6.78e2)
+flt3=float("Infinity")
+flt4=float("-inf")
+flt1
+789.0
+flt2
+-678.0
+flt3
+inf
+flt4
+-inf
+
+## 2.3. Преобразование десятичных чисел в другие системы счисления
+```
+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})
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+## Преобразование элементов объекта в список с помощью функции 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']
+```
+В последней инструкции из словаря в список попали ключи, чтобы создать список значений, применил следующую инструкцию
+```
+spis3=list({"A":1,"B":2,"C":9}.values())
+spis3
+[1, 2, 9]
+```
+
+## 3.3.	Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>).
+Примеры преобразований:
+```
+kort7=tuple('Строка символов')
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8=tuple(spis2)
+kort8
+(23, 12, 78)
+kort9=tuple({"A":1,"B":2,"C":9})
+kort9
+('A', 'B', 'C')
+```
+
+## 3.4. Удаление объектов.
+Удалил объекты и убедился в их отсутствии в оперативной памяти
+```
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#62>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#63>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+
+Создал строку со своей фамилией и инициалами, преобразовал её в список,затем в кортёж, а затем в строку:
+```    
+strr="KhoduykMR"
+lstrr=list(strr)
+lstrr
+['K', 'h', 'o', 'd', 'u', 'y', 'k', 'M', 'R']
+klstrr=tuple(lstrr)
+klstrr
+('K', 'h', 'o', 'd', 'u', 'y', 'k', 'M', 'R')
+strr2=str(klstrr)
+strr2
+"('K', 'h', 'o', 'd', 'u', 'y', 'k', 'M', 'R')"
+```
+
+# 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
+```
+Проверил тип объекта а
+```
+type(a)
+<class 'float'>
+```
+
+## 4.4.	 Деление с округлением вниз (//).
+```
+b=178//45
+b
+3
+c=-24.6//12.1
+c
+-3.0
+```
+Попробовал смешанные комбинации типов чисел в этой операции
+```
+178//12.1
+14.0
+-24.6//15
+-2.0
+```
+
+## 4.5.	 Получение остатка от деления (%).
+```
+148%33
+16
+12.6%3.8
+1.2000000000000002
+```
+Попробовал применить в этой операции смешанные типы чисел
+```
+148%3.8
+3.6000000000000068
+12.6%33
+12.6
+12.6%3
+0.5999999999999996
+```
+
+## 4.6.	 Возведение в степень (**).
+```
+14**3
+2744
+e=2.7**3.6
+e
+35.719843790663525
+```
+Попробовал смешанные типы чисел и в операции возведения в степень
+```
+14**3.6
+13367.830445904418
+2.7**3
+19.683000000000003
+```
+
+Попробовал применить операции, представленные в пункте 4, с участием комплексных чисел
+```
+14**(3+8j)
+(-1751.1118980727824+2112.6152324614004j)
+(3+8j)*14
+(42+112j)
+(3+8j)/(15+883j)
+(0.009115107563141576-0.0032426652169341747j)
+(3+8j)//(15+883j)
+Traceback (most recent call last):
+  File "<pyshell#98>", line 1, in <module>
+    (3+8j)//(15+883j)
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+(3+8j)%(15+883j)
+Traceback (most recent call last):
+  File "<pyshell#99>", line 1, in <module>
+    (3+8j)%(15+883j)
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+К комплексным числам можно применить все действия, кроме деления с округлением и получения остатка от деления
+
+# 5. Операции с двоичными представлениями целых чисел.
+## 5.1. Двоичная инверсия (~).
+При применении двоичной инверсии значение каждого бита в представлении числа меняется на противоположное:
+```
+dv1=9
+dv2=~dv1
+dv2
+-10
+```
+
+## 5.2.	 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+При применении данной команды результат - это число в десятичной системе счисления, которое в двоичной системе счисления представляется как результат побитового совпадения разрядов(то есть 1 в разряде получится только если в этом разряде у обоих сравниваемых чисел стоит 1)
+```
+7&9 #111 и 1001 = 0001
+1
+7&8 #111 и 1000 = 0000
+0
+```
+
+## 5.3. Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел
+Результат также как в предыдущем случае десятичное число, но на этот раз в двоичном представлении у числа будет 0 только если у обоих сравниваемых чисел в этом разряде 0
+```
+7|9
+15
+7|8
+15
+14|5
+15
+```
+
+## 5.4.	Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел
+В данной операции получаем 0, если оба сравниваемых разряда имеют одинаковые значения
+```
+14^5
+11
+```
+
+## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+Применение:
+```
+h=14
+g=h<<2
+g1=h>>1
+g2=h>>2
+g
+56
+g1
+7
+g2
+3
+```
+Создал двоичное число с 11 знаками и попробовал к нему применить различные операции
+```
+hh=1924 #11110000100
+gg=hh<<5
+gg
+61568
+gg1=hh>>6
+gg1
+30
+```
+
+# 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
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+```
+Применил примеры: Создание списка со 100 отсчётами сигнала-ступеньки
+```
+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='Система автоматического управления'
+stroka
+'Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку','-']*3
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+
+## 6.4.	Подстановка значений в строку с помощью оператора «%»
+Применил пример 1:
+```
+stroka='Температура = %g %s  %g'
+stroka
+'Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+Применил пример 2:
+```
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka
+'Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+# 7.Оператор присваивания
+## 7.1.	 Обычное присваивание значения переменной (=)
+```
+zz=-12
+zz
+-12
+```
+## 7.2.	Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```
+zz+=5
+zz
+-7
+zz-=3
+zz
+-10
+```
+Проверил работу сочетания знаков (+=) на строках
+```
+stroka='Система'
+stroka
+'Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+```
+Для строк эта операция означает конкатенацию текущего значения с заданным дополнением
+
+## 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+```
+Попробовал данную операцию на строке: она означает повторение текущего значения заданное количество раз
+```
+stroka*=2
+stroka
+'Система регулированияСистема регулирования'
+```
+
+## 7.4. Самостоятельное изучение операций (//=), (%=), (**=)
+```
+zz//=2
+zz
+-13.0
+zz%=3
+zz
+2.0
+zz**=4
+zz
+16.0
+```
+
+## 7.5. Множественное присваивание
+```
+w=v=10
+w;v
+10
+10
+n1,n2,n3=(11,-3,'all')
+n1;n2;n3
+11
+-3
+'all'
+```
+Самостоятельно проверил,можно ли вместо кортежа справа в последней инструкции использовать строку, список, словарь, множество
+Список:
+```
+k1,k2,k3=[11,-3,'gfgdg']
+k1;k2;k3
+11
+-3
+'gfgdg'
+```
+Строка:
+```
+s1,s2,s3='123'
+s1;s2;s3
+'1'
+'2'
+'3'
+```
+Словарь:
+```
+d1,d2,d3={'Saratov':145, 'Orel':56, 'Vologda':45}
+d1;d2;d3
+'Saratov'
+'Orel'
+'Vologda'
+```
+Множество:
+```
+m1,m2,m3={'двигатель','датчик','линия связи'}
+m1;m2;m3
+'двигатель'
+'линия связи'
+'датчик'
+```
+# 8. Логические операции
+## 8.1.	 Операции сравнение
+Придумал примеры использования операций сравнения и сравнил ранее созданные переменные w и v
+```
+w==v
+True
+w>v
+False
+w>=v
+True
+12>2
+True
+1<7
+True
+w!=v
+False
+```
+
+## Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in).
+Применил операции со множеством:
+```
+mnoz1={'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+```
+Применил операции со словарём:
+```
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+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).
+Использовал приведённый в методичке пример  сложного логического выражения и придумал 2 своих
+```
+a=17
+b=-6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+((w==v) or (18>234)) and ('pen' in mnoz1) and not (123<1) and (('M' in 'Messi') or ('M' in 'Nicolay'))
+True
+not (dct1['Depart'][1] == 'MM') and not (163.5>163.6) and ('Vologda' in dic1)
+True
+```
+
+## 8.4.	Проверка ссылок переменных на один и тот же объект (is).
+Проверил, что при одновременном присваивании переменные ссылаются на один и тот же объект
+```
+w=v=10
+w is v
+True
+```
+После присвоил переменным одинаковые значения, но не одновременным присваиванием,поэтому переменные просто содержат одинаковые значения, но не ссылаются на одну и ту же "ячейку" в опертивной памяти
+```
+w1=['A','B']
+w1
+['A', 'B']
+v1=['A','B']
+w1 is v1
+False
+```
+
+# 9.Операции с объектами, выполняемые с помощью методов.
+Применил функцию dir() для получения списка атрибутов объекта
+```
+stroka='Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+## 9.1.	Методы для работы со строками.
+Рассмотрел и применил примеры таких методом
+Возвращение позиции первого вхождения контекста или -1 если он не встречается:
+```
+stroka.find('пр')
+5
+```
+Подстчет числа вхождений подстрки в строку
+```
+stroka.count("с")
+4
+```
+Замена первого вхождения указанной подстроки на вторую подстроку
+```
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+```
+Возвращение списка подстрок с заданным разделителем:
+```
+spis22=stroka.split(' ')
+```
+Возвращение строки со всеми заглавными буквами:
+```
+stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+```
+Создание строки, собранной из элементов списка:
+```
+stroka3=" ".join(spis22)
+```
+Создание кортежей с результатами поиска "с" слева и "с" справа:
+```
+stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+```
+
+Изучение метода format
+Создал строку и вместо фигурных скобок вставил значения с помощью метода format
+```
+strk1='Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+```
+Создал вторую строку, но на этот раз поставил индексы, определяющие порядок использования аргументов формата
+```
+strk2='Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+```
+Создал третью строкус именами аргументов-вставок, ис помощью метода формат вставил в строку значения по именами
+```
+strk3='Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)
+```
+
+## 9.2.	Методы для работы со списками.
+Создал список spsk с 5 элементами, применил к нему следующие методы:
+```
+spsk=[1,2,'ggwp', 'ss', 'Roman'] 
+spsk
+[1, 2, 'ggwp', 'ss', 'Roman']
+spsk.pop(2)     
+'ggwp'
+spsk.append('c')
+spsk    
+[1, 2, 'ss', 'Roman', 'c']
+spsk.insert(2,'a')   
+spsk
+[1, 2, 'a', 'ss', 'Roman', 'c']
+spsk.count('a')    
+1
+```
+Метод pop() удаляет из списка элемент с заданным индексом, метод append() добавляет новый элемент в конец списка
+insert() вставляет в список перед заданным индексом заданный элемент, а count() подсчитывает число вхождений элемента в список
+
+## 9.3 Методы для работы с кортежами
+Применил к ранее созданному кортежу методы index и count, первый возвращает индекс первого вхождения элемента в кортёж, а второй подсчитывает число вхождений элемента в кортёж
+```
+kort1.index(222)    
+0
+kort1.count(222)     
+1
+```
+Методов pop, append и insert у кортежей нет, так как это неизменяемые объекты
+
+## 9.4. Методы словарей и множеств
+Применил методы для добавления и удаления элементов из множеств:
+```
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1.add('реле')    
+mnoz1    
+{'датчик', 'линия связи', 'микропроцессор', 'реле', 'двигатель'}
+mnoz1.remove('линия связи')     
+mnoz1    
+{'датчик', 'микропроцессор', 'реле', 'двигатель'}
+```
+
+Создал словарь и применил к нему методы для: получения списка ключей, получения списка значений, и получения списка из пар ключ/значение
+```
+student = {
+    "name": "Анна",
+    "age": 20,
+    "course": "Информатика",
+    "grades": [4, 5, 4, 3],
+    "city": "Москва"
+}    
+student.keys()    
+dict_keys(['name', 'age', 'course', 'grades', 'city'])
+student.values()    
+dict_values(['Анна', 20, 'Информатика', [4, 5, 4, 3], 'Москва'])
+student.items()    
+dict_items([('name', 'Анна'), ('age', 20), ('course', 'Информатика'), ('grades', [4, 5, 4, 3]), ('city', 'Москва')])
+removed_city = student.pop("city")    
+removed_city
+'Москва'
+```
+
+# 10. Сохранил отчёт работы и закончил сеанс работы с IDLE

TEMA3/task.md

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

TEMA3/test.md

@@ -0,0 +1,46 @@
+# Индивидуальное контрольное задание: тест по модулю 1
+Ходюк Максим Романович А-01-23
+## Задание
+M1_1
+1) Почему текстовый редактор оболочки IDLE предпочтителен при написании программ на языке Python?
+
+2) Создайте объект - символьную строку с текстом данного предложения. Напишите инструкции, заменяющие дефис, точку и запятую на знаки пробелов.
+
+3) Напишите инструкцию создания списка с отдельными словами из строки символов. Подсчитайте число слов в списке.
+
+4) Напишите инструкции создания  списка с целочисленными элементами, значения которых равны числу символов в соответствующих словах из первого списка.
+
+5) Подсчитайте среднюю длину слов в рассматриваемом предложении.
+
+### Решение
+1)Текстовый редактор оболочки IDLE предпочтителен при написании программ на языке Python, так как в нём можно создавать скрипты(файлы с расширением .py), которые не получится создать при работе с консольным окном, а также скрипты можно запускать много раз без повторного ввода команд
+
+2)
+```
+string = "Создайте объект - символьную строку с текстом данного предложения. Напишите инструкции, заменяющие дефис, точку и запятую на знаки пробелов."
+string = string.replace('-',' ')
+string = string.replace('.',' ')
+string = string.replace(',',' ')
+string
+'Создайте объект   символьную строку с текстом данного предложения  Напишите инструкции  заменяющие дефис  точку и запятую на знаки пробелов '
+```
+3)
+```
+spisW=string.split()
+spisW
+['Создайте', 'объект', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения', 'Напишите', 'инструкции', 'заменяющие', 'дефис', 'точку', 'и', 'запятую', 'на', 'знаки', 'пробелов']
+len(spisW)
+18
+```
+4)
+```
+spis2=[len(word) for word in spisW]
+spis2
+[8, 6, 10, 6, 1, 7, 7, 11, 8, 10, 10, 5, 5, 1, 7, 2, 5, 8]
+```
+5)
+```
+srznac=sum(spis2)//len(spis2)
+srznac
+6
+```

TEMA4/report.md

@@ -0,0 +1,449 @@
+# Отчёт по Теме 4
+Ходюк Максим Романович, А-01-23
+
+## 2. Изучение стандартных функций модуля builtins
+### 2.1. Функция round
+Использовал функцию на следующих примерах:
+```    
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+```
+Как можно заметить, второй аргумент означает количество цифр в дробной части, до которой округляется число, и при введении этого аргумента результат получается типа float
+Если этот аргумент не задать:
+```    
+round(123.456)
+123
+type(round(123.456))
+<class 'int'>
+```
+То число округлится до целых и будет типа int
+
+### 2.2. Функция range
+Пример:
+```    
+gg=range(76,123,9)
+gg
+range(76, 123, 9)
+```
+Эта инструкция создает, так называемый, «итерируемый объект» класса range. Чтобы увидеть получившуюся последовательность чисел, его надо преобразовать, например, в список, обычным способом:
+```    
+list(gg)
+[76, 85, 94, 103, 112, 121]
+```
+Если вызвать эту функцию с одним аргументом, то создатся диапазон от 0 до заданного числа с шагом 1:
+```    
+range(23)
+range(0, 23)
+list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+### 2.3. Функция zip
+Создал обьект список с именем qq, после чего применил функцию zip к qq и ранее созданному списку gg
+```
+qq = ['Hodyuk','Kovalenko','Ivanov', 'Lykova']
+ff=zip(gg,qq)
+```
+Как и в range здесь получается «итерируемый  объект» класса zip, поэтому чтобы увидеть содержимое создал кортёж
+```
+tuple(ff)
+((76, 'Hodyuk'), (85, 'Kovalenko'), (94, 'Ivanov'), (103, 'Lykova'))
+```
+Элементов в полученном кортеже 4, так как из аргументов функции zip меньшую длину имел список qq, равную 4
+
+Проверил, можно ли обратиться к полученному обьекту по индексу:
+```    
+ff[1]
+Traceback (most recent call last):
+  File "<pyshell#14>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable
+```
+К объекту zip нельзя обращаться по индексу
+
+### 2.4. Функция eval
+Применил пример использования, отобразил результат(переменную dan):
+```    
+fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=13
+dan
+-91.0
+```
+### 2.5 Функция exec
+Функция выполняет совокупность инструкций на языке Python, например:
+```    
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+### 2.6. Самостоятельное изучение других стандартных функций
+Применил ранее известные функции:
+```    
+abs(dan)
+91.0
+pow(2,4)
+16
+max([1,3,6,1])
+6
+min([1,16, -591, 0])
+-591
+sum([1,2,3,4])
+10
+len(qq)
+4
+```
+Изучил функции divmod и map, и применил их
+```
+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(15,4)
+(3, 3)
+divmod(17,2)
+(8, 1)
+help(map)
+Help on class map in module builtins:
+
+class map(object)
+ |  map(function, iterable, /, *iterables)
+ |
+ |  Make an iterator that computes the function using arguments from
+ |  each of the iterables.  Stops when the shortest iterable is exhausted.
+ |
+ |  Methods defined here:
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __next__(self, /)
+ |      Implement next(self).
+ |
+ |  __reduce__(self, /)
+ |      Return state information for pickling.
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+
+map(len,qq)
+<map object at 0x000002694337F220>
+list(map(len,qq))
+[6, 9, 6, 6]
+```
+## 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']
+```
+Применил некоторые функции из модуля, включая factorial
+```
+math.factorial(5)
+120
+math.sin(math.pi/2)
+1.0
+math.acos(math.sqrt(3)/2)
+0.5235987755982989
+help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+math.degrees(math.pi/2)
+90.0
+math.radians(90)
+1.5707963267948966
+math.log(15)
+2.70805020110221
+math.log(8,2)
+3.0
+math.exp
+<built-in function exp>
+math.log10(100)
+2.0
+math.ceil(25.181926)
+26
+math.floor(25.181915)
+25
+```
+После применения всех необходимых функций написал инструкцию для вычисления значения выражения sin(2π/7+e0.23 )
+```
+math.sin((2*math.pi/7)+math.exp(0.23))
+0.8334902641414562
+```
+## 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']
+```
+Изучил функцию seed, задающую случайное начальное состояние для псевдослучайных чисел:
+```    
+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 (равномерно распределенное случайное число), uniform (равномерно распределенное случайное число), randint (случайные целые числа), gauss (нормально распределенное случайное число), randint (случайное целое число), choice (случайный выбор из совокупности), shuffle (случайная перестановка элементов списка), sample (случайный выбор подмножества элементов), betavariate(случайное число с бета-распределением), gammavariate(случайное число с гамма-распределением).
+```
+random.random()
+0.8415073202155561
+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.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = (a + b) / 2
+        Var[X] = (b - a) ** 2 / 12
+
+random.uniform(4,13)
+12.083229701608595
+random.randint(1,4)
+1
+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.
+
+help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu=0.0, sigma=1.0) 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.9495673914994565
+random.gauss(mu=3,sigma=2)
+3.7978130361127436
+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([1,3,5,2,1,5,7,8,9])
+5
+random.shuffle([1,3,5,2,1,5,7,8,9])
+aa=random.shuffle([1,3,5,2,1,5,7,8,9])
+aa
+help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x) method of random.Random instance
+    Shuffle list x in place, and return None.
+
+aa=[1,3,5,2,1,5,7,8,9]
+random.shuffle(aa)
+aa
+[5, 1, 7, 5, 3, 8, 9, 1, 2]
+random.sample(aa,4)
+[1, 3, 5, 5]
+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(13,2)
+0.9768043355909166
+random.gammavariate(4,6)
+6.383419053564046
+```
+Создал список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям:
+```
+spis=[random.uniform(4,13),random.gauss(mu=3,sigma=2),random.betavariate(13,2),random.gammavariate(4,6)]
+spis
+[8.823603554451614, 0.9688486416723059, 0.8365506057159969, 10.812180117279787]
+```
+## Модуль 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']
+```
+Изучил функцию time, возвращающую время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
+```
+c1=time.time()
+c2=time.time()-c1
+```
+Получил в переменную dat "Всемирное координатное время", и научился обращаться к компонентам получившегося объекта:
+```
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=7, tm_min=19, tm_sec=44, tm_wday=0, tm_yday=286, tm_isdst=0)
+dat.tm_mon
+10
+dat.tm_mday
+13
+dat.tm_wday
+0
+```
+Получил местное время функцией localtime()
+```
+time.localtime()
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=10, tm_min=21, tm_sec=49, tm_wday=0, tm_yday=286, tm_isdst=0)
+```
+Изучил функции из модуля time:asctime (преобразование представления времени из кортежа в строку) , ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку), sleep (прерывание работы программы на заданное время), mktime (преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи).
+```
+help(time.asctime)
+Help on built-in function asctime in module time:
+
+asctime(...)
+    asctime([tuple]) -> string
+
+    Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
+    When the time tuple is not present, current time as returned by localtime()
+    is used.
+
+time.asctime(time.localtime())
+'Mon Oct 13 10:23:33 2025'
+help(time.ctime)
+Help on built-in function ctime in module time:
+
+ctime(...)
+    ctime(seconds) -> string
+
+    Convert a time in seconds since the Epoch to a string in local time.
+    This is equivalent to asctime(localtime(seconds)). When the time tuple is
+    not present, current time as returned by localtime() is used.
+
+time.ctime(156323)
+'Fri Jan  2 22:25:23 1970'
+time.ctime(1)
+'Thu Jan  1 03:00:01 1970'
+help(time.sleep)
+Help on built-in function sleep in module time:
+
+sleep(object, /)
+    sleep(seconds)
+
+    Delay execution for a given number of seconds.  The argument may be
+    a floating-point number for subsecond precision.
+
+time.sleep(3)
+time.mktime(time.localtime())
+1760340425.0
+```
+Преобразование из секунд в местное время также осуществляется функцией localtime:
+```    
+time.localtime(c1)
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=10, tm_min=19, tm_sec=23, tm_wday=0, tm_yday=286, tm_isdst=0)
+```
+## Графические функции
+Импортировал модуль pylab из пакета matplotlib, после чего создал списки и научился создавать графики
+```
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000002695C316850>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+Сохранил получившийся график в файле Figure0.png
+
+Рассмотрел возможность создания нескольких графиков на одном экране
+```
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000002695D9BF110>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000002695D9BF250>]
+pylab.show()
+```
+Сохранил в файл с названием Figure1.png
+
+Построил круговую диаграмму, сохранил результат в файл Figure2.png
+```
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000002695C2FD940>, <matplotlib.patches.Wedge object at 0x000002695D2E0B90>, <matplotlib.patches.Wedge object at 0x000002695D2E0F50>, <matplotlib.patches.Wedge object at 0x000002695D2E11D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+```
+Изучил функции bar и hist, результаты сохранил в файлы Figure3.png и Figure4.png соответственно
+```
+pylab.bar(X1,X1)
+<BarContainer object of 5 artists>
+pylab.show()
+pylab.hist(X2,bins=3)
+(array([2., 1., 2.]), array([ 5.        ,  7.66666667, 10.33333333, 13.        ]), <BarContainer object of 3 artists>)
+pylab.show()
+```
+## 8.Статистика
+Импортировал модуль statistics и применил 3 функции из этого модуля
+```
+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.mean(X1)
+8.6
+statistics.correlation(X1,X2)
+-0.3939192985791677
+statistics.covariance(X1,X2)
+-3.0
+```

TEMA4/task.md

@@ -0,0 +1,81 @@
+# Общее контрольное задание по Теме 4
+Ходюк Максим Романович А-01-23
+## Задание
+•	Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+
+•	Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+•	Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+•	Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+•	Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+•	Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+### Решение
+```
+import cmath
+divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+(8.0, 2.6000000000000014)
+kort = divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+kort
+(8.0, 2.6000000000000014)
+```
+
+```
+MosTime=time.localtime()
+MosTime
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=11, tm_min=17, tm_sec=51, tm_wday=0, tm_yday=286, tm_isdst=0)
+string='Текущее время по МСК: часы - {}, минуты-{}'
+string=string.format(MosTime.tm_hour,MosTime.tm_min)
+string
+'Текущее время по МСК: часы - 11, минуты-17'
+```
+
+```
+spis = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
+random.sample(spis,3)
+['Wednesday', 'Friday', 'Tuesday']
+```
+
+```
+random.choice(range(14,33,3))
+29
+```
+
+```
+N=random.gauss(15,4)
+N
+20.856697509675403
+N=round(N)
+```
+
+```
+import string
+alf=string.ascii_lowercase
+alf
+'abcdefghijklmnopqrstuvwxyz'
+ALF=list(alf)
+ALF
+['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']
+spis1=list(random.choice(ALF)for i in range(N))
+spis1
+['d', 'i', 'g', 'g', 't', 'm', 'c', 'y', 'z', 'm', 'w', 'd', 'j', 'h', 'q', 't', 'k', 'v', 'i', 'r', 'w']
+```
+
+```
+import time
+MosTime1=time.localtime()
+MosTime1
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=42, tm_sec=27, tm_wday=4, tm_yday=297, tm_isdst=0)
+MosTime2=time.localtime()
+MosTime2
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=46, tm_sec=4, tm_wday=4, tm_yday=297, tm_isdst=0)
+interval=time.mktime(MosTime2)-time.mktime(MosTime1)
+interval
+217.0
+IntervMin=interval/60
+IntervMin
+3.6166666666666667
+```

TEMA4/test.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по Теме 4
+Ходюк Максим Романович, А-01-23
+## Задание, Вариант 6
+
+Создайте переменную с календарными сведениями для текущего момента времени и выведите информацию в виде строки «Текущая дата: <день>-<месяц>-<год>». Создайте объект со значением 5-2j. Извлеките из него квадратный корень с записью результата в новый объект. Эту операцию выполните с использованием функции exec.
+
+### Выполнение
+Создание переменной с календарными сведениями и форматный вывод:
+```
+import time
+MosTime=time.localtime()
+LocalDate='Текущая дата:{day}-{month}-{year}'
+LocalDate.format(day=MosTime.tm_mday, month=MosTime.tm_mon, year=MosTime.tm_year)
+'Текущая дата:24-10-2025'
+```
+
+Создание обьекта-комплексного числа и извлечение из него квадратного корня с помощью функции exec
+```
+import cmath
+perem=5-2j
+perem
+(5-2j)
+exec(input("Введите инструкцию для извлечения квадратного корня из комплексного числа в переменной perem и записи в новую переменную: "))
+Введите инструкцию для извлечения квадратного корня из комплексного числа в переменной perem и записи в новую переменную: PeremSqrt=cmath.sqrt(perem)
+PeremSqrt
+(2.27872385417085-0.4388421169022545j)
+```