Добавления отчета

TEMA1/Pr0

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Бушманов Артём Сергеевич
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('/Users/ArtyomBushmanov/python-labs/TEMA1')

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме1 Бушманова Артёма Сергеевича
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir("/Users/ArtyomBushmanov/python-labs/TEMA1")

TEMA1/Protocol.py

@@ -0,0 +1,8 @@
+#Протокол по Теме 1 Бушманов Артём Сергеевич
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir("/Users/ArtyomBushmanov/python-labs/TEMA1")
+import Pr0
+import prb1
+help(print);help(input)

TEMA1/test.md

@@ -0,0 +1,14 @@
+# Индивидуальное контрольное задание по теме 1
+Бушманов Артём Сергеевич А-01-23
+
+## Задание 
+Какие способы могут использоваться для получения помощи при работе со средой Python?
+
+### Решение
+Через меню Help в IDLE: IDLE Help и Python Docs (локальная/онлайн документация), а также встроенная функция help() в Shell и контекстная справка по выделенному слову.
+## Меню Help и Python Docs
+В главном меню IDLE есть раздел «Помощь (Help)», откуда открывается «Python Docs» с официальной справочной подсистемой; то же окно вызывается клавишей F1 для быстрого доступа к документации прямо из среды.
+## Встроенная функция help()
+В командном окне IDLE можно получить оперативную помощь по объектам и функциям вызовом вида help(print), что выводит описание и сигнатуры; допускается ввод нескольких запросов в одну строку через точку с запятой, например help(print); help(input) для последовательного просмотра.
+## Указатель (Index) и поиск терминов
+В окне справочной подсистемы доступна вкладка «Указатель (Index)» с алфавитным списком терминов языка; выбор, например, пункта print() (built-in function) открывает соответствующую страницу справки с описанием функции.

TEMA2/report.md

@@ -0,0 +1,531 @@
+# Отчет по теме 2  Основы программирования Python
+### Бушманов Артём Сергеевич, А-01-23.
+### 1. Запуск оболочки IDLE
+Установка рабочего каталога.
+```Python
+import os
+os.chdir('/Users/ArtyomBushmanov/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;
+-  большие и малые буквы в именах различаются (имена – чувствительные к регистру)!
+С учетом этих правил в командном окне IDLE выполним следующие операции.
+```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 
+>>> abs(-7)
+7
+```
+Возвращает модуль числа
+#### 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 = [1, 2, 3, 4, 5]
+
+>>> my_dict = dict(zip(keys_tuple, values_list))
+>>> print(my_dict)
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+
+>>> 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 = {1, 'число',(15, 30, 45), 3.14}
+>>> mnoz2
+{1, (15, 30, 45), 3.14, 'число'}
+>>> len(mnoz2)  # количество элементов
+4
+>>> 'число' in mnoz2 
+True
+>>> mnoz2.add(False)
+>>> mnoz2
+>>> {False, 1, 3.14, 'число', (15, 30, 45)}
+>>> mnoz2.remove(1)
+>>> mnoz2
+
+{False, 3.14, 'число', (15, 30, 45)}
+```
+### 1.16 Завершаем работу со средой.
+Выбираем File и exit.
+### 1.17 Контрольные вопросы.

TEMA2/task.md

@@ -0,0 +1,77 @@
+# Общее контрольное задание по теме 2
+Бушманов Артём Сергеевич, А-01-23
+## Задание
+**Общее контрольное задание**
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+· Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+· Создать переменную со значением, совпадающим с первой буквой из familia.
+· Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+· Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+· Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+· Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
+· Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+· Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+## Решение
+
+### 1. Создаю переменную familia
+
+```python
+>>> familia = 'Bushmanov'
+```
+
+### 2. Создаю переменную которая = первой букве familia
+
+```python
+>>> fam1=familia[0]
+>>> fam1
+'B'
+```
+
+### 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
+{'строка': 'Bushmanov', 'список': ['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'], 'кортеж': ('Artyom', 'Dmitriy', 'Maksim', 'Denis', 'Pavel', 'Aleksandr')}
+```

TEMA2/task2.md

@@ -0,0 +1,16 @@
+# Индивидуальное контрольное задание по теме 2 
+Бушманов Артём Сергеевич, А-01-23
+## Задание (Вариант 5)
+Создайте объект
+gg=(11,2,-4,23,12,56)
+
+К какому классу относится этот объект? Подсчитайте сумму его элементов, расположенных на нечетных позициях.
+
+## Решение
+``` python
+gg = (11, 2, -4, 23, 12, 56)
+print(gg)
+print("Класс:", type(gg))
+s = sum(gg[0::2])
+print("Сумма (нечетных):", s) 
+```

TEMA2/task2.py

@@ -0,0 +1,5 @@
+gg = (11, 2, -4, 23, 12, 56)
+print(gg)
+print("Класс:", type(gg))
+s = sum(gg[0::2])
+print("Сумма (нечетных):", s) 

TEMA3/task.md

@@ -0,0 +1,60 @@
+# Общее контрольное задание по теме 3
+
+## Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+- Преобразовать восьмеричное значение 45 в целое число.
+- Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+- Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+- Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+- Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+- Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+- Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+```
+>>>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,57 @@
+# Индивидуальное контрольное задание
+Бушманов Артём Сергеевич A-01-23
+## Вопрос M1_9
+
+1) В каком месте инструкции и как можно написать комментарий?
+
+2) Создайте объект список с 10 элементами - русскоязычными названиями продуктов. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3) Удалите из списка 5 и 6 элементы, считая от первого. Определите число оставшихся элементов. Замените 4-й элемент на "трюфель". Отобразите получившийся объект.
+
+4) Преобразуйте список в кортеж. Отобразите полученный объект. Создайте новый кортеж с удалением из ранее созданного кортежа элемента "трюфель".
+
+5) Напишите инструкцию проверки наличия в списке элемента "молоко". Если его нет в списке, добавьте его туда, иначе - удалите его из списка.
+## Ответ: 
+1) Комментарий можно писать в любой части строки после символа "#"
+2) 
+```python
+>>>products = ["хлеб", "молоко", "сыр", "яблоко", "груша", "картофель", "морковь", "капуста", "тыква", "лук"]
+>>>products
+['хлеб', 'молоко', 'сыр', 'яблоко', 'груша', 'картофель', 'морковь', 'капуста', 'тыква', 'лук']
+>>>type(products) == list #Проверка на то что это список
+True #Верно это список
+>>>dir(products)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+```
+3)
+```python
+>>>del products[5]  # Удаляем 6-й элемент ("картофель")
+>>>del products[4]  # Удаляем 5-й элемент ("груша")
+>>>len(products) # Определяем сколько осталось элементов
+>>>products[3] = "трюфель" #Замена 4 элемента
+>>>products
+['хлеб', 'молоко', 'сыр', 'трюфель', 'груша', 'морковь', 'капуста', 'тыква', 'лук']
+```
+4)
+```python
+>>>products_tuple = tuple(products)
+>>>products_tuple
+('хлеб', 'молоко', 'сыр', 'трюфель', 'морковь', 'капуста', 'тыква', 'лук')
+products_tuple = tuple(products)
+print(products_tuple)
+#Удаляем трюфель
+>>>products_list = list(products_tuple) 
+>>>products_list.remove("трюфель")
+>>>products_tuple_no_truffle = tuple(products_list)
+>>>products_tuple_no_truffle
+```
+5)
+```python
+#Проверка на наличие элемента "молоко"
+if "молоко" in products:
+    products.remove("молоко")
+else:
+    products.append("молоко")
+
+print(products)
+```

TEMA3/Отчет по теме 3.md

@@ -0,0 +1,867 @@
+
+# Бушманов Артём, А-01-23
+
+## 1. Запуск IDLE
+
+## 2. Преобразование простых базовых типов объектов.
+
+### 2.1.  Преобразование в логический тип с помощью функции bool(<Объект>).
+Примеры использования:
+
+```
+>>>logiz1 = bool(56)
+>>>logiz1
+True
+>>>logiz2 = bool(0)
+>>>logiz2
+False
+>>>logiz3 = bool("Beta")
+>>>logiz3
+True
+>>>logiz4 = bool("")
+>>>logiz4
+False
+```
+
+### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления. осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.
+Примеры использования:
+``` 
+>>>tt1 = int(198.6) #Отбрасывается дробная часть
+>>>tt1
+198
+>>>tt2 = int("-76")#Число – в строке символов, система по умолчанию - десятичная
+>>>tt2
+-76
+>>>tt3 = int("B", 16)
+>>>tt3
+11
+>>>tt4 = int("71", 8)
+>>>tt4
+57
+>>>tt5 = int("98,76")
+Traceback (most recent call last):
+  File "<pyshell#16>", line 1, in <module>
+    tt5 = int("98,76")
+ValueError: invalid literal for int() with base 10: '98,76'
+```
+Как видно, выводится диагностическое сообщение. Выводится оно по причине того, что заданное число вещественное(float), а ожидается значение типа "int".
+
+Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>).
+Примеры преобразований:
+```
+>>>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.  Преобразование десятичных чисел в другие системы счисления:
+```
+>>>hh=123
+>>>hh
+123
+>>>dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+>>>dv1
+'0b1111011'
+>>>vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+>>>vos1
+'0o173'
+>>>shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+>>>shs1
+'0x7b'
+```
+Выполним обратные преобразования объектов dv1, vos1, shs1:
+```
+>>>int(dv1,2)
+123
+>>>int(vos1, 8)
+123
+>>>int(shs1, 16)
+123
+
+```
+
+## 3. Преобразования более сложных базовых типов объектов.
+
+### 3.1.  Преобразование в строку символов с помощью функции str(<Объект>).
+Примеры использования:
+```
+>>>strk1 = str(23.6)
+>>>strk1
+'23.6'
+>>>strk2  = str(logiz3)
+>>>strk2
+'True'
+>>>strk3 = str(["A", "B", "C"]) # Преобразуем список
+>>>strk3
+"['A', 'B', 'C']"
+>>>strk4 = str(("A", "B", "C")) # Преобразуем кортеж
+>>>strk4
+"('A', 'B', 'C')"
+>>>strk5=str({"A":1,"B":2,"C":9}) # Преобразуем словарь
+>>>strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+### 3.2.  Преобразование элементов объекта в список с помощью функции list(<Объект>).
+Примеры преобразований:
+```
+>>>spis1=list("Строка символов")  #Заданная строка разделяется на символы
+>>>spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>>spis2=list((124,236,-15,908))   #Кортеж превращается в список
+>>>spis2
+[124, 236, -15, 908]
+>>>spis3=list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+>>>spis3
+['A', 'B', 'C']
+```
+Инструкция, обеспечивающую создание из того же словаря списка с другими его частями:
+```
+>>>spis4 = list({"A":1,"B":2,"C":9}.values())
+>>>spis4
+[1, 2, 9]
+```
+
+### 3.3. Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>).
+Примеры преобразований
+```
+>>>kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+>>>kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>>kort8=tuple(spis2)   #Преобразование списка в кортеж 
+>>>kort8
+(124, 236, -15, 908)
+>>>kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+>>>kort9             
+('A', 'B', 'C')
+```
+### 3.4. Удаление объектов.
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del.
+Пример:
+```
+>>>del strk5, kort8
+>>>strk5        
+Traceback (most recent call last):
+  File "<pyshell#77>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+>>>kort8           
+Traceback (most recent call last):
+  File "<pyshell#78>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+```
+
+Создание строки со своей фамилией и инициалами, преобразование её в список, затем список – в кортеж и, наконец, кортеж – в строку. .
+```
+>>>fam = list('Bushmanov')
+>>>fam
+['B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v']
+>>>kort = tuple(fam)
+>>>kort
+('B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v')
+>>>strk = str(kort)
+>>>strk
+"('B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v')"
+```
+
+## 4. Арифметические операции.
+
+### 4.1.  Сложение и вычитание (+ и -)
+```
+>>>12+7+90   # Сложение целых чисел
+109
+>>>5.689e-1 - 0.456  #Вычитание вещественных чисел
+0.11289999999999994
+>>>23.6+54   #Сложение вещественного и целого чисел
+77.6
+>>>14-56.7+89  # Сложение и вычитание целых и вещественных чисел
+46.3
+```
+### 4.2.  Умножение (*)
+```
+>>>-6.7*12   #Умножение вещественного числа на целое число
+-80.4
+```
+
+### 4.3.  Деление (/). (Результатом деления всегда будет вещественное число!)
+```
+>>>-234.5/6   #Деление вещественного числа на целое
+-39.083333333333336
+>>>a=178/45  #Деление двух целых чисел – проверьте тип объекта a!
+a
+3.9555555555555557
+type(a)         
+<class 'float'>
+```
+### 4.4.  Деление с округлением вниз (//). 
+Здесь результат может быть целым или вещественным. В нижеследующих операциях определите тип результата.
+```
+>>>b=178//45   #Деление двух целых чисел
+>>>b             
+3
+>>>type(b)              
+<class 'int'>
+>>>c=-24.6//12.1  #Деление двух вещественных чисел        
+>>>c            
+-3.0
+>>>type(c)          
+<class 'float'>
+>>>zz1 = 78.4 / 16            
+>>>zz1             
+4.9
+>>>type(zz1)     
+<class 'float'>
+>>>zz2 = 78.4 // 16         
+>>>zz2           
+4.0
+>>>type(zz2)   
+<class 'float'>
+>>>zz3 = 78 // 16           
+>>>zz3          
+4
+>>>type(zz3) 
+<class 'int'>
+```
+
+### 4.5.  Получение остатка от деления (%).
+```
+>>>148 % 33   #Остаток от деления двух целых чисел
+16
+>>>12.6 % 3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+1.2000000000000002
+>>>36 % 12            
+0
+>>>36.98 % 23.56            
+>>>13.419999999999998
+```
+
+### 4.6.  Возведение в степень (**). 
+```
+>>>14**3  
+2744
+>>>e=2.7**3.6  #Вещественное число возводится в вещественную степень
+>>>e           
+35.719843790663525
+```
+
+Попробуем проделать арифметические операции над комплексными числами. Создадим два
+комплексных числа.
+
+```
+>>>comp1 = (5 + 3j)     
+>>>comp1      
+(5+3j)
+>>>type(comp1)          
+<class 'complex'>
+>>>comp2 = (10 - 5j)            
+>>>comp2             
+(10-5j)
+>>>type(comp2)  
+<class 'complex'>
+```
+Сложение:
+```
+>>>comp1 + comp2             
+(15-2j)
+```
+Вычитание:
+```
+>>>comp1 - comp2           
+(-5+8j)
+```
+
+Умножение:
+```
+>>>comp1 * comp2           
+(65+5j)
+```
+
+Деление:
+```
+>>>comp1 / comp2            
+(0.28+0.44j)
+```
+
+Целочисленное деление:
+```
+>>>comp1 // comp2      
+Traceback (most recent call last):
+  File "<pyshell#129>", line 1, in <module>
+    comp1 // comp2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+>>>comp1 // 2          
+Traceback (most recent call last):
+  File "<pyshell#130>", line 1, in <module>
+    comp1 // 2
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+```
+Как видим, целочисленное деление нельзя применять к комплексным числам.
+
+Взятие остатка от деления:
+```
+>>>comp1 % comp2
+Traceback (most recent call last):
+  File "<pyshell#131>", line 1, in <module>
+    comp1 % comp2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+>>>comp1 % 2      
+Traceback (most recent call last):
+  File "<pyshell#132>", line 1, in <module>
+    comp1 % 2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+```
+Как видим, взятие остатка от деления нельзя применять к комплексным числам.
+
+Возведение в степень:
+```
+>>>comp1 ** comp2           
+(-652921189.7700557+180781145.7454619j)
+>>>comp1**5      
+(-6100+2868j)
+```
+
+## 5. Операции с двоичными представлениями целых чисел.
+
+### 5.1.  Двоичная инверсия (~).
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+```
+>>>dv1 = 9          
+>>>dv2 = ~dv1            
+>>>dv2            
+-10
+>>>bin(dv1)          
+'0b1001'
+>>>bin(dv2)          
+'-0b1010'
+```
+### 5.2.  Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```
+>>>bin(7&9)            
+'0b1'
+```
+Совпадение единиц только в первом разряде, поэтому итог - 0001 или просто 1
+```
+>>>bin(7&8)          
+'0b0'
+```
+Совпадений единиц нет, итог - 0000 или просто 0
+
+### 5.3.  Двоичное «ИЛИ» (|) 
+Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
+```
+bin(7|9)     # 111 или 1001 = 1111
+'0b1111'
+bin(7|8)     # 111 или 1000 = 1111
+'0b1111'
+bin(14|5)   # 1110 или 0101 = 1111
+'0b1111'
+```
+### 5.4. Двоичное «исключающее ИЛИ»(^) 
+
+Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+```
+>>>bin(14^5)  # 1110 исключающее или 0101 = 1011
+'0b1011'
+```
+Значение в десятичном представление:
+```
+>>>14^5        
+11
+```
+
+### 5.5.  Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+
+```
+>>>h=14   #Двоичное представление = 1110
+>>>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'
+```
+Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.
+
+Возьмем два двоичных числа:
+1011001 (в десятичной системе это 89)
+10001001 (в десятичной системе это 137)
+
+1. Двоичная инверсия
+```
+>>>~89            
+-90
+>>>bin(~89)         
+'-0b1011010'
+```
+
+2. Двоичное "И"
+```
+>>>bin(89 & 137)            
+'0b1001'
+```
+
+3. Двоичное "ИЛИ"
+```
+>>>bin(89 | 137)            
+'0b11011001'
+```
+
+4. Двоичное "исключающее ИЛИ"
+```
+>>>bin(89^137)             
+'0b11010000'
+```
+
+5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+```
+>>>89 >> 2             
+22
+>>>bin(89 >> 2)             
+'0b10110'
+>>>137 << 3            
+1096
+>>>bin(137 << 3)          
+'0b10001001000'
+```
+
+## 6. Операции при работе с последовательностями (строками, списками, кортежами).
+        
+### 6.1.  Объединение последовательностей (конкатенация)(+)
+```
+>>>'Система '+'регулирования'  #Соединение двух строк символов
+'Система+ регулирования'
+>>>['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>>('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+### 6.2.  Повторение (*)
+```
+>>>'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>>['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>>('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+```
+Создание списка со 100 отсчетами сигнала-ступеньки:
+```
+>>>signal1=[0]*3+[1]*99
+>>>signal1             
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+```
+Создание кортежа с отсчетами сигнала – импульса:
+```
+>>>signal2=(0,)*3+(1,)*5+(0,)*7
+>>>signal2          
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+### 6.3.  Проверка наличия заданного элемента в последовательности (in)
+```
+>>>stroka='Система автоматического управления'
+'автомат' in stroka  #Наличие подстроки в строке
+True
+>>>'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+>>>'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+### 6.4. Подстановка значений в строку с помощью оператора «%»
+
+```
+>>>stroka='Температура = %g %s  %g'
+'Температура =  %g %s  %g'
+>>>stroka % (16,' меньше ',25)
+'Температура =  %g %s  %g'
+```
+Вставка с использованием данных из словаря.
+```
+>>>stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>>stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16 меньше  25'
+```
+## 7. Оператор присваивания
+### 7.1.  Обычное присваивание значения переменной (=)
+```
+>>>zz=-12
+>>>zz
+-12
+```
+
+### 7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```
+>>>zz+=5   # Значение zz увеличивается на 5
+>>>zz
+-7
+>>>zz-=3  # Значение уменьшается на 3
+>>>zz
+-10
+```
+
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+```
+>>>stroka = 'Система'  
+>>>stroka
+'Система'           
+>>>stroka += ' регулирования'              
+>>>stroka            
+'Система регулирования'
+```
+
+### 7.3.  Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```
+>>>zz /= 2             
+>>>zz             
+-5.0
+>>>zz*= 5            
+>>>zz             
+-25.0
+>>>per = 2          
+>>>per*=10          
+>>>per            
+20
+ ```
+
+### 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=).
+```
+>>>zz //= 2             
+>>>zz             
+-13.0
+>>>zz %= -2             
+>>>zz             
+-1.0
+>>>per **= 4            
+>>>per              
+160000
+```
+
+### 7.5.  Множественное присваивание
+    w=v=10  # Переменным присваивается одно и то же значение
+    n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+Самостоятельно проверьте, можно ли вместо кортежа справа использовать строку, список, словарь, множество?
+1) Присваивание одного значения двум переменным
+```
+>>>w = v =10              
+>>>w, v            
+(10, 10)
+```
+2) Присваивание кортежем 
+```
+n1, n2, n3 = (11, -3, 'all')            
+n1, n2, n3            
+(11, -3, 'all')
+
+```
+3) Присваивание строкой
+```
+>>>a1, a2, a3 = 'red', 'black' , 'blue'         
+>>>a1, a2, a3         
+('red', 'black', 'blue')
+```
+4) Присваивание списком
+```
+>>>b1, b2, b3 = ["s", 67, None]            
+>>>b1, b2, b3            
+('s', 67, None)
+>>>b3         
+>>>type(b3)       
+<class 'NoneType'>
+```
+5) Присваивание словарем
+```
+>>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3}      
+>>>c1, c2, c3             
+('one', 'two', 'three')
+```
+По умолчанию в словарях итерируются именно ключи. Если нужно задать значения, надо
+указать дополнительно ".value":
+```
+>>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3}.values()       
+>>>c1, c2, c3         
+(1, 2, 3)
+```
+Если в каждую переменную надо положить именно и ключ, и значение одновременно, можно
+использовать метод .items(), который каждую пару(ключ-значение) распределяет в отдельный
+кортеж
+```
+>>>d1, d2, d3 = {"one": 1, "two": 2, "three": 3}.items()              
+>>>d1            
+('one', 1)
+>>>d2             
+('two', 2)
+>>>d3             
+('three', 3)
+
+```
+
+
+6) Присваивание множеством
+```
+>>>m1, m2, m3 = {100, 23, 59}            
+>>>m1, m2, m3             
+(59, 100, 23)
+```
+
+## 8. Логические операции 
+
+### 8.1.  Операции сравнение: равенство (= =), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) 
+```
+>>>w == v          
+True
+>>>w != v            
+False
+>>>w < v             
+False
+>>>w > v             
+False
+>>>w >= v             
+True
+```
+Другие примеры:
+```
+>>>0 == False             
+True
+>>>0 == True            
+False
+>>>100 != 1000          
+True
+>>>1200 > 100          
+True
+>>>1200 < 1000            
+False
+>>>1200 >= 1000           
+True
+```
+
+### 8.2.  Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in).
+
+Операции с множеством 
+```
+>>>mnoz1={'pen','book','pen','iPhone','table','book'}
+>>>'book' in mnoz1
+True
+>>>'cap' in mnoz1
+False
+```
+Операции со словарем
+```
+>>>dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>>'Vologda' in dic1           
+True
+>>>'Pskov' in dic1
+False
+>>>56 in dic1.values()
+True
+```
+Ещё пример работы со словарем:
+```
+>>>dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>>dct1             
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+>>>'UII' in dct1['Depart']            
+True
+>>>dct1['Depart'][1] == 'MM'
+False
+```
+### 8.3.  Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). 
+```
+>>>a=17
+>>>b=-6
+>>>(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Собственные примеры:
+```
+>>>((145) in dic1.values()) and not  ('Rostov' in dic1)             
+True
+>>>not(len(dic1) == 3) or (sum(dic1.values()) > 300) or ('ITAE' in dct1['Depart'])          
+False
+```
+### 8.4. Проверка ссылок переменных на один и тот же объект (is).
+
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+```
+>>>w is v
+True
+>>>w1 = ['A', 'B']
+>>>v1 = ['A', 'B']
+>>>w1 is v1  
+```
+Но при этом:
+```      
+False
+>>>w1 == v1          
+True
+```
+Основная разница "= =" и "is":
+- is проверяет, являются ли две переменные ссылками на один и тот же объект в памяти
+- == проверяет, равны ли значения объектов (содержимое одинаковое)
+Переменные целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти. `Словари были созданы в разных строках, и адреса разные, т.е. они ссылаются на разные участки в памяти, поэтому is возвращает False.
+
+## 9. Операции с объектами, выполняемые с помощью методов.
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например,
+```
+>>>stroka = 'Микропроцессорная система управления'
+>>>dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+### 9.1. Методы для работы со строками.
+``` 
+>>>stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+>>>stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+>>>stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>>spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+>>>spis22           
+['Микропроцессорная', 'система', 'управления']
+>>>stroka.upper()   #Возвращает строку со всеми заглавными буквами
+>>>stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+>>>stroka3         
+'Микропроцессорная система управления'
+>>>stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+>>>stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Изучим метод format. 
+```
+>>>strk1 = 'Момент времени {}, значение = {}'
+>>>strk1           
+'Момент времени {}, значение = {}'
+>>>strk1.format(1, 89.7)            
+'Момент времени 1, значение = 89.7'
+```
+Можно указать порядок:
+```
+>>>strk2='Момент времени {1}, значение = {0}:{2}'
+>>>strk2          
+'Момент времени {1}, значение = {0}:{2}'
+>>>strk2.format(36.7,2,'норма!')           
+'Момент времени 2, значение = 36.7:норма!'
+```
+Порядок подстановки: сначала подставляется второй аргумент, потом первый и затем третий
+
+Теперь зададим следующую строку:
+```
+>>>strk3='Момент времени {num}, значение = {znch}'
+>>>strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+В этом варианте порядок аргументов не обязательно соответствует порядку вставок в строке.
+
+### 9.2. Методы для работы со списками. 
+Создайте произвольный список spsk, не менее чем с 5 элементами. Отобразите его атрибуты.
+Последовательно обратитесь к методам этого списка с отображением каждый раз полученного списка:
+```
+spsk = ["blue", 163, (1, 2), "green", 78.69] #Создаем список           
+spsk.pop(2) #Удаляем второй элемент из списка           
+(1, 2) #Удаленный элемент
+spsk          
+['blue', 163, 'green', 78.69]
+spsk.append('c') #Добавляем элемент в список, по умолчанию добавляется в конец          
+spsk            
+['blue', 163, 'green', 78.69, 'c']
+spsk.insert(2, 'a') #Добавление элемента в список с индексом два           
+spsk          
+['blue', 163, 'a', 'green', 78.69, 'c']
+spsk.count('a') #Подсчет элементов 'a' в списке             
+1
+```
+
+### 9.3. Создание кортежа и изучение создания его методов.
+```
+>>>cort = ('abc', 52.3, 'a', 167, 3 + 2j)
+>>>dir(cort)        
+['__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']
+>>>cort.count('a')         
+1
+>>>cort.index(3+2j)        
+4
+```
+Благодаря функции dir видим, что кортеж имеет меньше атрибутов чем список.
+
+### 9.4. Методы словарей и множеств.
+- Методы словарей
+Возьмем уже ранее использованный словарь dic1
+```
+>>>dic1           
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>>dic1.keys() # Возвращение объектов, состоящих только из ключей.         
+>>>dict_keys(['Saratov', 'Orel', 'Vologda'])
+>>dir(dic1)          
+['__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']
+>>>dic1.items()  #Возвращение кортежей из пар ключ-значение      
+>>>dict_items([('Saratov', 145), ('Orel', 56), ('Vologda', 45)])
+>>>dic1.get("Saratov") #Возвращение значения по ключу           
+145
+>>>dic1.values() #Возвращение объекта только из значений        
+>>>dict_values([145, 56, 45])
+>>>dic1["key4"] = 49 #Вызов значения по ключу      
+>>>dic1         
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'key4': 49}
+>>>dic1_k = dic1.keys() #Создание отдельного объекта, чтобы положить в него dict_keys           
+>>>dic1_k        
+>>>dict_keys(['Saratov', 'Orel', 'Vologda', 'key4'])
+>>>dic1.popitem() #Удаление последнего добавленного элемента          
+('key4', 49)
+>>>dic1          
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>>dic1_k           
+>>>dict_keys(['Saratov', 'Orel', 'Vologda'])
+>>>dic1.pop("Orel") #Удаление ключа и возвращение значения            
+56
+```
+- Методы множеств
+```
+>>>mn = {1, "per", 35.8, "red", True, 153} #Создаем множество
+>>>mn            
+{1, 35.8, 'per', 153, 'red'}
+>>>dir(mn)           
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+>>>mn.add(6+3j) #Добавление элемента в конец множества            
+>>>mn            
+{1, 35.8, 'per', 153, 'red', (6+3j)}
+>>>mn.remove(1) #Удаление элемента по значению            
+>>>mn            
+{35.8, 'per', 153, 'red', (6+3j)}
+>>>mn.discard("red") #Удаление элемента по значению с возвратом None при отсутствии            
+>>>mn           
+{35.8, 'per', 153, (6+3j)} 
+{35.8, 'per', 153, (6+3j)}
+>>>print(mn.discard(1000))            
+None
+>>>mn.pop() #Удаление и возвращение случайного элемента из множества            
+35.8
+>>>mn             
+{'per', 153, (6+3j)}
+>>>mn.update({63, "klumba"}) #Добавление элементов
+>>>mn 
+{'klumba', 'per', 153, 63, (6+3j)}
+```
+
+## 10. Сохранение созданного текстового файла протокола в своем рабочем каталоге. Завершение сеанса работы с IDLE.

TEMA4/task.md

@@ -0,0 +1,46 @@
+Бушманов Артём Сергеевич А-01-23 
+
+## Задание
+**Общее контрольное задание**
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+·      Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+
+·      Создайте объект класса **struct****_****time** с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+·      Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+·      Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+·      Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+·      Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+## Выполнение
+```Python
+>>>import math
+>>>import cmath
+>>>import random
+>>>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=12, tm_min=30, tm_sec=42, tm_wday=4, tm_yday=297, tm_isdst=0)
+>>>nows = str(msc_t.tm_hour) + " " + str(msc_t.tm_min)
+>>>nows
+'12 30'
+>>>liist = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
+>>>random.sample(liist, 3)
+['четверг', 'понедельник', 'вторник']
+>>>random.choice(range(14, 33, 3))
+29
+>>>N = round(random.gauss(15,4))
+>>>N
+9
+>>>spis = list('qawsedrftgyhujikol')
+>>>spis = list('qawsedrftgyhujikolp')
+???random.sample(spis, N)
+['d', 'u', 'h', 's', 'e', 'y', 'o', 'r', 'w']
+>>>(time.mktime(time.localtime()) - time.mktime(msc_t)) / 60
+1.1666666666666667
+```

TEMA4/Отчет по теме 4.md

@@ -0,0 +1,656 @@
+# Бушманов Артём Сергеевич А-01-23
+## 1. Запуск интерактивной оболочки IDLE
+
+## 2. Стандартные функции
+
+### 2.1. Функция round – округление числа с заданной точностью
+```python
+>>>round(123.456,1)
+123.5
+>>>type(round(123.456,1))
+<class 'float'>
+>>>round(123.456,0)
+123.0
+>>>type(round(123.456,0))
+<class 'float'>
+>>>round(123.456)
+123
+>>>type(round(123.456))
+<class 'int'>
+```
+Если ndigits не указан — возвращает округлённое целое число.
+Если ndigits указан (даже 0) — возвращает число с плавающей точкой.
+Использует банковское округление: если число посередине между двумя возможными, выбирается ближайшее чётное.
+
+### 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(0,26))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+```
+Объект range(26) будет содержать последовательность целых чисел, начиная с 0 и до 25 (так как 26 не включается). Чтобы это увидить, необходимо применить list(). range — это легковесный объект, который генерирует числа на лету, а не хранит их все в памяти, поэтому преобразование в list нужно только для просмотра. Границы диапазона: от 0 и до 23, проход с шагом 1 по умолчанию.
+
+### 2.3. Функция zip - создание итерируемого объекта из кортежей
+Объединяет несколько последовательностей в кортежи поэлементно.
+Идёт до самой короткой последовательности.
+Возвращает итератор класса zip, а не список. Для вывода: list(zip(...)).
+Используется для параллельной обработки нескольких списков.
+```python
+>>>qq = ["Bushmanov", "Podolskiy", "Terehov", "Butko"]
+>>>ff = zip(gg, qq)
+>>>ff
+<zip object at 0x0000021278293500>
+>>>tuple(ff)
+((76, 'Bushmanov'), (85, 'Podolskiy'), (94, 'Terehov'), (103, 'Butko'))
+```
+Длина получившегося объекта соответствует длине меньшего объекта-параметров(длина 4 значения). 
+```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 и возвращает результат.
+Можно использовать для динамических вычислений.
+Опасна: при вводе непроверенного текста может выполняться произвольный код.
+
+```python
+>>>fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=55
+>>>fff
+55.0
+>>>dan
+119.0
+```
+### 2.5. Функция exec – чтение и выполнение объекта-аргумента функции.
+```python
+>>>exec(input('введите инструкции:'))        
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>>gg          
+221.456
+```
+- Исполняет строку как инструкцию Python.Отличие от eval: не возвращает значение, может создавать переменные и функции.
+- Опасна при работе с вводом пользователя.
+
+### 2.6. Функции abs, pow, max, min, sum, divmod, len, map. 
+- Функция abs(возвращение модуля):
+```python
+>>>x = abs(-10)           
+>>>x            
+10
+```
+- Функция pow(возведение в степень)
+```python
+>>>pow(2, 10)         
+1024
+>>>pow(4,5,10) # 4**5 = 1024, затем 1024 % 10 = 4           
+4
+```
+- Функции max и min(выбор максимального и минимального значения соответственно)
+```python
+>>>max(40, 50, 6)        
+50
+>>>min(-3, 57, 30)           
+-3
+```
+- Функция sum(суммирование элементов)
+```python
+>>>sum([1,2,3,4,5])           
+15
+>>>sum([1,2,3,4,5], -5)            
+10
+```
+- Функция divmod(возвращение кортежа из целой части и остатка от деления)
+```python
+>>>divmod(36, 5)          
+(7, 1)
+```
+- Функция len(длина списка)
+```python
+>>>len([1,2,3,4,5,6])          
+6
+```
+- Функция map ( это встроенная функция Python, которая применяет заданную функцию к каждому элементу итерируемого объекта (списка, кортежа и т.д.) и возвращает итератор с результатами.)
+```python
+>>>a = [10, 20, 30]
+>>>a
+[10, 20, 30]
+>>>b = [30, 20, 10]
+>>>b
+[30, 20, 10]
+>>>result = list(map(lambda x, y: x + y, a, b))
+>>>result
+[40, 40, 40]
+```
+
+## 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 - e**x
+```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 – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+```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(x) инициализирует внутреннее состояние генератора Mersenne Twister. Однаковый seed => одна и та же последовательность псевдослучайных значений при том же порядке вызовов.
+- Функци random(равномерно распределенное случайное число от 0 до 1)
+```python
+>>>help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+>>>random.random()
+0.15224090837130377
+>>>random.random()
+0.8451183120672832
+>>>random.random()
+0.8392090272295469
+```
+
+- Функция uniform (равномерно распределенное случайное число)
+```python
+>>>help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+>>>random.uniform(1, 5)
+1.4822447721210175
+>>>random.uniform(1, 500)
+11.101749613668387
+```
+равномерно от a до b.
+- Функция gauss(нормально распределенное случайное число)
+```python
+>>>help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu, sigma) method of random.Random instance
+    Gaussian distribution.
+    
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+    
+    Not thread-safe without a lock around calls.
+
+>>>random.gauss(1, 5)
+5.705708773458442
+>>>random.gauss(12, 57)
+-14.33510203993609
+```
+нормально распределённое число.
+- Функция randint(случайные целые числа)
+```python
+>>>help(random.randint)
+Help on method randint in module random:
+
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+>>>random.randint(3, 19)
+4
+>>>random.randint(3, 19)
+5
+```
+целое от a до b включительно.
+- Функция choice (случайный выбор из совокупности)
+```python
+>>>help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+90.3
+>>>random.choice([True, "ababba", 35, 90.3, 3+5j])
+(3+5j)
+```
+
+- Функця shuffle (случайная перестановка элементов списка)
+```python
+>>>help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x, random=None) method of random.Random instance
+    Shuffle list x in place, and return None.
+    
+    Optional argument random is a 0-argument function returning a
+    random float in [0.0, 1.0); if it is the default None, the
+    standard random.random will be used.
+
+>>>lst = [True, "ababba", 35, 90.3, 3+5j]
+>>>random.shuffle(lst)
+>>>lst
+[35, 'ababba', 90.3, (3+5j), True]
+```
+- Функция sample (случайный выбор подмножества элементов)
+```python
+>>>help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence or set.
+    
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  The resulting list is
+    in selection order so that all sub-slices will also be valid random
+    samples.  This allows raffle winners (the sample) to be partitioned
+    into grand prize and second place winners (the subslices).
+    
+    Members of the population need not be hashable or unique.  If the
+    population contains repeats, then each occurrence is a possible
+    selection in the sample.
+    
+    Repeated elements can be specified one at a time or with the optional
+    counts parameter.  For example:
+    
+        sample(['red', 'blue'], counts=[4, 2], k=5)
+    
+    is equivalent to:
+    
+        sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
+    
+    To choose a sample from a range of integers, use range() for the
+    population argument.  This is especially fast and space efficient
+    for sampling from a large population:
+    
+        sample(range(10000000), 60)
+
+>>>random.sample(lst, 5)
+['ababba', 90.3, True, (3+5j), 35]
+>>>random.sample(lst, 1)
+['ababba']
+```
+- Функция betavariate(случайное число с бета-распределением)
+```python
+>>>help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+>>>random.betavariate(1, 2)
+0.3174347054415454
+>>>random.betavariate(1, 2)
+0.17833765040946833
+```
+
+- Функция gammavariate(случайное число с гамма-распределением)
+```python
+>>>help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+    
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    
+    The probability distribution function is:
+    
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+>>>random.gammavariate(2, 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
+[2.1956405045678467, -2.238234699654799, 0.30508834143011926, 1.9912119529312582]
+```
+## 6. Функции из модуля time – работа с календарем и со временем.
+- UNIX время и текущее время
+```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=24, tm_hour=8, tm_min=57, tm_sec=30, tm_wday=0, tm_yday=279, tm_isdst=0)
+
+```
+
+- Текущее время с учетом часового пояса
+```python
+>>>mestn = time.localtime()                     
+>>>list(mestn)                   
+[2025, 10, 24, 12, 18, 35, 0, 279, 0]
+```
+
+- Функция asctime (преобразование представления времени из кортежа в строку) 
+```python
+>>>time.asctime(mestn)
+                      
+'Mon Oct  24 12:18:35 2025'
+```
+- Функция ctime (преобразование времени в секундах, прошедшего с начала эпохи, в строку)
+```python
+>>>time.ctime()
+                      
+'Mon Oct  24 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 0x0000021222D40400>]
+>>>pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>>pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>>pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>>pylab.show() #Отображение графика на экране
+```
+![График](figure0.png)
+
+- Рассмотрим способ построения нескольких графиков на одном рисунке.
+```python
+>>>X1 = [12, 6, 8, 10, 7]
+>>>X2 = [5, 7, 9, 11, 13]
+>>>pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000021222DF35B0>]
+>>>pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000021222DF38B0>]
+>>>pylab.show()
+```
+![График](figure1.png)
+
+
+- Теперь изучим возможность построения круговой диаграммы.
+```python
+>>>region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>>naselen=[65,12,23,17] # Значения для диаграммы
+>>>pylab.pie(naselen, labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000021225094EB0>, <matplotlib.patches.Wedge object at 0x0000021225094DF0>, <matplotlib.patches.Wedge object at 0x0000021225095900>, <matplotlib.patches.Wedge object at 0x0000021225095E70>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>>pylab.show()  #Отображение диаграммы
+```
+![График](figure2.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()
+```
+
+![График](figure3.png)
+
+
+- Построение столбиковой диаграммы
+```python
+>>>fruits = ["apple", "date", "apricot", "raspberry", "watermelon"]
+>>>values = [13, 16, 8, 25, 6]
+>>>pylab.bar(fruits, values, color='green')
+<BarContainer object of 5 artists>
+>>>pylab.show()
+```
+
+![График](figure4.png)
+
+
+Все графики, диаграммы и гистограммы сохранены в папку в формате "jpg".
+
+## 8. Статистический модуль statistics
+
+```python
+>>>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. Завершение работы