добавил ИКЗ

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/IKZ_TEMA4.py

@@ -0,0 +1,18 @@
+import random
+import math
+
+mu = -3.5
+sigma = 5
+
+random.seed(42)
+
+spisok = []
+for i in range(3):
+    spisok.append(random.gauss(mu, 5))
+
+kortezh = tuple(math.sin(x) for x in spisok)
+suma = sum(kortezh)
+
+print('список:', spisok)
+print('кортеж синусов:', kortezh)
+print('сумма:', suma)

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
+
+
+```

TEMA4/test.md

@@ -0,0 +1,33 @@
+# Индивидуальное контрольное задание по теме 4
+Подольский Никита, А-01-23
+
+## Задание (Вариант 3)
+
+Создайте список с 3 элементами – нормально распределенными случайными числами с математическим ожиданием -3.5 и дисперсией 25. Составьте кортеж с элементами, равными синусам от элементов первого списка. Рассчитайте сумму элементов этого кортежа.
+
+## Решение
+### 1
+``` python
+>>> import random
+>>> import math
+
+>>> mu = -3.5
+>>> sigma = 5
+>>> 
+>>> random.seed(42)
+>>> 
+>>> spisok = []
+>>> for i in range(3):
+	    spisok.append(random.gauss(mu, 5))
+
+>>> kortezh = tuple(math.sin(x) for x in spisok)
+>>> suma = sum(kortezh)
+
+>>> print('список:', spisok)
+>>> print('кортеж синусов:', kortezh)
+>>> print('сумма:', suma)
+список: [-4.220451647889642, -4.364518001657596, -4.056579307838312]
+кортеж синусов: (0.8814194445437432, 0.940100620060998, 0.7925544486907984)
+сумма: 2.61407451329554
+
+```

TEMA5/report.md

@@ -0,0 +1,357 @@
+# Отчет по теме 5
+Подольский Никита, А-01-23
+### 1. Запуск интерактивной оболочки IDLE.
+
+### 2. Ветвление по условию – управляющая инструкция if.
+
+- dohod:
+``` python 
+>>>porog = 5
+>>>rashod1 = 8
+>>>rashod2 = 6
+>>>if rashod1 >= porog:
+    dohod = 12
+
+if rashod1 >= porog:
+    dohod = 12
+elif rashod2 == porog:
+    dohod = 0
+else:
+    dohod = 8
+
+>>>print(dohod)
+# Выполним операцию для двух случаев
+>>>rashod2 = 4
+>>>if rashod1 >= 3 and rashod2 == 4:
+    dohod = rashod1
+    if rashod2 == porog or rashod1 < rashod2:
+        dohod = porog        
+>>>print(dohod)
+8 # Выполнилось одно условие
+>>>porog = 4
+>>>if rashod1 >= 3 and rashod2 == 4:
+    dohod = rashod1
+    if rashod2 == porog or rashod1 < rashod2:
+        dohod = porog 
+>>>print(dohod)
+4 # Выполнились оба условия
+```
+- Операция с множественным ветвлением линий потока:
+``` python
+>>>if porog == 3: # Не подходит
+    dohod = 1
+elif porog == 4: # Подходит
+    dohod = 2
+elif porog == 5: # Игнорируется
+    dohod = 3
+else: # Игнорируется
+    dohod = 0  
+>>>print(dohod)
+2
+```
+
+- Инструкции, записывающиеся в одну строку в операторе присваивания.
+<Объект>=<значение 1> if <условие>  else <значение 2>
+
+``` python
+>>>dohod = 2 if porog >- 4 else 0
+>>>print(dohod)
+2
+>>>if porog >= 5: rashod1 = 6; rashod2 =  0 # porog = 4
+>>>print(rashod1)
+8
+>>>print(rashod2)
+4
+>>>porog = 6
+>>>if porog >= 5: rashod1 = 6; rashod2 =  0
+>>>print(rashod1)
+6
+>>>print(rashod2)
+0
+```
+
+### 3. Цикл по перечислению – управляющая инструкция for.
+Общее правило написания:
+for <Объект-переменная цикла> in <объект>:
+<отступы><Блок инструкций 1 – тело цикла>
+else: 
+<отступы ><Блок инструкций 2 – если в цикле не сработал break>]
+
+
+#### 3.1. Простой цикл.
+Выполняем цикл, который проходится по значениям от 3 до 18(не включительно) с шагом 3 и суммирует их в переменную temperatura.
+
+``` python
+>>>temperatura = 5
+>>>for i in range(3, 18, 3):
+    temperatura += i
+    
+>>>temperatura
+50
+```
+#### 3.2. Более сложный цикл.
+
+``` python
+>>>sps = [2, 15, 14, 18]
+>>>for k in sps:
+    if len(sps) <= 10: 
+    sps.append(sps[0])
+    else: break
+>>>sps
+[2, 15, 14, 18, 2, 2, 2, 2, 2, 2, 2]
+```
+
+Цикл идет по списку `sps`, который **меняется** во время выполнения, потому что мы добавляем туда элементы через `.append(sps[0])`.
+
+- Это значит, что по мере роста списка цикл будет продолжаться, пока не сработает `break`. Если бы не было ограничения, цикл стал бы бесконечным.
+- Итерация происходит по "живому" списку, который удлиняется прямо во время обхода.
+
+``` python
+>>>sps = [2, 15, 14, 8]
+for k in sps[:]:
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break
+>>>sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+```
+
+- С `[:]` создаётся копия, и цикл не видит добавленные элементы: работает ровно столько раз, сколько длина оригинала
+#### 3.3. : Cоздание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране.
+
+``` python
+import random as rn
+sps5 = []
+for i in range(10):
+    sps5.append(rn.randint(1, 100))
+    ss = sum(sps5)
+    if ss > 500: break
+else:
+    print(ss)
+ 
+435
+>>> sps5
+[10, 98, 65, 13, 56, 26, 1, 88, 55, 23]
+```
+
+#### 3.4. Пример с символьной строкой
+``` python
+>>>stroka='Это – автоматизированная система'
+>>>stroka1 = " "
+>>>for ss in stroka:
+    stroka1 += " " + ss
+>>>print(stroka1)
+  Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а
+```
+Переменная **stroka** содержит исходную фразу: _"Это – автоматизированная система"_.  
+Переменная **stroka1** изначально пустая.
+Далее в цикле **for** мы последовательно перебираем каждый символ строки **stroka**.  
+На каждом шаге к **stroka1** добавляется пробел и текущий символ.
+В итоге получается новая строка, в которой каждый символ исходного текста выведен через пробел — поэтому вывод выглядит «растянутым».
+ 
+
+#### 3.5. Конструкция list comprehension. 
+Пример: создание списка с синусоидальным сигналом.(Внутри квадратных скобок записано выражение-генератор)
+``` python
+>>>import math
+>>>sps2 = [math.sin(i * math.pi / 5 + 2) for i in range(100)]
+>>>sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+>>>import pylab
+>>>pylab.plot(sps2, label = 'Синусоидальный сигнал', color = 'red')
+[<matplotlib.lines.Line2D object at 0x000001A6371A2CE0>]
+>>>pylab.show()
+```
+![[figure0.png]]
+
+### 4. Цикл «пока истинно условие» – управляющая инструкция while. 
+Общее правило написания:
+while <Условие>:
+<отступы><Блок инструкций 1 – тело цикла>
+else:
+<отступы><Блок инструкций 2 – если в цикле не сработал break>]
+
+#### 4.1. Цикл со счетчиком.
+``` python
+>>>rashod = 300
+>>>while rashod:
+    print("Расход=", rashod)
+    rashod -= 50   
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Цикл завершился из-за того, что расход стал равен 0, а 0 в свою очередь воспринимается как False.
+
+
+#### 4.2. Пример с символьной строкой.
+``` python
+>>>import math
+>>>stroka = 'Расчет процесса в объекте регулирования'
+>>>i = 0
+>>>sps2 = []
+>>>while i < len(stroka):
+    r = 1 - 2/(1+math.exp(0.1 * i))
+    sps2.append(r)
+    print('Значение в момент', i, "=", r)
+    i += 1
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+>>>pylab.plot(sps2, label = 'Сигнал на выходе инерционного звена', color = 'red')
+[<matplotlib.lines.Line2D object at 0x000001A6372762F0>]
+>>>pylab.show()
+```
+![[Figure_1.png]]
+
+#### 4.3. Определение, является ли число простым (делится только на самого себя или 1).
+``` python
+>>>chislo=267   #Проверяемое число
+>>>kandidat =chislo // 2 		# Для значений chislo > 1
+>>>while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+>>>else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+267 имеет множитель 89
+```
+Программа работает так: переменная **kandidat** — это возможный делитель числа.  
+Мы начинаем проверку с половины числа, потому что делитель не может быть больше этого значения.
+
+Дальше в цикле мы уменьшаем **kandidat** и на каждом шаге проверяем:  
+делится ли число на kandidat без остатка.  
+Если делится — значит число **составное**, и мы сразу выходим из цикла.
+
+Если же цикл дошёл до конца и ни разу не нашёл делитель, значит число **простое**.
+
+Дополним программу так, чтобы выявить все простые числа в диапазоне от 250 до 300.
+``` python
+>>>for i in range(250, 301):
+    chislo = i
+    kandidat = chislo // 2
+    while kandidat > 1:
+        if chislo % kandidat == 0:
+            print(chislo, 'имеет множитель', kandidat)
+            break
+        kandidat -= 1
+    else:
+        print(chislo, 'является простым!')   
+250 имеет множитель 125
+251 является простым!
+252 имеет множитель 126
+253 имеет множитель 23
+254 имеет множитель 127
+255 имеет множитель 85
+256 имеет множитель 128
+257 является простым!
+258 имеет множитель 129
+259 имеет множитель 37
+260 имеет множитель 130
+261 имеет множитель 87
+262 имеет множитель 131
+263 является простым!
+264 имеет множитель 132
+265 имеет множитель 53
+266 имеет множитель 133
+267 имеет множитель 89
+268 имеет множитель 134
+269 является простым!
+270 имеет множитель 135
+271 является простым!
+272 имеет множитель 136
+273 имеет множитель 91
+274 имеет множитель 137
+275 имеет множитель 55
+276 имеет множитель 138
+277 является простым!
+278 имеет множитель 139
+279 имеет множитель 93
+280 имеет множитель 140
+281 является простым!
+282 имеет множитель 141
+283 является простым!
+284 имеет множитель 142
+285 имеет множитель 95
+286 имеет множитель 143
+287 имеет множитель 41
+288 имеет множитель 144
+289 имеет множитель 17
+290 имеет множитель 145
+291 имеет множитель 97
+292 имеет множитель 146
+293 является простым!
+294 имеет множитель 147
+295 имеет множитель 59
+296 имеет множитель 148
+297 имеет множитель 99
+298 имеет множитель 149
+299 имеет множитель 23
+300 имеет множитель 150
+```
+Здесь просто добавляется for для перебора значений.
+
+#### 4.4. Инструкция continue
+Инструкция continue, которая не вызывает завершения цикла, но завершает его текущий виток и обеспечивает переход к следующему витку.
+``` python
+>>>x =   [rn.randint(-25, 40) for i in range (20)]
+>>>x
+[35, 21, -14, 21, -15, 1, -9, -7, -15, 2, 32, 11, 38, 32, -13, -21, 31, -10, -20, 15]
+>>>for y in x:
+    if y < 0: continue
+    print(y, ">0")
+else: print("stop")
+35 >0
+21 >0
+21 >0
+1 >0
+2 >0
+32 >0
+11 >0
+38 >0
+32 >0
+31 >0
+15 >0
+stop
+```
+
+### 5. Завершение сеанса в среде IDLE

TEMA5/task.md

@@ -0,0 +1,125 @@
+# Общее контрольное задание по теме 5
+Подольский Никита, А-01-23
+## Задание 
+- Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+- Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+- Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение 
+``` python
+>>> alphabet = 'abcdefghijklmnopqrstuvwxyz'
+>>> text = "We visited the Louvre Museum in Paris last summer"
+>>> for now in range(len(text)):
+	low = text.lower()
+	letter = low[now]
+	if not letter in alphabet:
+		continue
+	else:
+		print("Буква ", letter, " имеет ", alphabet.index(letter) + 1,
+                      "порядковый номер в алфавите")
+
+Буква  w  имеет  23 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  v  имеет  22 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  t  имеет  20 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  d  имеет  4 порядковый номер в алфавите
+Буква  t  имеет  20 порядковый номер в алфавите
+Буква  h  имеет  8 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  l  имеет  12 порядковый номер в алфавите
+Буква  o  имеет  15 п  рядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  v  имеет  22 порядковый номер в алфавите
+Буква  r  имеет  18 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  n  имеет  14 порядковый номер в алфавите
+Буква  p  имеет  16 порядковый номер в алфавите
+Буква  a  имеет  1 порядковый номер в алфавите
+Буква  r  имеет  18 порядковый номер в алфавите
+Буква  i  имеет  9 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  l  имеет  12 порядковый номер в алфавите
+Буква  a  имеет  1 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  t  имеет  20 порядковый номер в алфавите
+Буква  s  имеет  19 порядковый номер в алфавите
+Буква  u  имеет  21 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  m  имеет  13 порядковый номер в алфавите
+Буква  e  имеет  5 порядковый номер в алфавите
+Буква  r  имеет  18 порядковый номер в алфавите
+
+
+>>> text = """Создайте список со словами из задания данного пункта Для этого
+списка определите есть ли в нем некоторое заданное значение и выведите соответствующее
+сообщение либо о нахождении элемента либо о его отсутствии в списке проверить как с
+имеющимся так и с отсутствующим словом"""
+>>> lst = text.split(" ")
+>>> lst
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого',
+ 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и',
+ 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо',
+ 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и',
+ 'с', 'отсутствующим', 'словом']
+ 
+>>> target = "список"
+>>> for now in lst:
+	if now == target:
+		print ("Такое слово есть")
+		break
+else:
+	print("Такого слова нет")
+
+Такое слово есть :)
+
+>>> target = "кот"
+>>> for now in lst:
+	if now == target:
+		print ("Такое слово есть")
+		break
+else:
+	print("Такого слова нет")
+
+Такого слова нет
+
+
+>>> studs = ['Bushmanov', 'Podolskiy', 'Melnikov']
+>>> summer_marks = [4.25, 4.15, 5.00]
+>>> studs2 = ['Melnikov', 'Podolskiy','Bushmanov']
+>>> winter_marks = [4.85, 4.35, 4.23]
+>>> student = input("Введите фамилию: ")
+>>> while student != "q":
+	if (student in studs) and (student in studs2):
+		sum_ans = summer_marks[studs.index(student)]
+		win_ans = winter_marks[studs2.index(student)]
+		print("Балл летом: ", sum_ans, "\nЗимой: ", win_ans, "\nСредний :",
+                    (sum_ans + win_ans)/2)
+	else:
+		print("Такого студента нет :(")
+	student = input("Введите фамилию (q для выхода):")
+	
+Введите фамилию: Bushmanov
+Балл летом:  4.25 
+Зимой:  4.23 
+Средний : 4.24
+Введите фамилию (q для выхода): Podolskiy
+Балл летом:  4.15
+Зимой:  4.35
+Средний : 4.25
+Введите фамилию (q для выхода): Melnikov
+Балл летом:  5.00
+Зимой:  4.85
+Средний : 4.925
+Введите фамилию (q для выхода): q
+```

TEMA5/test.md

@@ -0,0 +1,41 @@
+# Индивидуальное контрольное задание по теме 5
+Подольский Никита, А-01-23
+
+## Задание (Вариант 5)
+
+По заданному списку со случайными числовыми элементами (любое распределение) рассчитайте число элементов списка, значение которых превышает  значение, равное полусумме наименьшего и наибольшего элементов списка.
+
+## Решение
+### 1
+``` python
+>>> import random
+
+>>> n = int(input("Введите количество элементов списка: "))
+5
+>>> numbers = []
+>>> for i in range(n):
+		    numbers.append(random.randint(-100, 100))
+
+>>> print("Исходный список:", numbers)
+[-1, 96, 21, -73, 3]
+
+>>> min_elem = min(numbers)
+>>> max_elem = max(numbers)
+
+>>> half_sum = (min_elem + max_elem) / 2
+
+>>> count = 0
+>>> for x in numbers:
+	    if x > half_sum:
+	        count += 1
+
+# 6. Выводим результаты
+>>> print("Минимальный элемент:", min_elem)
+Минимальный элемент: -73
+>>> print("Максимальный элемент:", max_elem)
+Максимальный элемент: 96
+>>> print("Полусумма min и max:", half_sum)
+Полусумма min и max: 11.5
+>>> print("Количество элементов, больших полусуммы:", count)
+Количество элементов, больших полусуммы: 2
+```

TEMA6/ zapis1.txt

@@ -0,0 +1,8 @@
+{\rtf1\ansi\ansicpg1251\cocoartf2867
+\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
+{\colortbl;\red255\green255\blue255;}
+{\*\expandedcolortbl;;}
+\paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural\partightenfactor0
+
+\f0\fs24 \cf0 123}

TEMA6/Stroka.txt

@@ -0,0 +1 @@
+запись строки в файл

TEMA6/report.md

@@ -0,0 +1,337 @@
+# Отчет по Теме 6
+Подольский Никита, А-01-23
+## 1. Начало работы
+Запуск IDLE, установление рабочего каталога
+
+## 2. Вывод данных на экран дисплея
+### 2.1 Вывод в командной строке.
+
+```python
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+### 2.2  Вывод с использованием функции  print
+
+```python
+
+ >>> fff=234.5;gg='Значение температуры = '
+ >>> print(gg, fff) #Можно вывести несколько объектов за одно обращение к функции
+Значение температуры =  234.5
+ >>> print(gg, fff, sep='/')
+Значение температуры = /234.5
+ >>> print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+ >>> print()
+
+ >>> print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+ >>> print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+### 2.3 Вывод с использованием метода write  объекта sys.stdout
+
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных. Обычно это – экран дисплея. Объект находится в модуле sys, который надо импортировать
+
+```python
+>>> import sys
+>>> sys.stdout.write('Функция write')
+Функция write13
+>>> sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+
+## 3.Ввод данных с клавиатуры.
+
+```python
+
+>>> psw=input('Введите пароль:')
+Введите пароль:12345
+>>> type(psw)
+<class 'str'>
+>>> while True:
+    znach=float(input('Задайте коэф.усиления ='))
+    if znach<17.5 or znach>23.8:
+        print('Ошибка!')
+    else:
+        break
+
+    
+Задайте коэф.усиления =15.4
+Ошибка!
+Задайте коэф.усиления =21.6
+>>> import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+
+```
+
+## 4.Ввод-вывод при работе с файлами.
+
+### 4.1. Функции для работы с путем к файлу.
+
+```python
+>>> import os
+>>> os.getcwd()
+'/Users/nickpod/Documents'
+>>> Podolsky = os.getcwd()
+>>> print(Podolsky)
+'/Users/nickpod/Documents'
+
+```
+
+#### 4.2
+
+```python
+>>> os.chdir("/Users/nickpod/Documents/python-labs")
+>>> os.getcwd()
+'/Users/nickpod/Documents/python-labs'
+>>> os.mkdir("aa")  #Создание папки в рабочем каталоге
+>>> os.rmdir("aa")  #Удаление папки
+>>> os.path.isdir("/Users/nickpod/Documents/python-labs")  #Проверка существует ли каталог
+True
+>>> os.path.abspath("OPLATA.DBF")
+'/Users/nickpod/Documents/python-labs/README.md'
+>>> fil=os.path.abspath("OPLATA.DBF")
+>>> fil
+'/Users/nickpod/Documents/python-labs/OPLATA.DBF'
+>>> drkt=os.path.dirname(fil)
+>>> drkt
+'/Users/nickpod/Documents/python-labs'
+>>> os.path.basename(fil)
+'OPLATA.DBF'
+>>> os.path.split(fil)
+('/Users/nickpod/Documents/python-labs', 'OPLATA.DBF')
+>>> os.path.exists(fil)
+True
+>>> os.path.isfile(fil)
+True
+>>> os.path.isfile(os.path.dirname(fil)+'fil1.txt')
+False
+>>> os.listdir(".")
+['TEMA4', '.DS_Store', 'TEMA3', 'TEMA2', 'TEMA5', 'README.md', '.gitignore', 'TEMA9', 'TEMA0', 'TEMA7', 'TEMA6', 'TEMA1', 'TEMA8', '.git']
+```
+![](Pasted%20image%2020251124095143.png)
+
+### 4.3.Открытие файла для записи или чтения данных – функция open.
+
+```python
+>>> fp=open(file=drkt+'\\zapis1.txt',mode='w')
+>>> drkt
+'/Users/nickpod/Documents/python-labs'
+>>> dir(fp)
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+>>> fp=open(drkt+'\\zapis1.txt','w')
+>>> fp=open('zapis1.txt','w')
+>>> fp
+<_io.TextIOWrapper name='zapis1.txt' mode='w' encoding='UTF-8'>
+>>> fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+>>> drkt
+'/Users/nickpod/Documents/python-labs'
+>>> fp.close()
+
+```
+Здесь *fp* – это файловый объект, который в других языках программирования обычно называют файловой переменной. Он сохраняет ссылку на открываемый файл и позволяет в дальнейшем ссылаться на файл, не указывая путь и имя открытого файла.  
+w – запись с созданием нового файла или перезапись существующего файла,
+w+ - чтение и запись/перезапись файла,
+r – только чтение (это значение - по умолчанию),
+r+ - чтение и/или запись в существующий файл,
+a – запись в конец существующего файла или, если его нет, запись с созданием файла,
+a+ - то же, что и в «a», но с возможностью чтения из файла.
+Если файл – символьный, то его тип обозначается «t», но это – значение по умолчанию и его можно не указывать. В символьный файл можно записывать только объекты типа str. Объекты других типов надо перед записью преобразовать к этому типу.
+
+
+### 4.5. Запись информации в файл с помощью метода write.
+
+```python
+>>> sps=list(range(1,13))
+>>> fp2=open('zapis3.txt','w')
+>>> fp2.write(str(sps[:4])+'\n')
+13
+>>> fp2.write(str(sps[4:8])+'\n')
+13
+>>> fp2.write(str(sps[8:])+'\n')
+16
+>>> fp2.close()
+```
+
+Числа `13`, `13`, `16`, которые выводит интерпретатор, — это просто сколько символов он записал в файл при каждом вызове `write`.
+
+**Результат:** 
+![](Pasted%20image%2020251124102125.png)
+
+
+```python
+>>> sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+>>> fp3=open('zapis4.txt','w')
+>>> for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+
+	
+11
+11
+12
+>>> fp3.close()
+>>> gh=open('zapis5.txt','w')
+>>> for r in sps3:
+	gh.write(r[0]+' '+str(r[1])+'\n')
+
+	
+12
+12
+13
+>>> gh.close()
+
+```
+
+**Результат:** 
+
+![](Pasted%20image%2020251124102259.png)
+![](Pasted%20image%2020251124102316.png)
+### 4.6. Первый способ чтения информации из текстового файла.
+
+```python
+
+>>> sps1=[]
+>>> fp=open('zapis3.txt')
+>>> for stroka in fp:
+	stroka=stroka.rstrip('\n')
+	stroka=stroka.replace('[','')
+	stroka=stroka.replace(']','')
+	sps1=sps1+stroka.split(',')
+
+	
+>>> fp.close()
+>>> print(sps1)
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+>>> for i in range(len(sps1)):
+               sps1[i] = int(sps1[i])
+
+               
+>>> sps1==sps
+True
+
+```
+
+### 4.7. Чтение информации из файла с помощью метода read.
+
+```python
+
+>>> fp=open('zapis3.txt')
+>>> stroka1=fp.read(12)
+>>> stroka2=fp.read()
+>>> fp.close()
+>>> print(stroka1)
+[1, 2, 3, 4]
+>>> print(stroka2)
+
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+
+```
+
+### 4.8. Чтение информации с помощью методов readline и readlines.
+
+```python
+
+>>> fp=open('zapis3.txt')
+>>> strok1 = fp.readline()
+>>> strok1
+'[1, 2, 3, 4]\n'
+>>> print(strok1)
+[1, 2, 3, 4]
+
+
+>>> fp.close()
+>>> fp=open('zapis3.txt');stroka1=fp.readlines()
+>>> print(stroka1)
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+>>> fp.close()
+
+```
+
+### 4.9. Ввод-вывод объектов с использованием функций из модуля pickle
+В модуле **pickle** содержатся функции для работы с бинарными файлами, в которые могут последовательно записываться или считываться целиком один или несколько объектов из оперативной памяти.
+
+```python
+
+>>> import pickle
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+>>> fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+>>> pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+>>> fp.close()
+>>> fp=open('zapis6.mnz','rb')
+>>> mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+>>> fp.close()
+
+
+>>> mnoz2 == mnoz1
+True
+>>> mnoz1
+{'book', 'table', 'pen', 'iPhone'}
+>>> mnoz2
+{'table', 'book', 'pen', 'iPhone'}
+>>> sps3
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+>>> fp=open('zapis7.2ob','wb')
+>>> pickle.dump(mnoz1,fp)
+>>> pickle.dump(sps3,fp)
+>>> fp.close()
+>>> fp=open('zapis7.2ob','rb')
+>>> obj1=pickle.load(fp)  #Первое обращение к load читает первый объект
+>>> obj2=pickle.load(fp)  #Второе – читает второй
+>>> fp.close()
+>>> sps3==obj2
+True
+>>> mnoz1==obj1
+True
+```
+![](Pasted%20image%2020251124104208.png)
+![](Pasted%20image%2020251124104800.png)
+## 5.Перенаправление потоков ввода и вывода данных.
+
+```python
+
+>>> import sys
+>>> vr_out=sys.stdout  #Запоминаем текущий поток вывода
+>>> fc=open('Stroka.txt','w') #Откроем файл вывода
+>>> sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+>>> print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+>>> sys.stdout=vr_out  #Восстановление текущего потока
+>>> print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+запись строки на экран
+>>> fc.close()
+
+
+>>> tmp_in = sys.stdin #Запоминаем текущий поток ввода
+>>> fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+>>> sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+>>> sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+>>> while True:
+	try:
+		line = input () #Считываем из файла строку
+		print(line)  # Отображаем считанное
+	except EOFError:
+		break
+
+	
+запись строки в файл
+>>> fd.close()
+>>> sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+
+```
+
+![](Pasted%20image%2020251124104911.png)
+## 6. Закрытие среды IDLE

TEMA6/task.md

@@ -0,0 +1,75 @@
+# Общее контрольное задание по теме 6
+Подольский Никита, А-01-23
+## Задание 
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+·       Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+·       Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+·       Записывается кортеж в бинарный файл.
+
+·       Записывается в этот же файл список и закрывается файл.
+
+·       Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+·       Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+
+·       Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Решение 
+``` python
+import random
+import pickle
+
+# фиксируем сид
+SEED = 12345
+random.seed(SEED)
+
+rn = tuple(str(random.randint(6, 56)) for i in range(125))
+print(rn)
+
+spis = ["Podolsky", "Bushmanov", "Terehov", "Melnikov", "Zhalnin"]
+
+fp = open('data.bin', 'wb')
+pickle.dump(rn, fp)
+pickle.dump(spis, fp)
+fp.close()
+
+fp = open('data.bin', 'rb')
+rn1 = pickle.load(fp)
+print(rn1)
+spis1 = pickle.load(fp)
+fp.close()
+
+if rn == rn1:
+    print("Переменные rn и rn1 совпадают")
+else:
+    print("Переменные rn и rn1 не совпадают")
+
+if spis == spis1:
+    print("Переменные spis и spis1 совпадают")
+else:
+    print("Переменные spis и spis1 не совпадают")
+
+# разбиение кортежа на списки по 5 элементов
+for i in range(0, 125, 5):          # идём по кортежу шагом 5
+    chunk = list(rn1[i:i+5])
+    exec('list' + str(i // 5 + 1) + ' = chunk')
+
+print(list1)
+print(list2)
+print(list5)
+
+
+
+('32', '52', '6', '25', '29', '18', '23', '42', '33', '16', '29', '13', '33', '22', '41', '46', '17', '45', '41', '17', '28', '53', '52', '11', '39', '53', '32', '43', '38', '16', '15', '19', '52', '10', '18', '27', '26', '7', '35', '27', '7', '38', '50', '53', '32', '6', '6', '48', '16', '55', '43', '17', '24', '12', '47', '32', '12', '49', '42', '17', '53', '30', '20', '39', '44', '51', '27', '8', '20', '13', '37', '19', '53', '54', '41', '48', '17', '22', '43', '33', '39', '14', '8', '16', '25', '6', '15', '20', '28', '40', '27', '16', '30', '26', '6', '9', '9', '51', '34', '11', '30', '17', '56', '6', '55', '51', '29', '19', '49', '38', '54', '13', '36', '45', '9', '6', '46', '37', '26', '55', '45', '32', '41', '18', '29')
+('32', '52', '6', '25', '29', '18', '23', '42', '33', '16', '29', '13', '33', '22', '41', '46', '17', '45', '41', '17', '28', '53', '52', '11', '39', '53', '32', '43', '38', '16', '15', '19', '52', '10', '18', '27', '26', '7', '35', '27', '7', '38', '50', '53', '32', '6', '6', '48', '16', '55', '43', '17', '24', '12', '47', '32', '12', '49', '42', '17', '53', '30', '20', '39', '44', '51', '27', '8', '20', '13', '37', '19', '53', '54', '41', '48', '17', '22', '43', '33', '39', '14', '8', '16', '25', '6', '15', '20', '28', '40', '27', '16', '30', '26', '6', '9', '9', '51', '34', '11', '30', '17', '56', '6', '55', '51', '29', '19', '49', '38', '54', '13', '36', '45', '9', '6', '46', '37', '26', '55', '45', '32', '41', '18', '29')
+Переменные rn и rn1 совпадают
+Переменные spis и spis1 совпадают
+['32', '52', '6', '25', '29']
+['18', '23', '42', '33', '16']
+['28', '53', '52', '11', '39']
+
+
+```

TEMA6/task.py

@@ -0,0 +1,41 @@
+import random
+import pickle
+
+# фиксируем сид
+SEED = 12345
+random.seed(SEED)
+
+rn = tuple(str(random.randint(6, 56)) for i in range(125))
+print(rn)
+
+spis = ["Podolsky", "Bushmanov", "Terehov", "Melnikov", "Zhalnin"]
+
+fp = open('data.bin', 'wb')
+pickle.dump(rn, fp)
+pickle.dump(spis, fp)
+fp.close()
+
+fp = open('data.bin', 'rb')
+rn1 = pickle.load(fp)
+print(rn1)
+spis1 = pickle.load(fp)
+fp.close()
+
+if rn == rn1:
+    print("Переменные rn и rn1 совпадают")
+else:
+    print("Переменные rn и rn1 не совпадают")
+
+if spis == spis1:
+    print("Переменные spis и spis1 совпадают")
+else:
+    print("Переменные spis и spis1 не совпадают")
+
+# разбиение кортежа на списки по 5 элементов
+for i in range(0, 125, 5):          # идём по кортежу шагом 5
+    chunk = list(rn1[i:i+5])        # <-- ОТДЕЛЬНАЯ переменная с 5 элементами
+    exec('list' + str(i // 5 + 1) + ' = chunk')
+
+print(list1)
+print(list2)
+print(list5)

TEMA6/test.md

@@ -0,0 +1,78 @@
+# Индивидуальное контрольное задание по теме 6
+Подольский Никита, А-01-23
+
+## Задание (Вариант 2)
+
+M2_2
+
+1)      Запросите у пользователя и введите две границы: XL и XU  интервала значений некоторой переменной.
+
+2)      Создайте список с 59 случайными равномерно распределенными числами из заданного пользователем диапазона значений. 
+
+3)      Разделите этот диапазон на 5 одинаковых непересекающихся интервалов и подсчитайте число элементов списка в каждом таком интервале. Отобразите результат на экране.
+
+4)      Для контроля рассчитайте сумму чисел элементов и отобразите по шаблону: "Общее число элементов в списке =ХХ".
+
+5)      Выведите список в текстовый файл по 4 числа на строке с разделением их запятыми.
+
+## Решение
+### Вариант 2
+``` python
+import random
+
+XL = float(input("Введите XL: "))
+XU = float(input("Введите XU: "))
+
+numbers = []
+for i in range(59):
+    x = XL + (XU - XL) * random.random()
+    numbers.append(x)
+
+h = (XU - XL) / 5.0
+
+count1 = 0
+count2 = 0
+count3 = 0
+count4 = 0
+count5 = 0
+
+for x in numbers:
+    if XL <= x < XL + h:
+        count1 += 1
+    elif XL + h <= x < XL + 2*h:
+        count2 += 1
+    elif XL + 2*h <= x < XL + 3*h:
+        count3 += 1
+    elif XL + 3*h <= x < XL + 4*h:
+        count4 += 1
+    else:  # всё, что выше, уходит в последний интервал
+        count5 += 1
+
+print("Число элементов в интервале 1:", count1)
+print("Число элементов в интервале 2:", count2)
+print("Число элементов в интервале 3:", count3)
+print("Число элементов в интервале 4:", count4)
+print("Число элементов в интервале 5:", count5)
+
+total = count1 + count2 + count3 + count4 + count5
+print("Общее число элементов в списке =", total)
+
+f = open("M2_2vblvod.txt", "w")
+
+i = 0
+while i < len(numbers):
+    # берём кусок из 4 чисел (или меньше, если в конце)
+    line = ""
+    j = i
+    while j < (i + 4) and j < len(numbers):
+        line += str(numbers[j])
+        if j < (i + 3) and j < len(numbers) - 1:
+            line += ","
+        j += 1
+    f.write(line + "\n")
+    i += 4
+
+f.close()
+
+
+```

TEMA6/test.py

@@ -0,0 +1,55 @@
+import random
+
+XL = float(input("Введите XL: "))
+XU = float(input("Введите XU: "))
+
+numbers = []
+for i in range(59):
+    x = XL + (XU - XL) * random.random()
+    numbers.append(x)
+
+h = (XU - XL) / 5.0
+
+count1 = 0
+count2 = 0
+count3 = 0
+count4 = 0
+count5 = 0
+
+for x in numbers:
+    if XL <= x < XL + h:
+        count1 += 1
+    elif XL + h <= x < XL + 2*h:
+        count2 += 1
+    elif XL + 2*h <= x < XL + 3*h:
+        count3 += 1
+    elif XL + 3*h <= x < XL + 4*h:
+        count4 += 1
+    else:  # всё, что выше, уходит в последний интервал
+        count5 += 1
+
+print("Число элементов в интервале 1:", count1)
+print("Число элементов в интервале 2:", count2)
+print("Число элементов в интервале 3:", count3)
+print("Число элементов в интервале 4:", count4)
+print("Число элементов в интервале 5:", count5)
+
+total = count1 + count2 + count3 + count4 + count5
+print("Общее число элементов в списке =", total)
+
+f = open("M2_2vblvod.txt", "w")
+
+i = 0
+while i < len(numbers):
+    # берём кусок из 4 чисел (или меньше, если в конце)
+    line = ""
+    j = i
+    while j < (i + 4) and j < len(numbers):
+        line += str(numbers[j])
+        if j < (i + 3) and j < len(numbers) - 1:
+            line += ","
+        j += 1
+    f.write(line + "\n")
+    i += 4
+
+f.close()

TEMA6/zapis3.txt

@@ -0,0 +1,3 @@
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]

TEMA6/zapis4.txt

@@ -0,0 +1 @@
+Иванов И. 1Петров П. 2Сидоров С. 3

TEMA6/zapis5.txt

@@ -0,0 +1,3 @@
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3

TEMA7/report.md

@@ -0,0 +1,575 @@
+# Отчет по Теме 7
+Подольский Никита, А-01-23
+## 1 Запуск интерактивной оболочки IDLE
+
+Была запущена интерактивная оболочка IDLE.
+
+```python
+os.chdir("/Users/nickpod/Documents/python-labs")
+```
+
+## 2 Изучение создания пользовательских функций
+
+Было изучено создание функций.
+
+## 2.1 Изучение создания функции без аргументов
+
+Была создана и потом применена функция, которая печатает определенный текст. Был определен класс функции и просмотрено пространство имен, в котором появилось название созданной функции. Просмотрена помощь по функции, в которой был выведен комментарий, созданный при создании функции. Можно сделать вывод, что в описании к функции нужно описать ее концепцию, что делает функция и какие аргументы нужно указывать.
+
+```python
+>>>def uspeh():
+    """Подтверждение успеха операции"""
+    print('Выполнено успешно!')
+
+    
+>>>uspeh()
+Выполнено успешно!
+>>>type(uspeh)
+<class 'function'>
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+>>>help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+
+docstring помогает другим разработчикам понимать, что делает функция, не изучая её код.
+
+## 2.2 Изучение создания функции с аргументами
+
+Была создана и применена функция сравнения двух чисел. При передаче в аргументы переменных класса чисел, функция сравнила числа, а при передачи данных типа строка, функция сравнила размер кодового номера, в случае с числами переменные сравниваются посимвольно, то есть первой цифрой числа.
+
+```python
+>>>def sravnenie(a,b):
+    """Сравнение a и b"""
+    if a>b:
+	    print(a,' больше ',b)
+    elif a<b:
+	    print(a, ' меньше ',b)
+    else:
+	    print(a, ' равно ',b)
+
+	    
+>>>n,m=16,5;sravnenie(n,m)
+16  больше  5
+>>>n,m="А","а";sravnenie(n,m)
+А  меньше  а #Каждому символу присвоен кодовый номер в стандарте Unicode A = U+0041 (десятичное: 65), a = U+0061 (97)
+```
+
+## 2.3 Изучение создания функции с применением return
+
+Была создана и применена функция, которая возвращает результат вычисления математического выражения.
+
+```python
+>>>def logistfun(b,a):
+    """Вычисление логистической функции"""
+    import math
+    return a/(1+math.exp(-b))
+
+>>>v,w=1,0.7;z=logistfun(w,v)
+>>>z
+0.6681877721681662
+```
+
+## 2.4 Изучение создания функции сложения обьектов различных типов
+
+Была создана и применена функция сложения различных обьектов. При сложении чисел, фунцкия вернула сумму, при сложении строк, списков и кортежей, функция обьединила их в один обьект, а при передаче в виде аргументов словарей и множеств произошла ошибка.
+
+```python
+>>>def slozh(a1,a2,a3,a4):
+	""" Сложение значений четырех аргументов"""
+	return a1+a2+a3+a4
+
+    
+>>>slozh(1,2,3,4)   # Сложение чисел
+10
+>>>slozh('1','2','3','4')  # Сложение строк
+'1234'
+>>>b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>>q=slozh([1,2],[-1,-2],[0,2],[-1,-1]) #Сложение списков
+q
+[1, 2, -1, -2, 0, 2, -1, -1]
+>>>kor = ("a", 8)
+>>>kor2 = ("b", 9)
+>>>kor3 = ("c", 10)
+>>>kor4 = ("d", 11)
+>>>k=slozh(kor, kor2, kor3, kor4)
+>>>k
+('a', 8, 'b', 9, 'c', 10, 'd', 11)
+>>>sl1 = {"A": 8, "B": 9}
+>>>sl2 = {"B": 10, "C": 11}
+>>>sl3 = {"D": 12, "E": 13}
+>>>sl4 = {"F": 14, "H": 15}
+>>>sl=slozh(sl1, sl2, sl3, sl4)
+Traceback (most recent call last):
+  File "<pyshell#47>", line 1, in <module>
+    sl=slozh(sl1, sl2, sl3, sl4)
+  File "<pyshell#29>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+>>>mn1 = {"A", "B"}
+>>>mn2 = {"C", "D"}
+>>>mn3 = {"E", "F"}
+>>>mn4 = {"H", "J"}
+>>>mn=slozh(mn1, mn2, mn3, mn4)
+Traceback (most recent call last):
+  File "<pyshell#55>", line 1, in <module>
+    mn=slozh(mn1, mn2, mn3, mn4)
+  File "<pyshell#29>", line 3, in slozh
+    return a1+a2+a3+a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+
+## 2.5 Изучение создания функции, которая создает список со значениями вычисленных сигналов
+
+Была создана функция, которая вычисляет значение по определенной формуле, далее реализован цикл, в котором созданный ранее список пополняется новыми значениями выходного сигнала, которые зависят от предыдущего значения выходного сигнала. По данным выходного сигнала был построен график.
+
+```python
+>>>def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+        x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y=(x+T*ypred)/(T+1)
+	return y
+
+    
+>>>sps=[0]+[1]*100
+>>>spsy=[] #Заготовили список для значений выхода
+>>>TT=20 #Постоянная времени
+>>>yy=0  #Нулевое начальное условие
+>>>for xx in sps:
+	yy=inerz(xx,TT,yy)
+	spsy.append(yy)
+
+	
+>>>import pylab
+>>>spsm = list(range(101))
+>>>pylab.plot(spsm, spsy)
+[<matplotlib.lines.Line2D object at 0x000001E1619A6850>]
+>>>pylab.show()
+```
+
+![[grafik1_lab7.png]]
+
+## 3 Изучение действий с функциями как с обьектами
+
+## 3.1 Изучение вывода подсказок по функции
+
+Были выведены атрибуты созданной функции и применен один из них, который показал описание функции, которое также было выведено с помощью функции help.
+
+```python
+>>>dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+>>>inerz.__doc__
+'Модель устройства с памятью:\n       x- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
+>>>help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+           x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства
+```
+
+## 3.2 Изучение создания ссылки на обьект
+
+Была создана ссылка на функцию и уже по этой ссылке вызвана функция, которая сравнила два числа по величине.
+
+```python
+>>>fnkt=sravnenie
+>>>v=16
+>>>fnkt(v,23)
+16  меньше  23
+```
+
+## 3.3 Изучение применения условия if для применения разных функций
+
+Был создан цикл-условия, в котором при одном условии функция определяется одними инструкциями, а при другом условии - другими. И была вызвана эта функция.
+
+```python
+>>>typ_fun=8
+>>>if typ_fun==1:
+	def func():
+		print('Функция 1')
+else:
+	def func():
+		print('Функция 2')
+
+		
+>>>func()
+Функция 2
+```
+
+## 4 Изучение работы с аргументами функции
+
+Были рассмотрены различные варианты передачи аргументов функции и работы с ними.
+
+## 4.1 Изучение функции как аргумента другой функции
+
+Была создана функция, а потом вызвана с передачей в виде первого аргумента - другой функции.
+
+```python
+def fun_arg(fff,a,b,c):
+	"""fff-имя функции, используемой 
+	в качестве аргумента функции fun_arg"""
+	return a+fff(c,b)
+
+    
+zz=fun_arg(logistfun,-3,1,0.7)
+zz
+-2.3318122278318336
+```
+
+## 4.2 Изучение функции, в которой присутствует предопределенный аргумент
+
+Была создана функция, в которой один аргумент уже предопределен, а при вызове функции передается всего один аргумент из двух.
+
+```python
+>>>def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+	"""Вычисление логистической функции"""
+	import math
+	return b/(1+math.exp(-a))
+
+    
+>>>logistfun(0.7)     #Вычисление со значением b по умолчанию
+0.6681877721681662
+>>>logistfun(0.7,2)  #Вычисление с заданным значением b
+1.3363486314678965
+```
+
+## 4.3 Изучение передачи аргументов функции в произвольном порядке
+
+Функция была вызвана с передачей аргументов не по порядку, а по названию аргументов.
+
+```python
+>>>logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами a/(1+math.exp(-b))
+0.34498724056380625
+```
+
+## 4.4 Изучение передачи аргумента в виде ссылки на список/ кортеж
+
+Была вызвана функция, которой в качестве аргументов была передана ссылка на список.
+
+```python
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+>>>b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+>>>qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+>>>qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+
+## 4.5 Изучение передачи аргумента в виде ссылки на словарь
+
+Была вызвана функция, которой в качестве аргументов была передана ссылка на словарь. В результате функция взяла в качестве аргументов значения из словаря.
+
+```python
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+qqq
+10
+```
+
+## 4.6 Изучение смешанных ссылок
+
+Была вызвана функция, которой в качестве аргументов была передана ссылка на список и словарь.
+
+```python
+>>>e1=(-1,6);dd2={'a3':3,'a4':9}
+>>>qqqq=slozh(*e1,**dd2)
+>>>qqqq
+17
+```
+
+## 4.7 Изучение функции, в которой в качестве аргумента присутствует кортеж неопределенного размера
+
+Была создана функция, где изначально не определено количество аргументов. Все переданные переменные в функцию, собираются в кортеж, доступный внутри функции.
+
+```python
+>>>def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return smm
+
+    
+>>>func4(-1,2)  #Обращение к функции с 2 аргументами
+1
+>>>func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+```
+
+## 4.8 Изучение функции, с неопределенным количеством аргументов
+
+Была создана функция где изначально есть два аргумента, а далее не определено количество аргументов. Все переданные переменные в функцию, собираются в кортеж, доступный внутри функции. Также была создана функция, где переданные аргументы собираются в словарь.
+
+```python
+>>>def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+    
+>>>func4(-1,2,0,3,6)
+-7 #  (-1) * 9 + 2
+
+>>>def func5(**slovar):
+    print(slovar)
+>>>func5(a=5, n=8, m=30)
+{'a': 5, 'n': 8, 'm': 30}
+```
+
+## 4.9 Изучение изменения обьектов внутри функции
+
+Были созданы функции, внутри которых передаваемый аргумент как-либо был изменен, и после применения функции, просмотрено значение переменных. Числовая переменная осталась такой же (а созданная внутри функции переменная "a" не имела связи с созданной "а" вне функции), какой была задана, элемент списка изменился, а при попытке передать в функцию кортеж вышла ошибка.
+
+```python
+>>>a=90    # Числовой объект – не изменяемый тип
+>>>def func3(b):
+	a=5*b+67
+
+	
+>>>a #Переменная не изменилась
+90
+>>>sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+>>>def func2(sps):
+	sps[1]=99
+
+	
+>>>func2(sps1)
+>>>print(sps1) #Элемент списка изменился
+[1, 99, 3, 4]
+>>>kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+>>>def func2(kort):
+        kort[1]=99
+    
+>>>print(kort)
+(1, 2, 3, 4)
+```
+
+## 5 Изучение специальных типов пользовательских функций
+
+Были изучены и созданы анонимные функции и функции-генераторы.
+
+## 5.1 Изучение анонимных функций
+
+Были созданы и применены функции без имени без аргументов, с двумя аргументами и с необязательным аргументом.
+Анонимная функция — это короткая функция без имени, которая определяется прямо в месте использования и может содержать только одно выражение.
+
+```python
+>>>import math
+>>>anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+>>>anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+>>>anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+>>>anfun2(17,234)
+19.369215857410143
+>>>anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+>>>anfun3(100)
+102.36921585741014
+```
+
+## 5.2 Изучение функции-генератора
+
+Была создана функция-генератор, которая производит последовательность чисел. Она была выведена с помощью цикла for, а также генерирующиеся значения были выведены поотдельности, с помощью метода **next**.
+
+```python
+>>>def func5(diap,shag):
+	""" Итератор, возвращающий значения
+	из диапазона от 1 до diap с шагом shag"""
+	for j in range(1,diap+1,shag):
+		yield j
+
+		
+>>>for mm in func5(7,3):
+    print(mm)
+
+    
+1
+4
+7
+>>>alp=func5(7,3)
+>>>print(alp.__next__())
+1
+>>>print(alp.__next__())
+4
+>>>print(alp.__next__())
+7
+>>>print(alp.__next__()) #На данном этапе, сообщается о том, что больше нет значений для выдачи.
+Traceback (most recent call last):
+  File "<pyshell#165>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+## 6 Изучение обьектов в функциях
+
+Были изучены локальные и глобальные обьекты, а также смоделирована система управления.
+
+## 6.1 Изучение работы с глобальными и локальными обьектами
+
+Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции. Глобальные – это те объекты, значения которых заданы вне функции. Была создана функция, внутри которой уже существующей в глобальном пространстве переменной было присвоено определенное новое значение. При выполнении функции глобальная переменная не изменялась. Далее внутри созданной функции была попытка напечатать переменную, которой не существует в пространстве имен функции. Также была создана функция, внутри которой была обьявлена переменная как глобальная и после этого она была изменена внутри функции, что изменило ее в глобальном пространстве.
+
+```python
+>>>glb=10
+>>>def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+    
+>>>res=func7(glb) #Для получения результата здесь использовалось значение переменной glb=10, то есть глобальной переменной, потому что именно она была передана в arg, который использовался в вычислениях.
+>>>res
+150
+>>>glb #Значение переменной не изменилось, так как это глобальная переменная и вне функции она не переопределялась.
+10
+>>>def func8(arg):
+	loc1=15
+	print(glb)  
+	glb=8
+	return loc1*arg
+
+    
+>>>res=func8(glb) #В данном случае выведется ошибка, так как до функции print внутри пространства имен функции переменной glb не существует 
+Traceback (most recent call last):
+  File "<pyshell#178>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#177>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+
+>>>glb=11
+>>>def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+    
+>>>res=func7(glb)
+11
+>>>glb #В этом случае значение переменной меняется, так как внутри функции обьявляется именно глобальная переменная glb.
+8
+>>>res #Однако в виде arg мы передали именно значение glb равное 11, поэтому как аргумент будет использоваться именно это значение, хоть сама переменная glb и была изменена. 
+165
+```
+
+## 6.2 Изучение нахождения локальных и глобальных обьектов
+
+Были выведены локальные и глобальные обьекты в глобальном пространстве видимости и также внутри функции.
+
+```python
+>>>globals().keys() #На глобальном уровне локальная и глобальная области видимости совпадают.
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+>>>locals().keys() #В данном случае отличий не будет, так как локализация обьектов запрашивается в глобальной области видимости.
+>>>def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+    
+>>>hh=func8(glb) #В этом случае глобальные обьекты остались те же, место локализации - функция, в ней существуют три локальных обьекта.
+>>>hh
+165
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+
+## 6.3 Изучение глобальных и локальных обьектов внутри вложенных функций
+
+Когда мы вывели глобальные и локальные объекты в функции и во вложенной функции, стало видно, что переменные, которые создаются внутри вложенной функции, существуют только внутри неё. Основная функция их не видит — в её локальном списке этих переменных нет. То же самое работает и наоборот: переменные основной функции не доступны вложенной.
+
+Получается, у каждой функции своё отдельное «пространство», и они друг в друга не лезут. Основная функция считается своим локальным объектом в программе, а вложенная функция существует только внутри неё и снаружи её не видно, если специально не вернуть её наружу.
+
+```python
+>>>def func9(arg2,arg3):
+	def func9_1(arg1):
+		loc1=15
+		glb1=8
+		print('glob_func9_1:',globals().keys())
+		print('locl_func9_1:',locals().keys())
+		return loc1*arg1 #75
+	loc1=5
+	glb=func9_1(loc1)
+	print('loc_func9:',locals().keys())
+	print('glob_func9:',globals().keys())
+	return arg2+arg3*glb #85
+
+    
+>>>kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'kor', 'kor2', 'kor3', 'kor4', 'k', 'sl1', 'sl2', 'sl3', 'sl4', 'mn1', 'mn2', 'mn3', 'mn4', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'spsm', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'mm', 'alp', 'al', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+
+## 6.4 Изучение моделирования системы управления
+
+Была смоделирована система управления, состоящая из реального двигателя, тахогенератора и зоны нечувствительности (их модели представляются пользовательскими функциями). На вход системы подается синусоидальный сигнал, который проходит через отрицательную обратную связь. Модель реального двигателя и тахогенератора представлены интеграторами и усилителями, а зона нечувствительности ограничивает значения выходного сигнала. В результате работы программы вычисляется и выводится список значений, представляющих выходной сигнал системы.
+
+```python
+>>>znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=0.5,35,0.6,5,1000,5,15
+>>>k1=float(znach[0])
+>>>T=float(znach[1])
+>>>k2=float(znach[2])
+>>>Xm=float(znach[3])
+>>>A=float(znach[4])
+>>>F=float(znach[5])
+>>>N=float(znach[6])
+>>>import math
+>>>vhod=[]
+>>>for i in range(N):
+    vhod.append(A*math.sin((2*i*math.pi)/F))
+>>>vhod
+[0.0, 951.0565162951535, 587.7852522924733, -587.785252292473, -951.0565162951536, -2.4492935982947065e-13, 951.0565162951535, 587.7852522924734, -587.7852522924728, -951.0565162951538, -4.898587196589413e-13, 951.0565162951528, 587.7852522924736, -587.7852522924726, -951.0565162951538]
+>>>def realdvig(xtt,kk1,TT,yti1,ytin1):
+    #Модель реального двигателя
+    yp=kk1*xtt  #усилитель
+    yti1=yp+yti1  #Интегратор
+    ytin1=(yti1+TT*ytin1)/(TT+1)
+    return [yti1,ytin1]
+
+>>>def tahogen(xtt,kk2,yti2):
+    #Модель тахогенератора
+    yp=kk2*xtt   #усилитель
+    yti2=yp+yti2 #интегратор
+    return yti2
+
+>>>def nechus(xtt,gran):
+    #зона нечувствительности
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt
+
+>>>yi1=0;yin1=0;yi2=0
+>>>vyhod=[]
+>>>for xt in vhod:
+    xt1=xt-yi2   #отрицательная обратная связь
+    [yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
+    yi2=tahogen(yin1,k2,yi2)
+    yt=nechus(yin1,Xm) #Если скорость yin1 = 0.3 → выход yt = 0 (слишком мало)
+    vyhod.append(yt)
+
+    
+>>>print('y=',vyhod)
+y= [0, 8.209118281877132, 29.104924685415277, 40.86232427117668, 38.3075414151359, 34.68635884409398, 42.90679739719954, 57.19526562043458, 60.53754513466764, 47.64611630565597, 31.742316122264157, 25.812753880749888, 24.278160244795345, 10.44509996519298, -10.518946273258612]
+```
+
+## 7 Завершение работы в IDLE
+
+Был завершен сеанс в среде IDLE.

TEMA7/result11.txt

@@ -0,0 +1,7 @@
+1.999999388195546 1.9999849909968057 1.9997532108480274 
+1.9972829600991422 1.9800963962661915 1.9051482536448667 
+1.7162978701990246 1.4621171572600098 1.2913126124515908 
+1.2913126124515908 1.4621171572600098 1.7162978701990246 
+1.9051482536448667 1.9800963962661915 1.9972829600991422 
+1.9997532108480274 1.9999849909968057 1.999999388195546 
+1.9999999832832198 1.9999999996938214 1.9999999999962408 

TEMA7/task.md

@@ -0,0 +1,89 @@
+# Общее контрольное задание по теме 7
+
+Подольский Никита, А-01-23
+
+## Задание
+
+Общее контрольное задание.
+    • Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+    • Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+    • Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
+	Y=b1+b2 * X
+	и имеющую аргументы b1, b2 и X.
+
+## Решение
+
+```python
+
+def signal_zaderzhka(vhod_spisok, zaderzhka):
+    """
+    Возвращает сигнал, где каждое значение - это значение входного сигнала
+    zaderzhka тактов назад (0 для первых zaderzhka тактов)
+    """
+    vihod = []
+    istoriya = []  # Отдельный список для истории
+
+    for el in vhod_spisok:
+        istoriya.append(el)  # Добавляем текущее значение в историю
+        
+        if len(istoriya) <= zaderzhka:
+            # Еще не накопили достаточно истории
+            vihod.append(0)
+        else:
+            # Берем значение, которое было zaderzka тактов назад
+            el_zad = istoriya[len(istoriya) - zaderzhka - 1]
+            vihod.append(el_zad)
+    
+    return vihod
+zaderzhka = 3
+vhod = [1, 2, 3, 4, 5]
+vihod = signal_zaderzhka(vhod, zaderzhka)  
+print("входной сигнал: ", vhod, "выходной сигнал: ", vihod)
+входной сигнал:  [1, 2, 3, 4, 5] выходной сигнал:  [0, 0, 0, 1, 2]
+```
+
+```python
+def histogram(data, num_bins):
+    """Вычисляет и выводит гистограмму в виде таблицы, возвращает bins и counts."""
+    min_val, max_val = min(data), max(data)
+    bin_width = (max_val - min_val) / num_bins
+    bins = [min_val + i * bin_width for i in range(num_bins + 1)] #список границ интервалов min=0, max=10, num_bins=5 → bins=[0, 2, 4, 6, 8, 10]
+    counts = []
+    for i in range(num_bins):
+        count = 0
+        for x in data:
+            if bins[i] <= x < bins[i+1] or (x == max_val and i == num_bins - 1):
+                count += 1
+        counts.append(count)
+
+    print("Гистограмма:")
+    for i in range(num_bins):
+        print(f"Интервал: [{bins[i]:.2f}, {bins[i+1]:.2f}], Элементов: {int(counts[i])}")
+
+    return bins, counts
+
+import random
+data = [random.gauss(0, 1) for _ in range(1000)]
+num_bins = 10
+bins, counts = histogram(data, num_bins)
+Гистограмма:
+Интервал: [-3.07, -2.46], Элементов: 11
+Интервал: [-2.46, -1.85], Элементов: 33
+Интервал: [-1.85, -1.24], Элементов: 64
+Интервал: [-1.24, -0.64], Элементов: 160
+Интервал: [-0.64, -0.03], Элементов: 207
+Интервал: [-0.03, 0.58], Элементов: 246
+Интервал: [0.58, 1.19], Элементов: 168
+Интервал: [1.19, 1.80], Элементов: 75
+Интервал: [1.80, 2.41], Элементов: 26
+Интервал: [2.41, 3.02], Элементов: 10
+```
+
+```python
+>>>anon = lambda b1, b2, X: b1+b2*X
+>>>Y = anon(1,2,3)
+>>>Y
+7
+```
+
+

TEMA7/test.md

@@ -0,0 +1,55 @@
+# Индивидуальное контрольное задание по теме 7
+Подольский Никита, А-01-23
+
+## Задание (Вариант 11)
+
+1.     Разработайте анонимную функцию с 5 аргументами: х, a,b,c,d, вычисляющую значение a/(1+exp(-b-c * x-d * x2)). Рассчитайте значения этой функции в диапазоне значений входного параметра х:  -20 ≤ x ≤ 20 с шагом 2 при некоторых положительных значениях параметров a,b,c,d. Обеспечьте запись рассчитанных значений в текстовый файл по три значения на строке, разделенных пробелами.
+
+## Решение
+### Вариант 11
+``` python
+import math
+
+f = lambda x, a, b, c, d: a / (1 + math.exp(-b - c*x - d*(x**2)))
+
+a = 2
+b = 1
+c = 0.3
+d = 0.05
+
+xs = []
+
+start = -20
+end = 20
+step = 2
+
+for i in range(0, (end - start) // step + 1):
+    x = start + i * step
+    xs.append(x)
+
+ys = []
+for x in xs:
+    y = f(x, a, b, c, d)
+    ys.append(y)
+
+out = open("result11.txt", "w")
+
+count = 0
+line = ""
+
+for y in ys:
+    line = line + str(y) + " "
+    count += 1
+
+    if count == 3:
+        out.write(line + "\n")
+        line = ""
+        count = 0
+
+if line != "":
+    out.write(line + "\n")
+
+out.close()
+```
+
+![[Pasted image 20251208120028.png]]