Объяснил про random.seed

TEMA1/test.md

@@ -0,0 +1,8 @@
+# Индивидуальное контрольное задание по теме 1
+Подольский Никита, А-01-23
+
+## Задание
+Для чего предназначено предложение «Окно (Window)» главного меню?
+
+## Решение 
+Предложение “Окно” (Window) в главном меню IDLE предназначено для управления окнами программы — например, чтобы быстро переключаться между открытыми окнами, изменять их размер, располагать на экране, или выводить их на передний план

TEMA2/report.md

@@ -0,0 +1,541 @@
+# Отчет по теме 2
+## Подольский Никита, А-01-23
+### 1. Запуск оболочки IDLE
+Установка рабочего каталога
+``` python 
+>>> import os
+os.chdir('/Users/nickpod/Desktop/python-labs/TEMA2')
+```
+### 2.1 Изучение простых объектов 
+```python 
+>>> f1=16
+>>> f2=3
+>>> f1,f2
+(16, 3)
+>>> f1;f2
+16
+3
+```
+
+```python 
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+
+>>> type(f2)
+<class 'int'>
+
+>>> del f1,f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+### 3. Изучение правил именования объектов в Python
+Правила именования:
+-  имена должны состоять из латинских букв, цифр и символов подчеркивания;
+-  имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
+-  имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
+-  большие и малые буквы в именах различаются (имена – чувствительные к регистру)!
+
+```python 
+>>> gg1=1.6
+>>> hh1='Строка'
+>>> 73sr=3
+SyntaxError: invalid decimal literal
+>>> and=7
+SyntaxError: invalid syntax
+```
+
+### 4. Вывод списка ключевых слов с помощью инструкции.
+```python 
+>>> 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']
+```
+
+### 5. Вывод списка встроенных идентификаторов с помощью инструкций
+ ```python 
+ >>> 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', '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']
+ ```
+
+### 5.1 Изучение функций (abs, len, max, min, pow, round, sorted, sum, zip)
+#### abs()
+```python 
+>>> abs(-7)
+7
+```
+ Возвращает модуль числа
+
+#### len()
+```python 
+>>> len([1, 2, 3])
+3
+```
+ Возвращает количество элементов в объекте (например, в списке)
+
+#### max()
+```python 
+>>> max(3, 5, 2)
+5
+```
+ Возвращает максимальное значение
+
+#### min()
+```python 
+>>> min(2,1)
+1
+```
+ Возвращает минимальное число
+
+#### pow()
+```python 
+>>> pow(2, 3)
+8
+```
+ Возводит число 2 в 3ью степень = 8
+
+#### round()
+```python 
+>>> round(3.1415926, 2)
+3.14
+```
+Округляет число до заданного количества знаков после запятой
+
+#### sorted()
+```python 
+>>> sorted([3, 1, 2])
+[1, 2, 3]
+```
+ Возвращает отсортированный список
+
+#### sum()
+```python 
+>>> sum([1, 2, 3])
+6
+```
+ Возвращает сумму всех элементов в последовательности
+
+#### zip()
+```python 
+>>> list(zip([1, 2, 3], ['a', 'b', 'c']))   
+[(1, 'a'), (2, 'b'), (3, 'c')]
+```
+Создаёт пары элементов из нескольких последовательностей
+
+### 6. Малые и большие буквы различаются
+```python 
+>>> Gg1=45
+>>> gg1, Gg1
+(1.6, 45)
+```
+
+### 7. Изучение базовых типов объектов
+Базовые типы объектов:
+#### Логический (**bool**) 
+```python 
+>>> bb1=True
+>>> bb2=False
+>>> bb1;bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+```
+
+#### Целый (**int**) 
+```python 
+>>> ii1=-1234567890
+```
+
+#### Вещественный (**float**) 
+```python 
+>>> a = 3.67
+>>> b = -0.45
+>>> ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+```
+
+#### Комплексный (**complex**) 
+```python 
+>>> cc1=2-3j
+>>> z = -1j
+>>> cc2=complex(a,b)  #Создается комплексное число
+>>> cc2
+(3.67-0.45j)
+```
+
+#### Строка символов (**str**)
+```python 
+>>> ss1 = 'Это - строка символов'
+>>> ss1 = "Это - строка символов"
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+ 	 
+>>> ss1b= 'Меня зовут: \n <Подольский НК>'
+>>> print(ss1b)
+Меня зовут: 
+ <Подольский НК>
+```
+
+```python 
+>>> mnogo = """Нетрудно заметить , что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+```python 
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+>>> ss1[6:9]  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[17:3:-2]
+'омсаот '
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+
+```python 
+>>> ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#67>", line 1, in <module>
+    ss1[4]='='  # Будет диагностика!
+TypeError: 'str' object does not support item assignment
+```
+Будет диагностика!
+
+```python 
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> ss1
+'Это = строка символов'
+```
+
+```python 
+>>> ss1b[3:10]
+'я зовут'
+>>> ss1b[5:15]
+'зовут: \n <'
+>>> ss1b[2:-5:2]
+'н оу:\n<ооьк'
+```
+
+
+### 8. Типы объектов (списки (list) , кортежи (tuple), словари (dict), множества (set))
+### 8.1 Списки
+	Список – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания.
+
+```python 
+>>> spis1=[111,'Spisok',5-9j]
+>>> spis1
+[111, 'Spisok', (5-9j)]
+```
+
+```python 
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+```
+
+```python 
+>>> spis=[1,2,3,4,
+
+      5,6,7,
+
+      8,9,10]
+>>> spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+
+```python 
+>>> spis1[-1]
+(5-9j)
+
+>>> stup[-8::2]
+[0, 1, 1, 1]
+
+>>> spis1[1]='Список'
+>>> spis1
+[111, 'Список', (5-9j)]
+```
+
+```python 
+>>> len(spis1)
+3
+```
+
+```python 
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+
+```python 
+>>> 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']
+```
+
+#### Удаление элемента списка
+```python 
+>>> spis1.pop(1)   #Из списка удален элемент с индексом 1
+'Список'
+>>> spis1
+[111, (5-9j), 'New item']
+```
+
+#### insert
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.insert(1, 100) 
+[1, 100, 2, 3]
+```
+#### remove
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.remove(2)
+[1, 3]
+```
+#### extend
+```python 
+>>> lst = [1, 2]
+>>> lst.extend([3, 4]) 
+[1, 2, 3, 4]
+```
+#### clear
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.clear() 
+[]
+```
+#### sort
+```python 
+>>> lst = [3, 1, 2]
+>>> lst.sort() 
+[1, 2, 3]
+```
+#### reverse
+```python 
+>>> lst = [1, 2, 3]
+>>> lst.reverse()
+[3, 2, 1]
+```
+#### copy
+```python 
+>>> lst = [1, 2, 3]
+>>> new_lst = lst.copy() 
+[1, 2, 3]
+```
+#### count
+```python 
+>>> lst = [1, 2, 2, 3]
+>>> lst.count(2)
+2
+```
+#### index
+```python 
+>>> lst = [10, 20, 30]
+>>> lst.index(20) 
+1
+```
+
+#### Вложенный список
+```python 
+>>> spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два спискa
+>>> spis2
+[[111, (5-9j), 'New item'], [4, 5, 6, 7]]
+```
+
+```python 
+>>> spis2[0][1]  #обращение к элементу списка spis1
+(5-9j)
+>>> spis2[0][1]=78  #Убедитесь, что значение элемента заменено на 78
+>>> spis1
+[111, 78, 'New item']
+```
+При создании spis2 = [spis1, [4,5,6,7]] первый элемент списка spis2 не копирует spis1, а хранит ссылку на него.
+Поэтому когда мы изменили элемент spis2[0][1] = 78, это изменение произошло непосредственно в объекте spis1.
+В результате сам spis1 изменился, и его второй элемент 'Список' был заменён на 78.
+
+```python 
+>>> my_list = [42, "Привет, мир!", True, [1, 2, 3]]
+>>> print(my_list)
+[42, 'Привет, мир!', True, [1, 2, 3]]
+```
+
+### 8.2 Объект - кортеж
+	Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддер­живают включение в них объектов различных типов и операции, типич­ные для последовательностей.
+
+ ```python 
+ >>> kort1=(222,'Kortezh',77+8j)
+ >>> 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 <Подольский НК>')
+ ```
+
+#### Важные методы кортежа
+##### Определение индекса заданного элемента:
+``` python 
+  >>> kort1.index(2)
+  4
+```
+
+##### Подсчет числа вхождений заданного элемента в кортеже:
+``` python 
+>>> kort1.count(222) 
+1
+```
+
+##### Операция замены элемента кортежа
+``` python
+>>> kort1[2]=90   
+Traceback (most recent call last):
+  File "<pyshell#112>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+
+#### Создание объекта-кортежа с элементами разных типов:
+``` python
+>>> my_tuple = (99, "Python", [1, 2, 3], (True, False))
+>>> print(my_tuple)
+(99, 'Python', [1, 2, 3], (True, False))
+```
+
+### 8.3 Объект - словарь
+``` python
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+```
+
+``` python
+>>> dic1['Orel']
+56
+```
+
+``` python 
+>>> dic1['Pskov']=78
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+```python
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+```
+
+##### Создадим словарь
+``` python
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>> dic2
+{1: 'mean', 2: 'standart deviation', 3: 'correlation'}
+
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+>>> dic3
+{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, '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 <Подольский НК>'}
+```
+
+```python
+# кортеж с 7 элементами
+>>> keys_tuple = ('a', 'b', 'c', 'd', 'e', 'f', 'g')
+
+# список с 5 элементами
+>>> values_list = [100, 200, 300, 400, 500]
+
+>>> my_dict = dict(zip(keys_tuple, values_list))
+>>> print(my_dict)
+{'a': 100, 'b': 200, 'c': 300, 'd': 400, 'e': 500}
+
+>>> len(my_dict)
+5
+```
+- У нас есть **7 ключей** и **5 значений**.
+- Функция zip работает до тех пор, пока хватает элементов в самой короткой последовательности.
+- Так как в списке только 5 элементов, то сформировалось 5 пар «ключ–значение».
+
+### 8.4 Объект множество
+``` python
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>> mnoz1
+{'датчик', 'линия связи', 'двигатель', 'микропроцессор'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле')
+>>> mnoz1
+{'двигатель', 'датчик', 'микропроцессор', 'реле', 'линия связи'}
+>>> mnoz1.remove('линия связи')
+>>> mnoz1
+{'двигатель', 'датчик', 'микропроцессор', 'реле'}
+```
+
+Самостоятельно придумал объект-множество с элементами разных
+``` python
+>>> mnoz2 = {10, 'строка', 3.14, (1, 2, 3)}
+>>> mnoz2
+{3.14, 10, (1, 2, 3), 'строка'}
+
+>>> len(mnoz2)  # количество элементов
+4
+
+>>> 'строка' in mnoz2 
+True
+
+>>> mnoz2.add(False)
+>>> mnoz2
+>>> {False, 3.14, 'строка', 10, (1, 2, 3)}
+
+>>> mnoz2.remove(10)
+>>> mnoz2
+{False, 3.14, 'строка', (1, 2, 3)}
+```
+
+### 9. Завершил работу со средой

TEMA2/task.md

@@ -0,0 +1,75 @@
+# Общее контрольное задание по теме 2
+Подольский Никита, А-01-23
+## Задание 
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+·      Создать переменную с именем **familia** и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+·      Создать переменную со значением, совпадающим с первой буквой из **familia**.
+
+·      Создать переменную с именем **sp****_****kw** со значением – списком всей ключевых слов языка Python.
+
+·      Удалите из списка **sp****_****kw** значение **'nonlocal'**. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+·      Создайте кортеж **kort****_****nam** с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это **tuple**.
+
+·      Напишите инструкцию, добавляющую в **kort****_****nam** имена еще двух студентов.
+
+·      Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+·      Создайте словарь **dict****_****bas**, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+## Решение 
+### 1. Создаю переменную familia
+```python
+>>> familia = 'Podolskiy'
+```
+
+### 2.  Создаю переменную которая = первой букве familia
+```python
+>>> fam1=familia[0]
+>>> fam1
+'P'
+```
+
+### 3. Создаю переменную с именем sp_kw, значение – списк всех ключевых слов Python.
+```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', затем убедился, что это значение удалено из списка.
+```python
+>>> 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 с моим и еще 3-х студентов из группы именами. Проверяю, что тип переменной – это tuple.
+```python
+>>> kort_nam = ("Nikita", "Vadim", "Artem", "Dima")
+>>> type(kort_nam)
+<class 'tuple'>
+```
+
+### 6.  Добавляю в kort_nam имена двух студентов.
+```python
+>>> kort_nam += ("Vanya", "Pasha")
+>>> kort_nam
+('Nikita', 'Vadim', 'Artem', 'Dima', 'Vanya', 'Pasha')
+```
+
+### 7.  Определяю, сколько раз в кортеже присутствуют студенты с именем «Vanya».
+```python
+>>> kort_nam.count("Vanya")
+1
+```
+
+### 8. Создаю словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+```python
+>>> dict_bas = {"строка": familia, "список": sp_kw, "кортеж": kort_nam,}
+>>> dict_bas
+{'строка': 'Podolskiy', 'список': ['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'], 'кортеж': ('Nikita', 'Vadim', 'Artem', 'Dima', 'Vanya', 'Pasha')}
+```

TEMA2/task.py

@@ -0,0 +1,8 @@
+nm = (12, 23, 34, 14, -7, -34)
+type1 = type(nm)
+print("Класс объекта:", type1)
+sum1stthree = sum(nm[0:3])
+sumlastthree = sum(nm[3:6])
+diff = sum1stthree - sumlastthree
+
+print("Разность сумм первых трех и последних трех элементов:", difference)

TEMA2/test.md

@@ -0,0 +1,21 @@
+# Индивидуальное контрольное задание по теме 2
+Подольский Никита, А-01-23
+
+## Задание (Вариант 15)
+Создайте объект
+nm=(12,23,34,14,-7,-34)
+
+К какому классу относится этот объект? Напишите инструкцию, обеспечивающую расчет разности сумм первых трех элементов и последних трех.
+
+## Решение
+``` python
+>>> nm = (12, 23, 34, 14, -7, -34)
+>>> type1 = type(nm)
+>>> print("Класс объекта:", type1)
+Класс объекта: <class 'tuple'>
+>>> sum1stthree = sum(nm[0:3])
+>>> sumlastthree = sum(nm[3:6])
+>>> diff = sum1stthree - sumlastthree
+print("Разность сумм первых трех и последних трех элементов:", diff)
+Разность сумм первых трех и последних трех элементов: 96
+```

TEMA3/report.md

@@ -0,0 +1,805 @@
+# Отчет по теме 3
+## Подольский Никита, А-01-23
+### 1. Запуск IDLE
+
+### 2. Преобразование простых типов объектов
+#### 2.1 Функция `bool()`
+```python
+>>> logiz1=bool(56)
+>>> logiz1
+True
+>>> logiz2=bool(0)
+>>> logiz2
+False
+>>> logiz3=bool('Beta')
+>>> logiz3
+True
+>>> logiz4=bool(" ")
+>>> logiz4
+True
+```
+
+#### 2.2 Преобразование в целое десятичное число объекта с заданной системой счисления
+```python
+>>> tt1=int(198.6) #Отбрасывается дробная часть
+>>> tt1
+198
+>>> tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+>>> tt2
+-76
+>>> tt3=int("B",16)
+>>> tt3
+11
+>>> tt4=int("71",8)
+>>> tt4
+57
+>>> tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+В последней инструкции `tt5=int("98.76")` возникает ошибка, потому что функция `int()` ожидает строку, представляющую целое число, а не вещественное (дробное) число.
+
+ Функция `float()`
+```python
+>>> flt1=float(789)
+>>> flt1
+789.0
+>>> flt2=float(-6.78e2)
+>>> flt2
+-678.0
+>>> flt3=float("Infinity")
+>>> flt3
+inf
+>>> flt4=float("inf")
+>>> flt4
+inf
+```
+
+#### 2.3 Преобразование десятичных чисел в другие системы счисления
+``` python
+>>> 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()`
+```python
+>>> strk1=str(23.6)
+>>> strk1
+'23.6'
+>>> strk2=str(logiz3)
+>>> strk2
+'True'
+>>> strk3=str(["A","B","C"])  #Преобразуем список
+>>> strk3
+"['A', 'B', 'C']"
+>>> strk4=str(("A","B","C"))  #Преобразуем кортеж
+>>> strk4
+"('A', 'B', 'C')"
+>>> strk5=str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+>>> strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+#### 3.2 Преобразование элементов объекта в список с помощью функции `list()`
+``` python
+>>> 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']
+```
+
+##### Создание из того же словаря списка с другими частями
+```python
+>>> spis31=list({"A":1,"B":2,"C":9}.values())
+spis31
+[1, 2, 9]
+```
+
+#### 3.3 Преобразование элементов объектов в кортеж с помощью функции `tuple()`
+```python
+>>> kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+>>> kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2)   #Преобразование списка в кортеж
+>>> kort8
+(124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+>>> kort9
+('A', 'B', 'C')
+```
+
+#### 3.4 Удаление объектов
+```python
+>>> del strk5, kort8
+>>> strk5
+Traceback (most recent call last):
+  File "<pyshell#65>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+>>> kort8
+Traceback (most recent call last):
+  File "<pyshell#66>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+
+##### Создание строки с фамилией и инициалами и ее преобразования
+``` python
+>>> fam = "Podolsky"
+>>> im = "N"
+>>> ot = "K"
+>>> fio = fam + im+ ot
+>>> fio
+'PodolskyNK'
+>>> listfio=list(fio)
+>>> listfio
+['P', 'o', 'd', 'o', 'l', 's', 'k', 'y', 'N', 'K']
+>>> kort = tuple(listfio)
+>>> kort
+('P', 'o', 'd', 'o', 'l', 's', 'k', 'y', 'N', 'K')
+>>> strkfio = str(kort)
+>>> strkfio
+"('P', 'o', 'd', 'o', 'l', 's', 'k', 'y', 'N', 'K')"
+```
+
+### 4. Арифметические операции
+#### 4.1 Сложение и вычитание
+```python
+>>> 12+7+90   # Сложение целых чисел
+109
+>>> 5.689e-1 - 0.456  #Вычитание вещественных чисел
+0.11289999999999994
+>>> 23.6+54   #Сложение вещественного и целого чисел
+77.6
+>>> 14-56.7+89  # Сложение и вычитание целых и вещественных чисел
+46.3
+```
+
+#### 4.2 Умножение
+``` python
+>>> -6.7*12   #Умножение вещественного числа на целое число
+-80.4
+```
+
+#### 4.3 Деление
+``` python
+>>> -234.5/6   #Деление вещественного числа на целое
+-39.083333333333336
+>>> a=178/45  #Деление двух целых чисел – проверьте тип объекта a!
+>>> a
+3.9555555555555557
+>>> type(a)
+<class 'float'>
+```
+
+#### 4.4 Деление с округлением вниз (//)
+``` python
+>>> b=178//45   #Деление двух целых чисел
+>>> b
+3
+>>> type(b)
+<class 'int'>
+
+>>> c=-24.6//12.1  #Деление двух вещественных чисел
+>>> c
+-3.0
+>>> type(c)
+<class 'float'>
+
+>>> z = 52 // 2.5
+>>> z
+20.0
+>>> type (z)
+<class 'float'>
+
+>>> zz = 52.5 // 7
+>>> zz
+7.0
+>>> type (zz)
+<class 'float'>
+```
+
+#### 4.5 Получение остатка от деления (%)
+``` python
+>>> 148%33   #Остаток от деления двух целых чисел
+16
+>>> 12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+>>> 148 % 3.8
+3.6000000000000068
+>>> 12.6 % 3
+0.5999999999999996
+```
+
+#### 4.6.  Возведение в степень **
+``` python
+>>> 14**3  #Целое число возводится в целую степень148 % 3.8
+2744
+
+>>> e=2.7**3.6  #Вещественное число возводится в вещественную степень
+>>> e
+35.719843790663525
+
+>>> 5**2.5
+55.90169943749474
+
+>>> 2.5**5
+97.65625
+```
+
+##### Другие арифметические операции над комплексными числами
+###### Сложение
+``` python
+>>>> z1 = 2 + 3j
+>>> z2 = 4 - 5j
+>>> sum_result = z1 + z2
+>>> sum_result
+(6-2j)
+```
+###### Вычитание
+``` python
+>>> sub_result = z1 - z2
+>>> sub_result
+(-2+8j)
+```
+###### Умножение
+``` python
+>>> mul_result = z1 * z2
+>>> mul_result
+(23+2j)
+```
+###### Деление
+``` python
+>>> delen = z1 / z2
+>>> delen
+(-0.17073170731707318+0.5365853658536587j)
+```
+
+###### Возведение в степень 
+``` python
+>>> e = 5**(2+1j)       # Получится комплексное число (complex)
+>>> e
+(-0.9657992483483834+24.98133767058701j)
+
+>>> f = (3+4j)**2       # Получится комплексное число (complex)
+>>> f
+(-7+24j)
+
+>>> g = (2+3j)**1.5     # Получится комплексное число (complex)
+>>> g
+(0.6603660276815663+6.814402636366296j)
+```
+
+###### Деление с округлением вниз
+``` python
+>>> z1 // z2
+Traceback (most recent call last):
+  File "<pyshell#135>", line 1, in <module>
+    z1 // z2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+
+>>> z1 // 2
+Traceback (most recent call last):
+  File "<pyshell#136>", line 1, in <module>
+    z1 // 2
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+```
+Видим, что деление с округлением вниз нельзя использовать с комплексными числами
+
+###### Взятие остатка от деления
+ ``` python
+>>> z1 % z2
+Traceback (most recent call last):
+  File "<pyshell#137>", line 1, in <module>
+    z1 % z2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+
+>>> z1 % 2
+Traceback (most recent call last):
+  File "<pyshell#138>", line 1, in <module>
+    z1 % 2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+ ```
+ Взятие остатка от деления нельзя так же применять к комплексным числам
+
+### 5. Операции с двоичными представлениями целых чисел
+#### 5.1 Двоичная инверсия (~)
+``` python
+>>> dv1=9
+>>> dv2 = ~dv1
+>>> dv2
+-10
+>>> bin(dv1)
+'0b1001'
+>>> bin(dv2)
+'-0b1010'
+```
+
+#### 5.2 Двоичное И (&)
+``` python
+>>> bin(7&9)
+'ob1'
+>>> bin (7&8)
+'0b0'
+```
+
+#### 5.3 Двоичное ИЛИ (|)
+``` python
+>>> bin(7|9)     # 111 или 1001 = 1111
+'0b1111'
+>>> bin(7|8)     # 111 или 1000 = 1111
+'0b1111'
+>>> bin(14|5)   # 1110 или 0101 = 1111
+'0b1111'
+```
+
+#### 5.4 Двоичное исключающее ИЛИ (^)
+``` python
+>>> bin(14^5)  # 1110 исключающее или 0101 = 1011
+'0b1011'
+
+>>>14^5        
+11
+```
+
+#### 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+``` python
+>>> h=14
+>>> bin(h)          
+'0b1110'
+
+>>> g=h<<2  # Новое двоичное представление = 111000
+>>> g
+56
+>>> bin(g)  
+'0b111000'
+
+>>> g1=h>>1  # Новое двоичное представление = 0111
+>>> g1
+7
+>>> bin(g1)
+'0b111'
+
+>>> g2=h>>2  # Новое двоичное представление = 0011
+>>> g2
+3
+>>> bin(g2)
+'0b11'
+```
+
+``` python
+a = 0b1011101    # это 93 в десятичной системе
+b = 0b1100110    # это 102 в десятичной системе
+```
+
+##### Инверсия
+``` python
+>>> ainv = ~a
+>>> binv = ~b
+>>> ainv
+-94
+>>> binv
+-103
+>>> bin(a)
+'0b1011101'
+>>> bin (b)
+'0b1100110'
+```
+
+##### Двоичное И
+ ``` python
+>>> andres = a & b
+>>> andres
+68
+>>> bin(andres)
+'0b1000100'
+ ```
+
+##### Двоичное ИЛИ
+``` python
+>>> orres = a | b
+>>> orres
+127
+>>> bin(orres)
+'0b1111111'
+```
+
+##### Двоичное исключающее ИЛИ
+``` python
+>>> isclres = a ^ b
+>>> isclres
+59
+>>> bin(isclres)
+'0b111011'
+```
+
+##### Сдвиг влево на 2 разряда
+``` python
+>>> shleft = a << 2
+>>> shleft
+372
+>>> bin(shleft)
+'0b101110100'
+```
+
+##### Сдвиг вправо на 3 разряда
+``` python
+>>> shright = b >> 3
+>>> shright
+12
+>>> bin(shright)
+'0b1100'
+```
+
+### 6.  Операции при работе с последовательностями (строками, списками, кортежами)
+#### 6.1 Объединение последовательностей (конкатенация)(+)
+``` python
+>>> 'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+#### 6.2 Повторение * 
+  ``` python
+>>> 'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99
+>>> signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>> signal2=(0,)*3+(1,)*5+(0,)*7
+>>> signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+  ```
+
+#### 6.3 Проверка наличия заданного элемента в последователности (in)
+``` python
+>>> stroka='Система автоматического управления'
+'автомат' in stroka  #Наличие подстроки в строке
+True
+>>> 'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+#### 6.4 Подстановка значений в строку с помощью оператора "%"
+``` python
+>>> stroka='Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+### 7. Оператор присваивания 
+#### 7.1 Обычное присваивание значения переменной (=)
+```python
+zz = -12
+```
+
+#### 7.2 Увеличение значения переменной на заданную величину (+=) или уменьшение (-=)
+``` python
+>>> zz+=5   # Значение zz увеличивается на 5
+>>> zz
+-7
+>>> zz -= 3 # Значение zz уменьшается на 3
+>>> zz
+-10
+```
+
+``` python
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+```
+
+#### 7.3 Умножение текущего значения переменной на заданную величину ( * = ) или деление (/=)
+``` python
+>>> zz/=2
+>>> zz
+-5.0
+>>> zz*=5
+>>> zz
+-25.0
+```
+
+``` python
+>>> stroka2='привет'
+>>> stroka2*=3
+>>> stroka2
+'приветприветпривет'
+```
+
+#### 7.4  Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(** =)
+``` python
+>>> zz //= 2
+>>> zz
+-13.0
+>> zz %= -2
+>> zz
+-1.0
+>> step = 21
+>> step **= 4
+>> step
+194481
+```
+
+#### 7.5 Множественное присваивание
+``` python
+>>> w=v=10  # Переменным присваивается одно и то же значение
+>>> n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+```
+
+##### Присваивание кортежу
+``` python
+>>> a1, a2, a3 = "a", "b", "c" # Строка
+>>> a1, a2, a3
+('a', 'b', 'c')
+>>> b1, b2, b3 = ["a", 1, None] # Список
+>>> b1
+'a'
+>>> b3
+>>> c1, c2, c3 = {"one": 1, "two": 2, "three": 3} # Словарь
+>>> c1, c2, c3
+('one', 'two', 'three')
+>>> m1, m2, m3 = {52, 0, 3} # Множество
+>>> m1, m2, m3
+(0, 3, 52)
+```
+
+### 8. Логические операции - при создании логических выражений, дающих в результате вычисления значения  True или False
+#### 8.1 Операции сравнение: равенство ( = = ), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=)
+``` python
+>>> w
+10
+>>> v
+10
+>>> w==v # Равенство
+True
+>>> w!=v # Не равно
+False
+>>> w<v # Меньше
+False
+>>> w<=v # Меньше или равно
+True
+```
+
+#### 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in)
+##### Операции с множеством
+``` python
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> 'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> 56 in dic1.values()
+True
+
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+```
+
+#### 8.3 Создание больших логических выражений с использованием соединительных слов. 
+
+``` python
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+
+```python
+>>> (a < 20 or b == -6) and not ('pen' in mnoz1)
+False
+>>> not (a == 0) and ('Moscow' in dic1 or 'book' not in mnoz1)
+False
+```
+
+#### 8.4 Проверка ссылок переменных на один и тот же объект (is)
+
+``` python
+>>> w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+>>> w is v
+True
+>>> w1=['A','B']
+>>> w1
+['A', 'B']
+>>> v1=['A','B']
+>>> v1
+['A', 'B']
+>>> w1 is v1
+False
+```
+
+Когда создаю переменные w и v с одним числом, они ссылаются на один и тот же объект в памяти, поэтому `w is v` выдаёт True.
+А когда создаю два одинаковых списка, w1 и v1, то это уже два разных объекта, хоть и одинаковых по содержанию, поэтому `w1 is v1` выдаёт False.
+
+### 9. Операции с объектами, выполняемые с помощью методов
+``` python
+>>> 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 Методы для работы со строками
+``` python
+>>> stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+>>> stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  за-данный разделитель
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()   #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+>>> stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+
+Метод `format` в Python применяется для красивого и удобного подставления данных внутрь строки. В строке делаются специальные “места” — фигурные скобки {}, а внутрь них можно подставить значения через `.format(...)`.
+
+``` python
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+```
+
+``` python 
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+```
+
+#### 9.2 Методы для работы со списками
+``` python
+>>> spsk = ["apple", 52, (6, 9), "macbook", 52.52] #Создаю произвольный список
+>>> spsk.pop(2) # Удаляет элемент с индексом 2
+(6, 9)
+>>> spsk.append('c') # Добавляет в конец списка элемент 'c'
+>>> spsk
+['apple', 52, 'macbook', 52.52, 'c']
+>>> spsk.insert(2,'a') # Вставляет элемент 'a' на место индекса 2
+>>> spsk
+['apple', 52, 'a', 'macbook', 52.52, 'c']
+>>> spsk.count('a') # Подсчитывает количество 'a', которые встречаются в списке
+1
+```
+
+#### 9.3 Самостоятельно создайте кортеж и изучите применение его методов.
+``` python
+>>> my_tuple = (5, 2, 7, 2, 9, 2)
+>>> count_2 = my_tuple.count(2)  # Считает, сколько раз 2 встречается в кортеже
+>>> count_2
+3
+>>> index_7 = my_tuple.index(7)  # Находит индекс первого появления 7 в кортеже
+>>> index_7
+2
+>>> my_tuple
+(5, 2, 7, 2, 9, 2)
+```
+
+#### 9.4 Словари и множества
+#### Словари
+``` python
+>>> d = {'name': 'Оля', 'age': 20}
+>>> d.get('age')
+20
+>>> d.get('city', 'Москва')
+'Москва'
+>>> list(d.keys())
+['name', 'age']
+>>> list(d.values())
+['Оля', 20]
+>>> list(d.items())
+[('name', 'Оля'), ('age', 20)]
+>>> d.update({'city': 'Москва'})
+>>> d
+{'name': 'Оля', 'age': 20, 'city': 'Москва'}
+>>> d.pop('age')
+20
+>>> d
+{'name': 'Оля', 'city': 'Москва'}
+>>> d.clear()
+>>> d
+{}
+>>> d2 = d.copy()
+>>> d2
+{}
+```
+
+#### Множество
+
+``` python
+>>> s = {1, 2, 3}
+>>> s.add(4)
+s
+{1, 2, 3, 4}
+>>> s.remove(2)
+>>> s
+{1, 3, 4}
+>>> s.discard(3)
+>>>> s
+{1, 4}
+>>> x=s.pop()
+>>> x
+1
+>>> x,s
+1 {4}
+>>> s.clear()
+>>> s
+>>> set()
+>>> s2=s.copy()
+>>> s.update([5,6])
+>>> s
+{5, 6}
+>>> s3 = s.union({7, 8})
+>>> s3
+{8, 5, 6, 7}
+>>> s4 = s.intersection({5, 6, 9})
+>>> s4
+{5, 6}
+>>> s5 = s.difference({4, 6})
+>>> s5
+{5}
+>>> s6 = s.symmetric_difference({5, 9})
+>>> s6
+{9, 6}
+>>> {5}.issubset(s)
+True
+>>> s.issuperset({5})
+True
+>>> {10, 11}.isdisjoint(s)
+True
+```
+
+### 10. Завершил работу со средой

TEMA3/task.md

@@ -0,0 +1,63 @@
+# Общее контрольное задание по теме 3
+Подольский Никита, А-01-23
+## Задание 
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+- Преобразовать восьмеричное значение 45 в целое число.
+- Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+- Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+- Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+- Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+- Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+- Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.
+
+## Решение 
+```python
+>>> vosm = "45"
+>>> celoe = int(vosm, 8)       
+>>> celoe         
+37
+>>> D = {"усиление":23, "запаздывание":12, "постоянная времени":78}       
+>>> spisok_klychey = list(D.keys())        
+>>> spisok_klychey          
+['усиление', 'запаздывание', 'постоянная времени']
+>>> spisok_znach = list(D.values())          
+>>> spisok_znach         
+[23, 12, 78]
+>>> obsh_kort = tuple(spisok_klychey + spisok_znach)        
+>>> obsh_kort       
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+>>> dir(obsh_kort)        
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+>>> result1 = ((1768 // 24.8) % 3) ** 2.4
+5.278031643091577
+>>> result2 = (~(13 & 27) ^ 14) << 2        
+>>> result2        
+-32
+>>> spisok_kolebat = ['колебат'] * 4        
+>>> spisok_kolebat          
+['колебат', 'колебат', 'колебат', 'колебат']
+>>> komb = spisok_kolebat[1] +  spisok_kolebat[2]        
+>>> komb        
+'колебатколебат'
+>>> 'аткол' in komb       
+True
+>>> 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]) #Получаем список значений
+>>> obj = "Создать объект - символьную строку с текстом данного предложения."          
+>>> obj_l = obj.split()        
+>>> obj_l        
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']3
+
+>>> obj_l[obj_l.index("-")] = ","        
+obj_l       
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> obj_l.remove("данного")        
+>>> obj_l     
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+
+```

TEMA3/test.md

@@ -0,0 +1,67 @@
+# Индивидуальное контрольное задание по теме 3
+Подольский Никита, А-01-23
+
+## Задание (Вариант 8)
+
+M1_8
+
+1)      При каких условиях можно создавать программы для среды Python с помощью других текстовых редакторов? Назовите примеры таких редакторов.
+
+2)      Создайте объект, содержащий текст задания данного пункта. Создайте новый объект, в который включите из первого объекта только слова, находящиеся на четных позициях. Напишите инструкции определения класса созданного объекта и списка его атрибутов.
+
+3)      Создайте кортеж, содержащий слова из итогового созданного объекта в п.2. Напишите инструкции подсчета числа слов и отобразите с использованием формата результат на экране по шаблону: "в кортеже ХХ элементов".
+
+4)      Напишите инструкции создания словаря, в котором ключами будут порядковые номера, а значениями - слова из кортежа, созданного в п.3.
+
+5)      Преобразуйте значения из словаря во множество. Подсчитайте и выведите на экран число элементов этого множества.
+
+## Решение
+### 1
+ Программы для среды Python можно создавать с помощью любых текстовых редакторов, если соблюдаются простые условия: файл должен быть сохранён с расширением .py и код должен быть написан в соответствии с синтаксисом Python. После сохранения такого файла его можно запускать в интерпретаторе Python или из командной строки. Примеры: IDLE, Notepad++, VS Code, PyCharm.
+### 2-5
+``` python
+>>> text = "Создайте объект содержащий текст задания данного пункта создайте новый объект в который включите из первого объекта только слова находящиеся на четных позициях напишите инструкции определения класса созданного объекта и списка его атрибутов"
+
+>>> words = text.split()
+>>> words
+['Создайте', 'объект', 'содержащий', 'текст', 'задания', 'данного', 'пункта', 'создайте', 'новый', 'объект', 'в', 'который', 'включите', 'из', 'первого', 'объекта', 'только', 'слова', 'находящиеся', 'на', 'четных', 'позициях', 'напишите', 'инструкции', 'определения', 'класса', 'созданного', 'объекта', 'и', 'списка', 'его', 'атрибутов']
+
+>>> chetslov = []
+>>> for i in range(len(words)):
+	    if (i + 1) % 2 == 0:
+	        chetslov.append(words[i])
+>>> chetslov
+['объект', 'текст', 'данного', 'создайте', 'объект', 'который', 'из', 'объекта', 'слова', 'на', 'позициях', 'инструкции', 'класса', 'объекта', 'списка', 'атрибутов']
+
+>>> newobj = " ".join(chetslov)
+>>> newobj
+объект текст данного создайте объект который из объекта слова на позициях инструкции класса объекта списка атрибутов
+
+>>> print("Класс объекта:", type(newobj))
+Класс объекта: <class 'str'>
+>>> print("Список атрибутов:", dir(newobj))
+
+Список атрибутов: ['__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']
+
+>>> tup = tuple(newobj.split())
+>>> tup
+('объект', 'текст', 'данного', 'создайте', 'объект', 'который', 'из', 'объекта', 'слова', 'на', 'позициях', 'инструкции', 'класса', 'объекта', 'списка', 'атрибутов')
+
+print("в кортеже {} элементов".format(len(tup)))
+
+
+# 4) создаём словарь: номер -> слово
+>>> dictionary = {}
+>>> for i in range(len(tup)):
+	    dictionary[i + 1] = tup[i]
+
+>>> print("Словарь:", dictionary)
+Словарь: {1: 'объект', 2: 'текст', 3: 'данного', 4: 'создайте', 5: 'объект', 6: 'который', 7: 'из', 8: 'объекта', 9: 'слова', 10: 'на', 11: 'позициях', 12: 'инструкции', 13: 'класса', 14: 'объекта', 15: 'списка', 16: 'атрибутов'}
+
+# 5) превращаем значения словаря в множество
+>>> mnojest = set(dictionary.values())
+>>> mnojest
+{'класса', 'объекта', 'текст', 'данного', 'который', 'слова', 'создайте', 'инструкции', 'атрибутов', 'из', 'на', 'позициях', 'списка', 'объект'}
+>>> print("В множестве", len(mnojest), "элементов")
+В множестве 14 элементов
+```

TEMA4/report.md

@@ -0,0 +1,604 @@
+# Отчет по теме 4
+## Подольский Никита, А-01-23
+### 1. Запуск интерактивной оболочки IDLE
+
+### 2. Стандартные функции
+#### 2.1 Функция round – округление числа с заданной точностью
+```python
+>>> 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
+>>> round(123.456,0)
+123.0
+>>> round(123.456)
+123
+>>> type(round(123.456,1))
+<class 'float'>
+>>> type(round(123.456,0))
+<class 'float'>
+>>> type(round(123.456))
+<class 'int'>
+```
+
+#### 2.2 Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```python
+>>> gg=range(76,123,9)
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> range(23)
+range(0, 23)
+>>> type(range(23))
+<class 'range'>
+>>> 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]
+```
+
+Объект `range(23)` будет содержать последовательность целых чисел, начиная с 0 и до 22 (так как 23 не включается). Чтобы это увидить, необходимо применить `list()`. range — это легковесный объект, который генерирует числа на лету, а не хранит их все в памяти, поэтому преобразование в list нужно только для просмотра. Границы диапазона: от 0 и до 23, проход с шагом 1 по умолчанию(Если вызываем просто `range(23)`, выводится только начальное и конечное значение).
+#### 2.3 Функция zip - создание итерируемого объекта из кортежей
+``` python
+>>> qq = ["Podolsky", "Zhalnin", "Melnikov", "Bushmanov"]
+>>> ff = zip(gg, qq)
+>>> ff
+<zip object at 0x10ce5cc40>
+>>> tuple(ff)
+((76, 'Podolsky'), (85, 'Zhalnin'), (94, 'Melnikov'), (103, 'Bushmanov'))
+```
+
+``` python
+>>> ff[1]
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    ff[1]
+TypeError: 'zip' object is not subscriptable 
+```
+К объекту ff нельзя обратиться по индексу из-за того что он не итерируемый, так же он является не изменяемым.
+
+#### 2.4 Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
+```python
+>>> fff = float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=73
+>>> fff
+73.0
+>>> dan
+209.0
+```
+
+#### 2.5 Функция exec – чтение и выполнение объекта-аргумента функции.
+``` python
+>>> exec(input('введите инструкции:'))
+введите инструкции:
+>>> perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+```
+Функции eval() и exec() нужно использовать с осторожностью, так как они затрудняют чтение и понимание программ. Отличие eval() от exec() в том, что eval() вычисляет выражение (expression), а exec() выполняет инструкции (statements). Выражения — подмножество инструкций, отличающееся наличием результата. Например, 1, 1+2, a+3 — выражения, а присваивание или условный оператор — инструкции.
+#### 2.6. Функции abs, pow, max, min, sum, divmod, len, map.
+
+```python
+# Функция abs (возвращает модуль числа)
+>>> x = abs(-25)
+>>> x
+25
+
+# Функция pow (возведение в степень)
+>>> pow(3, 4)
+81
+>>> pow(7, 3, 5)  # 7**3 = 343, затем 343 % 5 = 3
+3
+
+# Функции max и min (поиск максимума и минимума)
+>>> max(12, 7, 29)
+29
+>>> min(-8, 15, 0)
+-8
+
+# Функция sum (суммирование элементов)
+>>> sum([5, 10, 15])
+30
+>>> sum([5, 10, 15], 5)
+35
+
+# Функция divmod (возвращает кортеж: целая часть и остаток)
+>>> divmod(47, 6)
+(7, 5)
+
+# Функция len (возвращает длину последовательности)
+>>> len(['a', 'b', 'c', 'd'])
+4
+
+# Функция map (применяет функцию к каждому элементу)
+>>> a = [2, 4, 6]
+>>> b = [1, 3, 5]
+>>> result = list(map(lambda x, y: x * y, a, b))
+>>> result
+[2, 12, 30]
+
+```
+
+### 3. Функции из стандартного модуля math – совокупность разнообразных математических функций.
+
+```python
+>>>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
+```
+
+Аналогичным образом изучим и попробуем применить некоторые другие функции из этого модуля: sin, acos, degrees, radians, exp, log, log10, sqrt, ceil, floor, pi.
+
+- Функция sin
+
+```python
+>>>help(math.sin)
+Help on built-in function sin in module math:
+sin(x, /)
+    Return the sine of x (measured in radians).
+>>>math.sin(math.pi / 3)
+0.8660254037844386
+```
+
+- Функция acos
+
+```python
+>>>help(math.acos)
+Help on built-in function acos in module math:
+acos(x, /)
+    Return the arc cosine (measured in radians) of x.
+    
+    The result is between 0 and pi.
+>>>math.acos(1)
+0.0
+```
+
+- Функция degrees
+
+```python
+>>>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
+```
+
+- Функция radians
+
+```python
+>>>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(157)
+2.7401669256310974
+```
+
+- Функция exp
+
+```python
+>>>help(math.exp)
+Help on built-in function exp in module math:
+exp(x, /)
+    Return e raised to the power of x.
+>>>math.exp(3)         
+20.085536923187668
+>>>math.exp(5)            
+148.4131591025766
+```
+
+- Функция log
+
+```python
+>>>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(10)           
+2.302585092994046
+>>>math.log(math.e)            
+1.0
+```
+
+- Функция log10
+
+```python
+>>>help(math.log10)       
+Help on built-in function log10 in module math:
+
+log10(x, /)
+    Return the base 10 logarithm of x.
+>>>math.log10(10)           
+1.0
+>>>math.log10(100)
+2.0
+>>>math.log10(105)           
+>>>2.0211892990699383
+```
+
+- Функция sqrt
+
+```python
+>>>help(math.sqrt)         
+Help on built-in function sqrt in module math:
+
+sqrt(x, /)
+    Return the square root of x.
+>>>math.sqrt(16)           
+4.0
+>>>math.sqrt(25)           
+5.0
+```
+
+- Функция ceil(округление в большую сторону)
+
+```python
+help(math.ceil)         
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+    
+    This is the smallest integer >= x.
+
+>>>math.ceil(4.56)           
+5
+>>>math.ceil(130.1)            
+131
+```
+
+- Функция floor(округление в меньшую сторону)
+
+```python
+>>>help(math.floor)           
+Help on built-in function floor in module math:
+
+floor(x, /)
+    Return the floor of x as an Integral.
+    
+    This is the largest integer <= x.
+
+>>>math.floor(99.999)          
+99
+```
+
+- Функция pi
+
+```python
+>>>math.pi
+3.141592653589793
+```
+
+
+### 4. Функции из модуля cmath – совокупность функций для работы с комплексными числами.
+
+```python
+>>>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 – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+random - равномерно распределенное случайное число;  
+uniform- равномерно распределенное случайное число в диапазоне, заданном двумя аргументами;  
+randint - случайные целые числа в диапазоне от значения первого аргумента до значения второго; gauss - нормально распределенное случайное число с средним равным первому аргументу и стандартным отклонением равным второму аргументу; choice - случайный выбор из совокупности указанной в аргументе; shuffle - случайная перестановка элементов списка в аргументе; sample - случайный выбор подмножества элементов из списка в первом аргументе (количество элементов равно числу, указанному во втором аргументе); betavariate - случайное число с бета-распределением, где альфа равна первому аргументу, а бета равна второму аргументу; gammavariate - случайное число с гамма-распределением, где альфа равна первому аргументу, а бета равна второму аргументу. 
+
+```python
+>>>import random
+>>>dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_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 инициализирует начальное состояние генератора псевдослучайных чисел стартовым ключом, чтобы последовательность стала предсказуемой и при повторном запуске с тем же ключом получалась ровно такая же “случайность” — это нужно для воспроизводимости результатов
+одинковый seed = одинаковые числа, графики, выборки
+
+- Функци random(равномерно распределенное случайное число от 0 до 1)
+
+```python
+>>>random.random()
+0.15224090837130377
+>>>random.random()
+0.8451183120672832
+>>>random.random()
+0.8392090272295469
+```
+
+- Функция uniform (равномерно распределенное случайное число)
+
+```python
+>>>random.uniform(1, 5)
+1.4822447721210175
+>>>random.uniform(1, 500)
+11.101749613668387
+```
+
+- Функция gauss(нормально распределенное случайное число)
+
+```python
+>>>random.gauss(1, 5)
+5.705708773458442
+>>>random.gauss(12, 57)
+-14.33510203993609
+```
+
+- Функция randint(случайные целые числа)
+
+```python
+>>>random.randint(3, 19)
+4
+>>>random.randint(3, 19)
+5
+```
+
+- Функция choice (случайный выбор из совокупности)
+
+```python
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+90.3
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+(3+5j)
+```
+
+- Функця shuffle (случайная перестановка элементов списка)
+
+```python
+>>>lst = [True, "ababba", 35, 90.3, 3+5j]
+>>>random.shuffle(lst)
+>>>lst
+[35, 'ababba', 90.3, (3+5j), True]
+```
+
+- Функция sample (случайный выбор подмножества элементов)
+
+```python
+>>>random.sample(lst, 5)
+['ababba', 90.3, True, (3+5j), 35]
+>>>random.sample(lst, 1)
+['ababba']
+```
+
+- Функция betavariate(случайное число с бета-распределением)
+
+```python
+>>>random.betavariate(1, 2)
+0.3174347054415454
+>>>random.betavariate(1, 2)
+0.17833765040946833
+```
+
+- Функция gammavariate(случайное число с гамма-распределением)
+
+```python
+>>>random.gammavariate(2, 5)
+18.174658510394487
+>>>random.gammavariate(2, 5)
+29.01757536081825
+```
+
+- Создание списка с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям и с любыми допустимыми значениями параметров этих распределений.
+
+```python
+>>>ls_r = [0] * 4
+>>>ls_r[0] = random.uniform(0, 5)
+>>>ls_r[1] = random.gauss(0, 2)
+>>>ls_r[2] = random.betavariate(1, 3)
+>>>ls_r[3] = random.gammavariate(3, 2)
+>>>ls_r
+[3.940448252721481, -0.9946853417283795, 0.04299068887668711, 8.97265061419367]
+```
+
+### 6. Функции из модуля time – работа с календарем и со временем.
+
+- UNIX время и текущее время
+	time - возвращает время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г; gmtime - возвращает объект класса struct_time, содержащий полную информацию о текущем времени (UTC): год (tm_year), месяц (tm_mon), день tm_mday)...; localtime - для получения «местного» времени (которое стоит на компьютере); asctime - преобразовывает представление времени из кортежа в строку (просто отображает время в формате строки); ctime - преобразовывает время в секундах, прошедшего с начала эпохи, в строку; sleep - прерывает работу программы на заданное время в секундах; mktime - преобразовает время из типа кортежа или struct_time в число секунд с начала эпохи.
+```python
+>>>import time
+>>>dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+c1=time.time()
+c1
+1759739386.6377628
+>>>c2=time.time()-c1 # временной интервал в секундах, со времени ввода предыдущей инструкции
+>>>c2
+26.08662247657776
+>>>dat = time.gmtime() # Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC)
+>>>dat.tm_mon # получение номера месяца
+10
+>>>dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=6, tm_hour=8, tm_min=57, tm_sec=30, tm_wday=0, tm_yday=279, tm_isdst=0)
+```
+
+``` python
+
+- Текущее время с учетом часового пояса
+
+```python
+>>>mestn = time.localtime()                     
+>>>list(mestn)                   
+[2025, 10, 6, 12, 18, 35, 0, 279, 0]
+```
+
+- Функция asctime (преобразование представления времени из кортежа в строку)
+
+```python
+>>>time.asctime(mestn)
+                      
+'Mon Oct  6 12:18:35 2025'
+```
+
+- Функция ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку)
+
+```python
+>>>time.ctime()
+                      
+'Mon Oct  6 12:22:01 2025'
+```
+
+- Функция sleep (прерывание работы программы на заданное время)
+
+```python
+>>>time.sleep(5)
+```
+
+- Функция mktime (преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи)
+
+```python
+>>>time.mktime(mestn)
+                      
+1759742315.0
+```
+
+- Обратное преобразование из секунд в местное время
+
+```python
+>>>time.localtime(c1)
+                      
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=6, tm_hour=11, tm_min=29, tm_sec=46, tm_wday=0, tm_yday=279, tm_isdst=0)
+```
+
+### 7. Графические функции
+
+Импортируем модули mathplotlib и pylab для построения графика.
+
+-Создание и отображение графика x(t):
+
+``` python
+>>>import matplotlib
+>>>import pylab
+
+>>>x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x10f66a490>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 47.04444444444444, 'время')
+>>> pylab.ylabel('сигнал')
+Text(93.94444444444443, 0.5, 'сигнал')
+>>> pylab.show()
+```
+![[Figure1.png]]
+
+- Рассмотрим способ построения нескольких графиков на одном рисунке.
+
+``` python
+>>> import matplotlib
+>>> import pylab
+>>> X1 = [12, 6, 8, 10, 7]
+>>> X2 = [5, 7, 9, 11, 13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x10e9f2490>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x1119f7390>]
+>>> pylab.show()
+```
+![[Figure2.png]]
+- Теперь изучим возможность построения круговой диаграммы.
+
+```python
+>>>region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x10ea60ad0>, <matplotlib.patches.Wedge object at 0x111a69090>, <matplotlib.patches.Wedge object at 0x111a69450>, <matplotlib.patches.Wedge object at 0x111a696d0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+```
+![[Figure3.png]]
+- Построение гистограммы
+
+```python
+>>>pylab.show()
+>>>data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+>>>pylab.hist(data)
+(array([1., 0., 2., 0., 0., 3., 0., 2., 0., 1.]), array([1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ]), <BarContainer object of 10 artists>)
+>>>pylab.title('Простая гистограмма')
+Text(0.5, 1.0, 'Простая гистограмма')
+>>>pylab.xlabel('Значения')
+Text(0.5, 0, 'Значения')
+>>>pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+>>>pylab.show()
+```
+![[Figure4.png]]
+- Построение столбиковой диаграммы
+
+```python
+>>> import matplotlib
+>>> import pylab
+
+>>> data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+
+# Гистограмма
+>>> pylab.hist(data, bins=10, edgecolor='black')
+>>> pylab.title('Простая гистограмма')
+>>> pylab.xlabel('Значения')
+>>> pylab.ylabel('Частота')
+>>> pylab.grid(axis='y', alpha=0.3)
+>>> pylab.show()
+
+```
+![[Figure5.png]]
+
+### 8. Статистический модуль statics
+
+```python
+>>>import statistics
+>>>data = [10, 20, 30, 40, 50]
+>>> statistics.mean(data)
+30
+>>> statistics.median(data)
+30
+>>> statistics.stdev(data)
+15.811388300841896
+>>> statistics.variance(data)
+250
+>>> statistics.mode(data)
+10
+```
+
+### 9. Завершение работы

TEMA4/task.md

@@ -0,0 +1,47 @@
+# Общее контрольное задание по теме 4
+Подольский Никита, А-01-23
+## Задание 
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+• Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+
+• Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+• Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+• Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+• Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+• Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение 
+``` python
+>>> import cmath
+>>> import random
+>>> import time
+>>> divmod((round(cmath.phase(0.2 + 0.8j), 2) * 20), 3)
+(8.0, 2.6000000000000014)
+>>> msc_t  = time.localtime()
+>>> msc_t
+>>> time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=21, tm_sec=49, tm_wday=4, tm_yday=297, tm_isdst=0)
+>>> nows = str(msc_t.tm_hour) + " " + str(msc_t.tm_min)
+>>> nows
+'11 21'
+>>> liist = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+>>> random.sample(liist, 3)
+['среда', 'воскресенье', 'четверг']
+>>> random.choice(range(14, 33, 3))
+29
+>>> N = round(random.gauss(15,4))
+>>> N
+19
+>>>spis = list('qawsedrftgyhujikol')
+>>> spis = list('qawsedrftgyhujikolp')
+>>> random.sample(spis, N)
+['i', 't', 'h', 'q', 'j', 's', 'f', 'k', 'u', 'a', 'g', 'l', 'p', 'o', 'd', 'w', 'y', 'r', 'e']
+>>> (time.mktime(time.localtime()) - time.mktime(msc_t)) / 60
+5.533333333333333
+
+
+```