добавлен отчет и окз

qa!

 Lines starting with '#' will be ignored, and an empty message aborts

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+# Программа по Теме 1 Турханова Артема Константиновича
+print('Hello')
+h = input('Your name = ')
+import os
+os.chdir('C:\\Users\\u111-03\\python-labs\\TEMA1\\')

TEMA1/report.md

@@ -0,0 +1,136 @@
+# Отчет по теме 1
+
+Турханов Артем, А-03-23
+
+## 1 Изучение среды IDLE
+
+## 1.1 Настройка текущего каталога
+
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\u111-03\\python-labs\\TEMA1\\')
+>>> os.getcwd()
+'C:\\Users\\u111-03\\python-labs\\TEMA1'
+```
+
+## 1.2 Настройка вида окна
+Скриншот вида окна
+
+![Скриншот вида окна](figure0.png)
+
+## 1.3 Запуск программы Pr0 тремя способами
+
+```py
+>>>
+============================== RESTART: C:/Users/u111-03/python-labs/TEMA1/Pr0.py =============================
+Hello
+Your name = Artem
+>>> import Pr0
+Hello
+Your name = Artem
+>>>
+============================== RESTART: C:\Users\u111-03\python-labs\TEMA1\Pr0.py =============================
+Hello
+Your name = Artem
+```
+## 1.4 Анализ каталога __pycache__
+Результат открытия файла Pr0.cpython-311
+
+![Результат открытия файла Pr0.cpython-311](figure1.png)
+
+## 1.5 Запуск программы prb1
+
+```py
+>>> import prb1
+Как Вас зовут? Artem
+Привет, Artem
+```
+## 1.6 Работа с "помощью"
+
+```py
+>>> help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+>>> help(print), help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+```
+
+Окно помощи при вводе help(print)
+
+![Окно помощи при вводе help(print)](figure2.png)
+
+Окно помощи при нажатии F1
+
+![Окно помощи при нажатии F1](figure3.png)
+
+Окно помощи, открытое через редактор (Python Docs)
+
+![Окно помощи, открытое через редактор (Python Docs)](figure4.png)
+
+## 1.7 Выполенение пнукта 15 задания
+```py
+>>>
+============== RESTART: C:\Users\u111-03\python-labs\TEMA1\prb1.py =============
+Как Вас зовут? Artem
+Привет, Artem
+
+>>>
+========== RESTART: C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py ==========
+Traceback (most recent call last):
+  File "C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py", line 58, in <module>
+    main()
+  File "C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py", line 50, in main
+    plot(g, 0.35, "green")
+  File "C:\Users\u111-03\python-labs\TEMA1\tdemo_chaos.py", line 41, in plot
+    dot(5)
+  File "<string>", line 5, in dot
+turtle.Terminator
+```
+Текст программы tdemo_chaos.py
+
+![Текст программы tdemo_chaos.py](figure5.png)
+
+Результат выполенения программы tdemo_chaos.py
+
+![Результат выполенения программы tdemo_chaos.py](figure6.png)
+
+Другие примеры
+
+![Другие примеры](figure7.png)

TEMA1/test.md

@@ -0,0 +1,15 @@
+# Общее контрольное задание по теме 1
+
+Турханов Артем, А-03-23
+
+## Вопрос
+
+Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле  ABC.txt?
+
+## Ответ
+
+Перед тем, как запускать программу, необходмимо поменять расширение исходного файла с .txt на .py.
+После того, как расширение будет изменено, возможны несколько вариантов действий:
+
+1) Открыть Python IDLE. Настроить рабочую папку - ту самую, где лежит программа ABC.py. Потом ввести команду import ABC. Программа будет запущена.
+2) Открыть программу ABC.py в текстовом редакторе оболочки IDLE. Выбрать в меню редактора: "Запустить модуль". Программа будет запущена.

TEMA2/Pr2.py

@@ -0,0 +1,34 @@
+# Общее контрольное задание по теме 2
+# Турханов Артем, А-03-23
+
+import keyword
+
+# Задание 1
+familia = 'Turkhanov'
+
+# Задание 2
+c = familia[0]
+
+# Задание 3
+sp_kw = keyword.kwlist
+
+# Задание 4
+print('Список ключевых слов: ', sp_kw)
+sp_kw.remove('nonlocal')
+print('Список ключевых слов без nonlocal: ', sp_kw)
+
+# Задание 5
+kort_nam = ('Артем', 'Илья', 'Дима', 'Даня')
+print('Класс (тип) данных созданноого кортежа: ',type(kort_nam))
+
+# Задание 6
+print('Исходный кортеж: ', kort_nam)
+kort_nam = kort_nam + ('Макс', 'Саша')
+print('Измененный кортеж: ', kort_nam)
+
+# Задание 7
+print('Количество студентов с именем Дима: ',kort_nam.count('Дима'))
+
+# Задание 8
+dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam}
+print('Словарь: ', dict_bas)

TEMA2/report.md

@@ -0,0 +1,469 @@
+# Отчет по Теме 2
+
+Турханов Артем, А-03-23
+
+## 1 Изучение простых объектов
+
+```py
+>>> f1 = 16; f2 = 3
+>>> f1,f2
+(16, 3)
+>>> f1;f2
+16
+3
+>>> 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(f1)
+<class 'int'>
+>>> type(f2)
+<class 'int'>
+>>> del f1,f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+## 2 Изучение правил именования объектов
+```py
+>>> gg1 = 1.6
+>>> gg1
+1.6
+>>> hh1 = 'Строка'
+>>> hh1
+'Строка'
+>>> 73sr=3
+SyntaxError: invalid decimal literal
+>>> and=7
+SyntaxError: invalid syntax
+```
+
+## 3 Ключевые слова
+```py
+>>> 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']
+>>> ls = keyword.kwlist
+ls
+['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 Внутренние идентификаторы
+```py
+>>> import builtins
+>>> dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+
+## 5 Изучение базовых функций
+```py
+>>> abs(-123)
+123
+>>> len(dir(builtins))
+161
+>>> max(1,2,3,4,-1,-5)
+4
+>>> min(-1,-2,-5,1,6,3)
+-5
+>>> pow(2,3)
+8
+>>> 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(3.14129,2)
+3.14
+>>> round(1.5); round(2.5)
+2
+2
+>>> sorted([1,5,3,7,6,0,3])
+[0, 1, 3, 3, 5, 6, 7]
+>>> sorted(['Artem', 'Ann', 'Kate', 'Mike'])
+['Ann', 'Artem', 'Kate', 'Mike']
+>>> sorted(['Artem', 'Ann', 'Kate', 'Mike'], key = len)
+['Ann', 'Kate', 'Mike', 'Artem']
+>>> sum([1,2,3,4,5,6,7,8,9])
+45
+>>> sum([1,2,3,4,5,6,7,8,9], 10)
+55
+>>> firstNames = ['Artem', 'Kate', 'Ann']
+>>> lastNames = ['Sidorov', 'Ivanova', 'Petrova']
+>>> birthYears = [2005, 2004, 1995]
+>>> data = zip(firstNames, lastNames, birthYears)
+>>> list(data)
+[('Artem', 'Sidorov', 2005), ('Kate', 'Ivanova', 2004), ('Ann', 'Petrova', 1995)]
+```
+
+## 6 Важность регистра
+```py
+>>> Gg1=45
+>>> gg1; Gg1
+1.6
+45
+```
+
+## 7 Базовые типы объектов
+```py
+>>> bb1 = True; bb2 = False
+>>> bb1; bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+>>> ii1 = -123456789
+>>> type(ii1)
+<class 'int'>
+>>> ff1=-8.9876e-12
+>>> type(ff1)
+<class 'float'>
+>>> dv1=0b1101010
+>>> type(dv1)
+<class 'int'>
+>>> vsm1=0o52765
+>>> type(vsm1)
+<class 'int'>
+>>> shest1=0x7109af6
+>>> type(shest1)
+<class 'int'>
+>>> cc1=2-3j
+>>> type(cc1)
+<class 'complex'>
+>>> a=3.67; b=-0.45
+>>> cc2=complex(a,b)
+>>> type(cc2)
+<class 'complex'>
+>>> cc2
+(3.67-0.45j)
+```
+### 7.1 Строка символов
+```py
+>>> ss1='Это - строка символов'
+>>> ss1; type(ss1)
+'Это - строка символов'
+<class 'str'>
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+>>> ss1b = 'Меня зовут \n Турханов А.К.'
+>>> print(ss1b)
+Меня зовут 
+ Турханов А.К.
+>>> mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+>>> ss1[0]
+'Э'
+>>> ss1[8]
+'р'
+>>> ss1[-2]
+'о'
+```
+### 7.2 Срезы
+
+```py
+>>> ss1[6:9]
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[:13]
+'Это - строка '
+>>> >>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+```
+С отрицательным шагом
+```py
+>>> ss1[17:3:-2]
+'омсаот '
+```
+Так как индекс 17 и -4 (4-й символ с конца строки) - одно и то же при 21-ом элементе, то получится то же самое, что и выше:
+```py
+>>> ss1[-4:3:-2]
+'омсаот '
+```
+Стротка - неизменяемый объект
+```py
+>>> ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#114>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+```
+```py
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> ss1
+'Это = строка символов'
+>>> ss1b = ss1b[:13] + 'Ivanov I.I.'; ss1b
+>>> print(ss1b)
+Меня зовут 
+ Ivanov I.I.
+```
+Создадим еще несколько объектов разных типов данных
+```py
+>>> a = 10; a; type(a)
+10
+<class 'int'>
+>>> a = 1.14; a; type(a)
+1.14
+<class 'float'>
+>>> a = True; a; type(a)
+True
+<class 'bool'>
+>>> a = 4 + 2j; a; type(a)
+(4+2j)
+<class 'complex'>
+>>> a = complex(4,2); a; type(a)
+(4+2j)
+<class 'complex'>
+>>> a = 'Hello, World!'; a; type(a)
+'Hello, World!'
+<class 'str'>
+```
+
+## 8 Более сложные типы объектов
+### 8.1 Списки
+#### 8.1.1 Индексы и срезы
+```py
+>>> spis1=[111,'Spisok',5-9j]; spis1
+[111, 'Spisok', (5-9j)]
+>>> stup=[0,0,1,1,1,1,1,1,1]; stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis = [1,2,3,4,
+        5,6,7,
+        8,9,10]; spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+>>> spis[-1]
+10
+>>> stup[-8::2]
+[0, 1, 1, 1]
+```
+В последнем случае получилось, что, в результате среза исходного списка stup длиной в 9 элементов, мы получили список длиной в 4 элемента. Это можно объянсить так: так как в срезе мы указали, что выборка элементов (срез) будет происходить от 8-го элемента с конца (т.к. знак минус перед 8) и до посленего элемента. Так как шаг был указан равным 2, то получаем: 8 / 2 = 4 элемента войдут в новый список. 
+
+```py
+>>> spis1[1]='Список'; spis1
+[111, 'Список', (5-9j)]
+```
+#### 8.1.2 Методы списков
+Все методы списка spis1 можно увидеть камандой dir (они, методы, без двойных нижних подчеркиваний):
+```py
+>>> dir(spis1)
+['__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']
+```
+```py
+>>> help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+>>> spis1.append('New item')
+>>> spis1
+[111, 'Список', (5-9j), 'New item']
+>>> spis1+['New item']; spis1
+[111, 'Список', (5-9j), 'New item', 'New item']
+[111, 'Список', (5-9j), 'New item']
+```
+Можно заметить, что последняя операция не сохраняет изменения списка spis1, а только отобраает измененый список.
+```py
+>>> spis1.append(ss1b); spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+>>> spis1.pop(1); spis1
+'Список'
+[111, (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+>>> spis1.insert(1,"Второй элемент"); spis1
+[111, 'Второй элемент', 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+>>> help(spis1.remove)
+Help on built-in function remove:
+
+remove(value, /) method of builtins.list instance
+    Remove first occurrence of value.
+
+    Raises ValueError if the value is not present.
+
+>>> ls = [1,2,3,4,5,2]; ls.remove(2); ls
+[1, 3, 4, 5, 2]
+>>> help(ls.extend)
+Help on built-in function extend:
+
+extend(iterable, /) method of builtins.list instance
+    Extend list by appending elements from the iterable.
+
+>>> ls.extend([3,4,5,6])
+>>> ls
+[1, 3, 4, 5, 2, 3, 4, 5, 6]
+>>> ls.extend([3,4,5,6]); ls
+[1, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6]
+>>> help(ls.clear)
+Help on built-in function clear:
+
+clear() method of builtins.list instance
+    Remove all items from list.
+
+>>> ls.clear(); ls
+[]
+>>> ls = [1,2,5,4,7,6,9]
+>>> ls.sort(); ls
+[1, 2, 4, 5, 6, 7, 9]
+>>> ls.sort(reverse = True); ls
+[9, 7, 6, 5, 4, 2, 1]
+>>> a = ['aa','aaa','a','aaaa', 'bb']
+>>> a.sort(key = len); a
+['a', 'aa', 'bb', 'aaa', 'aaaa']
+>>> ls; ls.reverse(); ls
+[9, 7, 6, 5, 4, 2, 1]
+[1, 2, 4, 5, 6, 7, 9]
+>>> help(ls.copy)
+Help on built-in function copy:
+
+copy() method of builtins.list instance
+    Return a shallow copy of the list.
+```
+Shallow copy - поверхностная копия. При таком копировании любые сложные объекты исходного списка копируются (передаются) в новый список по ссылке. Это значит, что изменение такого скопированного объекта в копии приведет к изменению этого же объекта в исходнои списке. Такими сложными объектами могут являться, например, вложенные списки.
+```py
+>>> spis2 = [[1,2], [3,4],5,6,7]
+>>> cp = spis2.copy()
+>>> cp
+[[1, 2], [3, 4], 5, 6, 7]
+>>> cp[0][0] = 100; cp[3] = 200
+>>> spis2; cp
+[[100, 2], [3, 4], 5, 6, 7]
+[[100, 2], [3, 4], 5, 200, 7]
+```
+Можно заметить, что при изменении в cp (копии) части вложенного списка, изменения затронули и исходный список spis2. А вот изменение простого объекта - целочисленной переменной, имеющей значение 6, на значение 200, - не повлекло за собой изменения в исходном списке.
+```py
+>>> help(spis2.count)
+Help on built-in function count:
+
+count(value, /) method of builtins.list instance
+    Return number of occurrences of value.
+
+>>> a = [1,2,2,3,3,3,4,4,4,4]
+>>> a.count(1); a.count(2); a.count(4)
+1
+2
+4
+>>> help(ls.index)
+Help on built-in function index:
+
+index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance
+    Return first index of value.
+
+    Raises ValueError if the value is not present.
+
+>>> a.index(4)
+6
+```
+#### 8.1.3 Вложенные списки
+```py
+>>> spis2=[spis1,[4,5,6,7]]; spis2
+[[111, 'Второй элемент', 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.'], [4, 5, 6, 7]]
+>>> spis2[0][1]
+'Второй элемент'
+>>> spis2[0][1] = 78; spis2
+[[111, 78, 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.'], [4, 5, 6, 7]]
+>>> spis1
+[111, 78, 'Второй элемент', (5-9j), 'New item', 'Меня зовут \n Ivanov I.I.']
+```
+Заметим, что при изменении spis2[0][1] = 78, касающегося на первый взгляд только списка spis2, изменился и список spis1, который является составной чатсью (а имеено первым элементом) списка spis2. Это происходит потому, что имя списка - это переменная, указывающая на адрес списка (точнее: на адрес его первого элемента). Поэтому справедливо сказать, что записью spis2=[spis1,[4,5,6,7]] мы в качестве первого элемента списка spis2 передаем не просто какую-то копию списка spis1, а передаем адрес его (spis1) первого элемента. Такая передача называется передача по сслыке. Именно поэтому изменение первого элемента списка spis2 влечет за собой изменение не только в самом spis2, но и в его первом элементе - списке spis1.
+```py
+>>> ls = [1,'два',True,[4,4,4,4]]; ls
+[1, 'два', True, [4, 4, 4, 4]]
+>>> type(ls[0]);type(ls[1]);type(ls[2]); type(ls[3])
+<class 'int'>
+<class 'str'>
+<class 'bool'>
+<class 'list'>
+```
+### 8.2 Кортежи и их методы
+```py
+>>> kort1=(222,'Kortezh',77+8j); kort1
+(222, 'Kortezh', (77+8j))
+>>> kort1[0] = 1
+Traceback (most recent call last):
+  File "<pyshell#89>", line 1, in <module>
+    kort1[0] = 1
+TypeError: 'tuple' object does not support item assignment
+>>> kort1= kort1+(1,2); kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1= kort1+(ss1b,); kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут \n Ivanov I.I.')
+>>> type((0,))
+<class 'tuple'>
+>>> kort2=kort1[:2]+kort1[3:]; kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут \n Ivanov I.I.')
+>>> kort1.index(2)
+4
+>>> kort1.count(222)
+1
+```
+### 8.3 Словари
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}; dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>> dic1['Orel']
+56
+>>> dic1['Pskov']=78; dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}; 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 Ivanov I.I.'}
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b])); dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут \n Ivanov I.I.'}
+>>> keys = (11,22,33,44,55,66,77)
+>>> values = ['один','два','три','четыре','пять']
+>>> dict(zip(keys,values))
+{11: 'один', 22: 'два', 33: 'три', 44: 'четыре', 55: 'пять'}
+>>> dict(zip(values,keys))
+{'один': 11, 'два': 22, 'три': 33, 'четыре': 44, 'пять': 55}
+```
+Предпоследняя операция выводит словарь, число элеиментов которого равно пяти. Количество элементов имеено пять, а не семь, потому, что функция zip объединяет два объекта (в нашем случае кортеж с ключами и массив со значениями). Так как кортеж содержит семь элементов, а массив - пять, то функция zip сделает из двух этих объектов кортеж из пяти элементов. Никакого "зацикливания" не будет.
+
+### 8.4 Множества. Операции с множествами
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}; mnoz1
+{'двигатель', 'микропроцессор', 'датчик', 'линия связи'}
+>>> len(mnoz1)
+4
+>>> 'датчик' in mnoz1
+True
+>>> mnoz1.add('реле'); mnoz1
+{'линия связи', 'микропроцессор', 'датчик', 'реле', 'двигатель'}
+>>> mnoz1.remove('линия связи'); mnoz1
+{'микропроцессор', 'датчик', 'реле', 'двигатель'}
+```
+Заметим, что логическое значение True, при создании сножества, воспринимается как 1. Поэтому ниже можно заметить, что значение True не вошло в множество, так как есть 1.
+```py
+>>> mnoz2 = {'строка',1,True,(5,6),1,'строка', False};mnoz2
+{False, 1, (5, 6), 'строка'}
+>>> len(mnoz2)
+4
+>>> mnoz2.add(2); mnoz2
+{False, 1, 2, 'строка', (5, 6)}
+>>> False in mnoz2
+True
+>>> 'строка' in mnoz2
+True
+>>> mnoz2.remove(2); mnoz2
+{False, 1, 'строка', (5, 6)}
+```

TEMA2/task.md

@@ -0,0 +1,94 @@
+# Общее контрольное задание по теме 2
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фа-милией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов перемен-ных, использованных в предыдущих операторах, а значениями – ранее созданные пере-менные, соответствующие этим типам.
+## Решение
+Работа в интерпретаторе Python: 
+```py
+>>> familia = 'Turkhanov' # задание 1
+>>> c = familia[0] # задание 2
+>>> import keyword # задание 3
+>>> sp_kw = keyword.kwlist
+>>> sp_kw # задание 4
+['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']
+>>> 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']
+>>> kort_nam = ('Артем', 'Илья', 'Дима', 'Даня') # задание 5
+>>> type(kort_nam)
+<class 'tuple'>
+>>> kort_nam = kort_nam + ('Макс', 'Саша') # задание 6
+>>> kort_nam
+('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')
+>>> kort_nam.count('Дима') # задание 7
+1
+>>> dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam} # задание 8
+>>> dict_bas
+{'Строка': 'Turkhanov', 'Список': ['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'], 'Кортеж': ('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')}
+```
+Реализация в тектовом файле:
+```py
+# Общее контрольное задание по теме 2
+# Турханов Артем, А-03-23
+
+import keyword
+
+# Задание 1
+familia = 'Turkhanov'
+
+# Задание 2
+c = familia[0]
+
+# Задание 3
+sp_kw = keyword.kwlist
+
+# Задание 4
+print('Список ключевых слов: ', sp_kw)
+sp_kw.remove('nonlocal')
+print('Список ключевых слов без nonlocal: ', sp_kw)
+
+# Задание 5
+kort_nam = ('Артем', 'Илья', 'Дима', 'Даня')
+print('Класс (тип) данных созданноого кортежа: ',type(kort_nam))
+
+# Задание 6
+print('Исходный кортеж: ', kort_nam)
+kort_nam = kort_nam + ('Макс', 'Саша')
+print('Измененный кортеж: ', kort_nam)
+
+# Задание 7
+print('Количество студентов с именем Дима: ',kort_nam.count('Дима'))
+
+# Задание 8
+dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam}
+print('Словарь: ', dict_bas)
+
+```
+
+Результат исполнения программы, записанной в тектосвый файл: 
+```py
+== RESTART: D:/!!!Download/Documents/учёба МЭИ/5 СЕМЕСТР/GIT/python-labs/TEMA2/Pr2.py ==
+Список ключевых слов:  ['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']
+Список ключевых слов без nonlocal:  ['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']
+Класс (тип) данных созданноого кортежа:  <class 'tuple'>
+Исходный кортеж:  ('Артем', 'Илья', 'Дима', 'Даня')
+Измененный кортеж:  ('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')
+Количество студентов с именем Дима:  1
+Словарь:  {'Строка': 'Turkhanov', 'Список': ['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'], 'Кортеж': ('Артем', 'Илья', 'Дима', 'Даня', 'Макс', 'Саша')}
+```

TEMA3/report.md

@@ -0,0 +1,754 @@
+# Отчет по Теме 3
+
+Турханов Артем, А-03-23
+
+## 1 Преобразование простых базовых типов
+### 1.1 Преобразование в логический тип
+```py
+>>> logiz1=bool(56); logiz1; type(logiz1)
+True
+<class 'bool'>
+>>> logiz2=bool(0); logiz2; type(logiz2)
+False
+<class 'bool'>
+>>> logiz3=bool('Beta'); logiz3; type(logiz3)
+True
+<class 'bool'>
+>>> logiz4=bool(''); logiz4; type(logiz4)
+False
+<class 'bool'>
+```
+### 1.2 Преобразование в целочисленный тип
+```py
+>>> tt1=int(198.6); tt1
+198
+>>> tt2=int("-76"); tt2
+-76
+>>> tt3=int("B",16); tt3
+11
+>>> tt4=int("71",8); tt4
+57
+```
+Если же попробуем передать строку, содержащую число с точкой, то получим ошибку:
+```py
+>>> tt5=int("98.76"); tt5
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    tt5=int("98.76"); tt5
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+Это происходит потому, что int() может принимать только строки, содержащие целые числа. Функция не может конверитровать строку, содержащую число с точкой. 
+
+### 1.3 Преобразование в вещественный тип
+```py
+>>> flt1=float(789); flt1
+789.0
+>>> flt2=float(-6.78e2); flt2
+-678.0
+>>> flt3=float("Infinity"); flt3
+inf
+>>> flt4=float("-inf"); flt4
+-inf
+```
+### 1.4 Преобразование в другие системы счисления
+
+```py
+>>> hh=123
+>>> dv1=bin(hh); dv1
+'0b1111011'
+>>> vos1=oct(hh); vos1
+'0o173'
+>>> shs1=hex(hh); shs1
+'0x7b'
+```
+Выполним обратное преобразование для проверки полученных результатов:
+```py
+>>> int(dv1,2)
+123
+>>> int(vos1,8)
+123
+>>> int(shs1,16)
+123
+```
+## 2 Преобразование более сложных базовых типов
+### 2.1 Преобразование в строку символов
+```py
+>>> strk1=str(23.6); strk1
+'23.6'
+>>> strk2=str(logiz3); logiz3; strk2
+True
+'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}"
+```
+### 2.2 Преобразование элементов объекта в список
+```py
+>>> 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']
+```
+Заметим, что из словаря в список попали только ключи. Чтобы в список смогли попасть не ключи, а значения словаря, можно выполнить следующую инструкцию:
+```py
+>>> spis4=list({"A":1,"B":2,"C":9}.values()); spis4
+[1, 2, 9]
+```
+### 2.3 Преобразование элементов объектов в кортеж
+```py
+>>> kort7=tuple('Строка символов'); kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2); spis2; kort8
+[124, 236, -15, 908]
+(124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9}); kort9
+('A', 'B', 'C')
+```
+### 2.4 Удаление объектов
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort8', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk1', 'strk2', 'strk3', 'strk4', 'strk5', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+>>> del strk5, kort8
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+>>> my_name = 'Turkhanov A.K.'
+>>> spis = list(my_name);spis
+['T', 'u', 'r', 'k', 'h', 'a', 'n', 'o', 'v', ' ', 'A', '.', 'K', '.']
+>>> tp = tuple(spis); tp
+('T', 'u', 'r', 'k', 'h', 'a', 'n', 'o', 'v', ' ', 'A', '.', 'K', '.')
+>>> s = str(tp); s
+"('T', 'u', 'r', 'k', 'h', 'a', 'n', 'o', 'v', ' ', 'A', '.', 'K', '.')"
+```
+## 3 Арифметические операции
+### 3.1 Сложение и вычитание
+```py
+>>> 12+7+90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994
+>>> 23.6+54
+77.6
+>>> 14-56.7+89
+46.3
+```
+### 3.2 Умножение
+```py
+>>> -6.7*12
+-80.4
+```
+### 3.3 Деление
+```py
+>>> -234.5/6
+-39.083333333333336
+>>> a=178/45; a; type(a)
+3.9555555555555557
+```
+### 3.4 Деление нацело
+```py
+<class 'float'>
+>>> b=178//45; b; type(b)
+3
+<class 'int'>
+>>> c=-24.6//12.1; c; type(c)
+-3.0
+<class 'float'>
+>>> d = 178//-24.6; d; type(d)
+-8.0
+<class 'float'>
+>>> e = -24.6//45; e; type(e)
+-1.0
+<class 'float'>
+```
+### 3.5 Остаток от деления
+```py
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+>>> x = 148%3.8; x; type(x)
+3.6000000000000068
+<class 'float'>
+>>> y = 12.6%5; y; type(y)
+2.5999999999999996
+<class 'float'>
+```
+### 3.6 Возведение в степень
+```py
+>>> 14**3
+2744
+>>> e=2.7**3.6; e
+35.719843790663525
+>>> x = 14**3.2
+>>> x
+4651.678749230765
+>>> y = 2.7**3; y
+19.683000000000003
+```
+### 3.7 Арифметические операции с комплексными числами
+```py
+>>> z1 = 1 + 2j; z2 = 2 - 1j
+>>> z1 + z2
+(3+1j)
+>>> z1 - z2
+(-1+3j)
+>>> z1*z2
+(4+3j)
+>>> 2*z1
+(2+4j)
+>>> 2.8*z2
+(5.6-2.8j)
+>>> z1/z2
+1j
+>>> z1/3.8
+(0.2631578947368421+0.5263157894736842j)
+>>> z2/3
+(0.6666666666666666-0.3333333333333333j)
+>>> z1//3.8; z1//3
+Traceback (most recent call last):
+  File "<pyshell#30>", line 1, in <module>
+    z1//3.8; z1//3
+TypeError: unsupported operand type(s) for //: 'complex' and 'float'
+>>> z1 // 4
+Traceback (most recent call last):
+  File "<pyshell#31>", line 1, in <module>
+    z1 // 4
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+>>> z1 % 2
+Traceback (most recent call last):
+  File "<pyshell#32>", line 1, in <module>
+    z1 % 2
+TypeError: unsupported operand type(s) for %: 'complex' and 'int'
+>>> z1**3
+(-11-2j)
+>>> z2**z1
+(2.3304790489341802+5.149201131069769j)
+```
+Можно заметить, что с комплексными числами невозможно выполнить операции деления нацело и взятие остатка от деления.
+
+## 4 Операции с двоичными числами
+### 4.1 Двоичная инверсия
+```py
+>>> dv1=9; bin(dv1)
+'0b1001'
+>>> dv2 = ~dv1; dv2; bin(dv2);
+-10
+'-0b1010' # Не соответсвует тому, как Python представляет отрицательные целые числа
+```
+Получиили число -10. Дело в том, что в Python целые числа представляются в "дополнительном коде". Например у нас есть 8-битное целое число. Пусть это будет число 9, как в примере выше. Его доичное представление: 00001001. Инвертируя каждый бит с помощью операции двоичный инверсии ~, получаем: 11110110. И до, и после инверсии битов двоичное представление числа - это представление в дополнительном коде. В силу способа перевода прямого кода в дополнительный, заметим, что инверсное число 9, то есть 11110110 в двоичном предаствлении, - это не что иное, как целое число -10. Докажем это:
+число -10 получается из числа 10. В двоичном представлении 10 - это: 00001010. Инверсируя каждый бит, получаем: 11110101. Прибавляем единицу: 11110101 + 1 = 11110110. Ч.т.д.
+### 4.2 Двоичное "И"
+```py
+>>> a = 7&9; bin(7), bin(9), bin(a)
+('0b111', '0b1001', '0b1')
+>>> a = 7&8; bin(7), bin(8), bin(a)
+('0b111', '0b1000', '0b0')
+```
+### 4.3 Двоичное "ИЛИ"
+```py
+>>> a = 7|9; bin(7), bin(9), bin(a)
+('0b111', '0b1001', '0b1111')
+>>> a = 7|8; bin(7), bin(8), bin(a)
+('0b111', '0b1000', '0b1111')
+>>> a = 14|5; bin(14), bin(5), bin(a)
+('0b1110', '0b101', '0b1111')
+```
+### 4.4 Двоичное "исключающее ИЛИ"
+```py
+>>> a = 14^5; bin(14), bin(5), bin(a); a
+('0b1110', '0b101', '0b1011')
+11
+```
+### 4.3 Побитовый сдвиг
+```py
+>>> h=14; bin(h)
+'0b1110'
+>>> g=h<<2; bin(g)
+'0b111000'
+>>> g1=h>>1; bin(g1)
+'0b111'
+>>> g2=h>>2; bin(g2)
+'0b11'
+```
+И другие примеры двоичных операций:
+```py
+>>> a = 120; b = 125; bin(120); bin(125)
+'0b1111000'
+'0b1111101'
+>>> ~a; ~b
+-121
+-126
+>>> a&b; bin(a&b)
+120
+'0b1111000'
+>>> a|b; bin(a|b)
+125
+'0b1111101'
+>>> a^b; bin(a^b)
+5
+'0b101'
+>>> bin(a); bin(a<<2)
+'0b1111000'
+'0b111100000'
+>>> bin(b); bin(b>>1)
+'0b1111101'
+'0b111110'
+```
+## 5 Операции при работе с последовательностями (строками, списками, кортежами)
+### 5.1 Конкатенация
+```py
+>>> 'Система '+'регулирования'
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+### 5.2 Повторение
+```py
+>>> 'ля-'*5
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*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)
+```
+### 5.3 Проверка наличия заданного элемента в последовательности
+```py
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka
+True
+>>> 'ку' in ['ку','-']*3
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
+False
+```
+### 5.4 Подстановка значений в строку
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+## 6 Присваивание
+### 6.1 Присваивание значения переменной
+```py
+>>> zz=-12; zz
+-12
+```
+### 6.2 Увеличение (уменьшение) на заданную величину
+```py
+>>> zz+=5; zz
+-7
+>>> zz-=3; zz
+-10
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+```
+### 6.3 Умножение (деление) на заданную величину
+```py
+>>> zz; zz/=2; zz
+-10
+-5.0
+>>> zz*=5; zz
+-25.0
+>>> stroka='Повтор '
+>>> stroka *= 3; stroka
+'Повтор Повтор Повтор '
+```
+### 6.4 Деление с округлением вниз, получение остатка от деление и возведение в степень
+```py
+>>> a = 35; a //= 3; a
+11
+>>> a = 35; a %= 3; a
+2
+```
+### 6.5 Множественное присваивание
+```py
+>>> w=v=10; w; v
+10
+10
+>>> n1,n2,n3=(11,-3,'all')
+>>> n1; n2; n3
+11
+-3
+'all'
+>>> n1,n2,n3='1,2,3'
+Traceback (most recent call last):
+  File "<pyshell#77>", line 1, in <module>
+    n1,n2,n3='1,2,3'
+ValueError: too many values to unpack (expected 3)
+>>> n1,n2,n3=[1,2,3]
+>>> n1; n2; n3
+1
+2
+3
+>>> n1,n2=[1,2,3]; n1; n2
+Traceback (most recent call last):
+  File "<pyshell#80>", line 1, in <module>
+    n1,n2=[1,2,3]; n1; n2
+ValueError: too many values to unpack (expected 2)
+>>> n1,n2,n3={1,2,3}
+>>> n1; n2; n3
+1
+2
+3
+>>> n1,n2={1,2,3}; n1; n2
+Traceback (most recent call last):
+  File "<pyshell#83>", line 1, in <module>
+    n1,n2={1,2,3}; n1; n2
+ValueError: too many values to unpack (expected 2)
+```
+Заметим, что при множественном присваивании нельзя использовать строку. Кортеж, список и множество использовать можно. Но важно, чтобы количество переменных, которым присваиваются значения, было равно количество элементов кортежа, списка или множества.
+## 7 Логические операции
+### 7.1 Сравнение
+```py
+>>> w; v
+10
+10
+>>> w == v
+True
+>>> w != v
+False
+>>> 1 != 2
+True
+>>> 3 < 10
+True
+>>> 10 > 5
+True
+>>> 3 <= 3; 5>= 3; 7>= 7
+True
+True
+True
+```
+### 7.2 Проверка наличия
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1; 'cap' in mnoz1
+True
+False
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> 'Vologda' in dic1; 'Pskov' in dic1; 56 in dic1.values();
+True
+False
+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
+```
+### 7.3 Логические выражения
+```py
+>>> a=17; b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+>>> (b<a) and not('UII' in dct1['Institut'])
+True
+>>> 'VMSS' in dct1['Depart'] or not(b != 0)
+True
+```
+### 7.4 Проверка ссылок переменных на один и тот же объект
+```py
+>>> w=v=10
+>>> w is v
+True
+>>> w1=['A','B']; v1=['A','B']
+>>> w1 is v1
+False
+```
+В случае использования операции множественного присваивания все переменные будут ссылаться на один и тот же объект (одну и ту же ячейку) оперативной памяти. Если же двум различным переменным (не при множественном присваивании, а отдельно) присвоено одно и то же значение, то они, переменные, будут ссылаться на разные объекты оперативной памяти. Потому и операция w1 is v1 выдаст FALSE.
+## 8 Методы
+```py
+>>> 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']
+```
+### 8.1 Методы для работы со строками
+```py
+>>> stroka.find('пр')
+5
+>>> stroka.count("с")
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ')
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22); stroka3
+'Микропроцессорная система управления'
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7); strk1
+'Момент времени 1, значение = 89.7'
+'Момент времени {}, значение = {}'
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+### 8.2 Методы для работы со списками
+```py
+>>> spsk = [1, 'два', 3.0, True, 5j]
+>>> dir(spsk)
+['__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']
+>>> spsk.pop(2)
+3.0
+>>> spsk
+[1, 'два', True, 5j]
+>>> spsk.append('c'); spsk
+[1, 'два', True, 5j, 'c']
+>>> spsk.insert(2,'a'); spsk
+[1, 'два', 'a', True, 5j, 'c']
+>>> spsk.count('a')
+1
+>>> spsk
+[1, 'два', 'a', True, 5j, 'c']
+```
+Операциия spsk.pop(2) "вытягивает" (от агнл. pop - выпригивать) из списка spsk элемент с индексом 2, т.е. третий элемент. При этот элемент удаляется из списка. То есть метод (функция) pop(i) удаляет элемент списка под индексом i и возвращает его (удаленного элемента) значение. 
+
+Операция spsk.append('c') добавляет в конец списка spsk элемент 'c'.
+
+Операция spsk.insert(2, 'a') вставляет на место второго индекса элемент 'a'.
+
+Операция spsk.count('a') возвращает количество элементов 'a' в списке spsk.
+### 8.3 Методы для работы с кортежами
+```py
+>>> t1 = (1, 'два', 3.0, True, 5j)
+>>> dir(t1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+>>> t1.count('a')
+0
+>>> t1.count(1)
+2
+>>> t1.index('два'); t1.index(1)
+1
+0
+```
+Метод count аналогичен одноименному методу списков: возвращает колчество элементов, соответствующих элементу, переданному в качестве аргумента фунции count().
+
+Метод index возвращает первое вхождение (инедкс первого вхождения) элемента, указанного в качестве аргумента функции index().
+### 8.4 Методы для работы со словарями
+```py
+>>> d1 = {'name': 'Artem', 'age': 20, 'institute':'MPEI'}
+>>> dir(d1)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> d2 = d1.copy(); d2
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d3 = d1; d3
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d3 is d1
+True
+>>> d2 is d1
+False
+>>> d2['name'] = 'Ivan'; d2; d1
+{'name': 'Ivan', 'age': 20, 'institute': 'MPEI'}
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d3['name'] = 'Jacob'; d3; d1
+{'name': 'Jacob', 'age': 20, 'institute': 'MPEI'}
+{'name': 'Jacob', 'age': 20, 'institute': 'MPEI'}
+```
+Метод copy создает неглубоекую копю словаря, переданного как аргумент функции copy(). В нашем случае d2 - неглубокая копия словая d1, а d3 - просто копия словаря d1. Это можно показать с помощью оператора is. Операция d3 is d1 дает True. Это значит, что d3 и d1 ссылаются на один и тот же элемент (ячейку) оперативной памяти ПК, и изменения d3 повлечет за собой изменения и d1 и наоборот. В случае же неглубокой копии d2 создаетяся новая ячейка оперативной памяти, куда копируется содержимое ячейки памяти элементов d1. Т.е. в таком случае словари d2 и d1 никак между собой не связаны. Они указывают на разные ячейки памяти ПК. Это можно увидеть, выполнив операцию d2 is d1, которая вернет False. Поэтому изменение элементов словаря d2 никак не повлияет на изменение словаря d1.
+
+```py
+>>> help(d1.get)
+Help on built-in function get:
+
+get(key, default=None, /) method of builtins.dict instance
+    Return the value for key if key is in the dictionary, else default.
+
+>>> d1.get('name'); d1.get('surname')
+'Jacob'
+```
+Метод get дает возможность получить значение по ключу.
+```py
+>>> d1.items()
+dict_items([('name', 'Jacob'), ('age', 20), ('institute', 'MPEI')])
+```
+Метод items дает возможность посмотреть все элементы (ключи и значения) словаря.
+```py
+>>> d1.values()
+dict_values(['Jacob', 20, 'MPEI'])
+```
+Метод values дает возможность посмотреть все значения, хранящиеся в словаре, без ключей.
+```py
+>>> d1.keys()
+dict_keys(['name', 'age', 'institute'])
+```
+Метод keys дает возможность посмотреть все ключи, имеющиеся в словаре, без соответствующих им значений.
+```py
+>>> help(d1.pop)
+Help on built-in function pop:
+
+pop(key, default=<unrepresentable>, /) method of builtins.dict instance
+    D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+
+    If the key is not found, return the default if given; otherwise,
+    raise a KeyError.
+
+>>> d1.pop('name'); d1
+'Jacob'
+{'age': 20, 'institute': 'MPEI'}
+```
+Метод pop дает возможность "вырвать" элемент из словаря: получить значение по заданному ключи. При этом элемент, значение которго было получено с помощью pop() по его ключу, будет удален из словаря.
+```py
+>>> d1['name'] = 'Artem'; d1
+{'age': 20, 'institute': 'MPEI', 'name': 'Artem'}
+>>> name = ('John', 'Alex', 'Kate')
+>>> age = 20
+>>> d4 = dict.fromkeys(name, age); d4
+{'John': 20, 'Alex': 20, 'Kate': 20}
+```
+Метод fromkeys дает возможность содать словарь по заданной последовательности ключей, присвоив им значение None (по умолчанию) или же то значение, которое мы сами зададим.
+```py
+>>> d1.popitem(); d1
+('name', 'Artem')
+{'age': 20, 'institute': 'MPEI'}
+>>> d1.popitem(); d1
+('institute', 'MPEI')
+{'age': 20}
+```
+Метод popitem дает возможность выбрать, "выдернуть" элемент из словаря. Функция popitem не принимает никаких аргументов. Она выбирает элемент словаря по принципу LIFO. При выборке элемента, он (элемент) удаляется из словаря.
+```py
+>>> d1 = {'name': 'Artem', 'age': 20, 'institute':'MPEI'}
+>>> d5 = {'name': 'Artemiy', 'surname': 'Turkhanov'}
+>>> d1.update(d5, city = 'Moscow'); d1
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow'}
+>>> d1
+{'name': 'Artem', 'age': 20, 'institute': 'MPEI'}
+>>> d5 = {'name': 'Artemiy', 'surname': 'Turkhanov'}
+>>> d1.update(d5, city = 'Moscow'); d1
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow'}
+```
+Метод update дает возможность обновлять словарь: добавлять новые элементы, изменять имеющиеся разными способами.
+```py
+>>> d1.setdefault('city'); d1
+'Moscow'
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow'}
+>>> d1.setdefault('country'); d1
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow', 'country': None}
+>>> d1.setdefault('gender', 'male'); d1
+'male'
+{'name': 'Artemiy', 'age': 20, 'institute': 'MPEI', 'surname': 'Turkhanov', 'city': 'Moscow', 'country': None, 'gender': 'male'}
+```
+Метод setdefault дает возможность получить значение элемента словаря по заданному ключу, а если такого ключа не существует в данном словаре, то создает новый элемент с заданным ключом и значением по умполчанию, а также возвращает указанное значение по умолчанию (если не находит элемента с заданным ключом).
+```py
+>>> d1.clear(); d1
+{}
+```
+Метод clear дает возможность очистить словарь от всех его элементов.
+### 8.5 Методы для работы с множествами
+```py
+>>> s1 = set([1, 'два', 3.0, True, 5j])
+>>> s1
+{1, 3.0, 5j, 'два'}
+>>> dir(s1)
+['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__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']
+>>> s1.add(2); s1
+{1, 2, 3.0, 5j, 'два'}
+>>> s1.add(1); s1
+{1, 2, 3.0, 5j, 'два'}
+```
+Метод add дает возможность добавлять уникальные элементы в множество.
+```py
+>>> s1 = {'a', 'b', 'c'}; s2 = {'d', 'a', 'f'}
+>>> s1.difference(s2); s2.difference(s1)
+{'b', 'c'}
+{'f', 'd'}
+>>> s1.difference_update(s2)
+>>> s1
+{'c', 'b'}
+```
+Методы difference и difference_update позволяют получить разность множеств, т.е. понять, какие элементы есть только в первом множестве. Однако первый метод возвращает новое множество, а второй - изменяет первое множество на "разность".
+```py
+>>> s1.discard('a')
+>>> s1
+{'c', 'b'}
+>>> s1.remove('a')
+Traceback (most recent call last):
+  File "<pyshell#87>", line 1, in <module>
+    s1.remove('a')
+KeyError: 'a'
+>>> s1.discard('c'); s1
+{'b'}
+>>> s1.remove('b'); s1
+set()
+```
+Методы discard и remove тоже похожи между собой. И тот, и другой удаляют элемент из множества. Только remove, если не найдет указанный элемент, который мы хотим удалить, выдаст ошибку KeyError, когда discard никакой ошибки не выдает, если не находит нужного эемента.
+```py
+>>> s2
+{'a', 'f', 'd'}
+>>> s1 = {'a', 'f', 'c'}
+>>> s1.intersection(s2); s2.intersection(s1)
+{'a', 'f'}
+{'a', 'f'}
+>>> s1.intersection_update(s2); s1
+{'a', 'f'}
+```
+Методы intersection и intersection_update также очень похоже. Это методы выделения пересечения множеств, т.е. нахождения общих элементов двух множеств и создания из них нового множества. Только первый метод не изменяет исходного множества (первого), а просто возвращает пересечение, когда как второй метод изменяет: присваивает первому множеству значения множества, полученног путем пересечения двух сравниваемых множеств.
+```py
+>>> s2
+{'a', 'f', 'd'}
+>>> s1.isdisjoint(s2); s2.isdisjoint(s1)
+False
+False
+```
+Метод isdisjoint дает возможность проверить: являются ли множества перечекающимися. Если первое множества пересекаются, то функция isdisjoin() выдаст False, если же нет - True.
+```py
+>>> s1.issubset(s2); s2.issubset(s1)
+True
+False
+>>> s1.issuperset(s2); s2.issuperset(s1)
+False
+True
+```
+Методы issubset и issuperset очень похожи. До противоположности. issubset позволяет понять, является ли первое множество подмножеством второго, или нет. А issuperset - является ли первое множество надмножеством второго. 
+```py
+>>> s1; s2
+{'a', 'f'}
+{'a', 'f', 'd'}
+>>> s1.add('c')
+>>> s1.symmetric_difference(s2); s2.symmetric_difference(s1)
+{'c', 'd'}
+{'d', 'c'}
+>>> s1.symmetric_difference_update(s2); s1
+{'d', 'c'}
+```
+Методы symmetric_difference и symmetric_difference_update очень похожи. И тот, и другой создают новое множество, которое является склейкой элементов, которые не принадлежат пересечению двух данных множеств. Только первый метод просто возвращает новое множество, а второй - изменяет первое множество на новое.
+```py
+>>> s1.union(s2)
+{'f', 'd', 'a', 'c'}
+```
+Метод union объединяет два множества.
+```py
+>>> s1.update([1,2,3]); s1
+{1, 2, 3, 'd', 'c'}
+>>> s2.update((1,2,3))
+>>> s2
+{1, 2, 3, 'a', 'f', 'd'}
+>>> s1.update('Hello!')
+>>> s1
+{1, 2, 3, 'e', 'o', 'H', 'd', '!', 'l', 'c'}
+```
+Метод update позволяяет обновлять множество: добавлять в него новые элементы, используя в качестве аргумента функции update() дюбой итерируемый объект (список, кортеж или строку).
+
+Также у множеств есть еще методы pop и clear, действия которых аналогичны одноименным методам словарей, которые были рассмотрены в п. 8.4 "Методы для работы со словарями".

TEMA3/task.md

@@ -0,0 +1,93 @@
+# Общее контрольное задание по теме 3
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Преобразовать восьмеричное значение 45 в целое число.
+
+•	Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а за-тем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+
+•	Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+•	Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключа-ющее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+•	Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+•	Определить список методов, доступных у ранее созданного словаря D. Поочередно использо-вать его методы keys и values, определить, что можно получить с применением этих методов.
+
+•	Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+```py
+>>> oct45 = oct(45); oct45
+'0o55'
+>>> dec45 = int(oct45, 8); dec45
+45
+```
+### Задача 2
+```py
+>>> D = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+>>> dict_keys = D.keys(); dict_keys
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+type(dict_keys )
+<class 'dict_keys'>
+>>> dict_values = D.values(); dict_values
+dict_values([23, 12, 78])
+>>> T = tuple(dict_keys) + tuple(dict_values); T
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+```
+Кортеж от списка отличается тем, что кортеж - это неизменяемый объект.
+### Задача 3
+```py
+>>> ((1768 // 24.8)%3)**2.4
+5.278031643091577
+```
+### Задача 4
+```py
+>>> ((~(13&27))^14)<<2
+-32
+```
+13 = 00001101, а 27 = 00011011. 13&27 = 00001001. ~ (13&27) = 11110110. 14 = 00001110. (~ (13&27))^14 = 11111000. ((~(13&27))^14) << 2 = 11100000. 
+
+Так как это в доп коде, то ~ (11100000 - 1) = 00100000. Что соответствует десятичному числу 32. Значит 11100000 - это двоичная  запись десятичного числа -32.
+### Задача 5
+```py
+>>> ls1 = list(('колебат '*4).split()); ls1
+['колебат', 'колебат', 'колебат', 'колебат']
+'аткол' in (ls1[1] + ls1[2])
+True
+```
+### Задача 6
+```py
+>>> help(D.keys)
+Help on built-in function keys:
+
+keys() method of builtins.dict instance
+    Return a set-like object providing a view on the dict's keys.
+
+>>> D.keys()
+dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
+>>> help(D.values)
+Help on built-in function values:
+
+values() method of builtins.dict instance
+    Return an object providing a view on the dict's values.
+
+>>> D.values()
+dict_values([23, 12, 78])
+```
+Используя методы keys и values, можно получить информацию о том, какие ключи (keys) и значения (values) имеются в словаре, к которму применены эти методы. В нашем случае словарь D имеет ключи: dict_keys(['усиление', 'запаздывание', 'постоянная времени']), и значения: dict_values([23, 12, 78]). 
+### Задача 7
+```py
+>>> s1 = 'Создать объект - символьную строку с текстом данного предложения'
+>>> ls2 = list(s1.split())
+>>> ls2
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> ls2[ls2.index('-')] = ','; ls2
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+>>> ls2.remove('данного'); ls2
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/test3.md

@@ -0,0 +1,59 @@
+# Тест по модулю 1
+
+Турханов Артем, А-03-23
+
+## Задание
+Вариант 17
+
+1)	Что означает название интерактивной оболочки IDLE?
+
+2)	Создайте объект-список с элементами - нечетными целыми числами, убывающими в диапазоне от 59 до 37. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию, позволяющую выделить из списка шестое по порядку число и записать его в виде отдельной переменной. Напишите инструкцию, добавляющую в конце списка число 35.  Отобразите на экране получившийся объект.
+
+4)	Преобразуйте список в кортеж. Напишите инструкцию, создающую новый кортеж, отличающийся от первого отсутствием числа 51. Отобразите получившийся объект. Преобразуйте кортеж в строку. Удалите из строки разделители чисел.  Отобразите получившийся объект.
+
+5)	Подсчитайте разность суммы 6-ти первых и 7-ми последних элементов созданного в п.3 списка. Проверьте результат расчета.
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+IDLE - Integrated Development and Learning Environment
+### Задача 2
+```py
+>>> ls = [i for i in range(59,36,-2)]
+>>> ls
+[59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37]
+>>> type(ls)
+<class 'list'>
+>>> dir(ls)
+['__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
+```py
+>>> x6 = ls[5]; x6
+49
+>>> ls.append(35); ls
+[59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35]
+```
+### Задача 4
+```py
+>>> tp1 = tuple(ls); tp1
+(59, 57, 55, 53, 51, 49, 47, 45, 43, 41, 39, 37, 35)
+>>> tp2 = tp1[:tp1.index(51)]+tp1[tp1.index(51)+1:]; tp2
+(59, 57, 55, 53, 49, 47, 45, 43, 41, 39, 37, 35)
+>>> str1 = str(tp2); str1
+'(59, 57, 55, 53, 49, 47, 45, 43, 41, 39, 37, 35)'
+>>> str2 = str1[1:len(str1)-1]; str2
+'59, 57, 55, 53, 49, 47, 45, 43, 41, 39, 37, 35'
+>>> ls2 = str2.split(', '); ls2
+['59', '57', '55', '53', '49', '47', '45', '43', '41', '39', '37', '35']
+>>> str3 = ''.join(ls2); str3
+'595755534947454341393735'
+```
+
+### Задача 5
+```py
+>>> sum(ls[:6]) - sum(ls[-7:])
+37
+```

TEMA4/report.md

@@ -0,0 +1,446 @@
+# Отчет по Теме 4
+
+Турханов Артем, А-03-23
+
+## 1 Стандартные функции
+```py
+>>> help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+>>> round(123.456,1); round(123.456,0)
+123.5
+123.0
+>>> round(123.456,-1)
+120.0
+>>> type(round(123.456,1))
+<class 'float'>
+>>> type(round(123.456,0))
+<class 'float'>
+>>> round(123.456); type(round(123.456))
+123
+<class 'int'>
+```
+Если же в качестве второго аргумента функции round нияего не указывать, то округление будет происходить до целого. Поэтому результат - число целочисленного типа данных (int). В противном же случае результатом будет число вещественного типа.
+```py
+>>> gg=range(76,123,9); gg; type(gg)
+range(76, 123, 9)
+<class 'range'>
+>>> list(gg)
+[76, 85, 94, 103, 112, 121]
+>>> range(23)
+range(0, 23)
+>>> list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+Если в функцию range передать всего один аргумент, то результатом выполнения функции будет итерируемый объет класса range с целочисленными значениями от 0 до того числа, которое было указано в качестве аргумента, не включительно c шагом по умолчанию, равным единице.
+
+```py
+>>> qq = ['Turkhanov', 'Ogarkov', 'Vasiliev', 'Semenov']
+>>> ff = zip(gg,qq); ff
+<zip object at 0x000001FA9B4AD340>
+>>> type(ff)
+<class 'zip'>
+>>> tuple(ff)
+((76, 'Turkhanov'), (85, 'Ogarkov'), (94, 'Vasiliev'), (103, 'Semenov'))
+>>> ff[0]; ff[3]
+Traceback (most recent call last):
+  File "<pyshell#32>", line 1, in <module>
+    ff[0]; ff[3]
+TypeError: 'zip' object is not subscriptable
+```
+В получившемся кортеже мы видим 4 объекта-кортежа, что соответствует длине самого короткого списка из двух (len(gg) = 6, len(qq) = 4). Заметим также, что к объекту ff типа zip нельзя обращаться по индексам.
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156');
+коэффициент усиления=100
+>>> dan; type(dan)
+344.0
+<class 'float'>
+>>> 5*100 - 156
+344
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+>>> abs(-10.12)
+10.12
+>>> pow(2,5)
+32
+>>> pow(2,5.3)
+39.396621227037315
+>>> pow(2.4,-5.3)
+0.009657849177552984
+>>> max(1,-2)
+1
+>>> min([1,3,-5,-122])
+-122
+>>> sum([1,3,5,3,7,4])
+23
+>>> help(divmod)
+Help on built-in function divmod in module builtins:
+
+divmod(x, y, /)
+    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
+
+>>> divmod(9,5)
+(1, 4)
+>>> a = [1,2,3,4,5,6,7,8,9]
+>>> len(a)
+9
+>>> a = map(int, input().split()); a
+1 2 3 4 5 6
+<map object at 0x000001FA9878E4D0>
+>>> list(a)
+[1, 2, 3, 4, 5, 6]
+```
+## 2 Функции из стандартного модуля math
+```py
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+>>> math.sin(math.pi/2)
+1.0
+>>> math.acos(-1)
+3.141592653589793
+>>> 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)
+180.0
+>>> math.radians(270)
+4.71238898038469
+>>> math.pi/2*3
+4.71238898038469
+>>> math.exp(1); math.exp(3)
+2.718281828459045
+20.085536923187668
+>>> 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 is not specified, returns the natural logarithm (base e) of x.
+
+>>> math.log(math.exp(1))
+1.0
+>>> math.log(math.exp(3))
+3.0
+>>> math.log10(pow(10,5))
+5.0
+>>> math.sqrt(121); math.sqrt(25)
+11.0
+5.0
+>>> 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(3.2); math.ceil(6.999)
+4
+7
+>>> 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(3.2); math.floor(6.999)
+3
+6
+>>> math.sin(2*math.pi/7 + pow(math.exp(1), 0.23))
+0.8334902641414562
+```
+## 3 Функции из модуля cmath
+```py
+>>> import cmath
+>>> dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>> cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+>>> cmath.phase(1-0.5j)
+-0.4636476090008061
+```
+## 4 Стандартный модуль random
+```py
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> 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()
+
+>>> help(random.uniform)
+Help on method uniform in module random:
+
+>>> uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = (a + b) / 2
+        Var[X] = (b - a) ** 2 / 12
+
+>>> random.uniform(1,10)
+7.820969962495622
+>>> 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.21580642037220688
+>>> 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(1,10)
+1
+>>> help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu=0.0, sigma=1.0) method of random.Random instance
+    Gaussian distribution.
+
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+
+    Not thread-safe without a lock around calls.
+
+>>> random.gauss(10, 2)
+6.560077457806456
+>>> help(random.choice)
+Help on method choice in module random:
+
+choice(seq) method of random.Random instance
+    Choose a random element from a non-empty sequence.
+
+>>> random.choice([1,2,3,4,5,6,7,8,9])
+1
+>>> help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x) method of random.Random instance
+    Shuffle list x in place, and return None.
+
+>>> x = [1,2,3,4,5,6,7,8,9]
+>>> random.shuffle(x); x
+[5, 7, 4, 3, 8, 1, 9, 2, 6]
+>>> help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha / (alpha + beta)
+        Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1))
+>>> random.betavariate(1,2)
+0.31509637997467377
+>>> 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
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha * beta
+        Var[X] = alpha * beta ** 2
+
+>>> random.gammavariate(1,2)
+0.0676205462545973
+>>> ls = [random.uniform(0,10), random.gauss(0,3), random.betavariate(1,2), random.gammavariate(1,2)]; ls
+[9.745005344582257, 2.16302978480045, 0.8426318147572717, 0.1932454384006428]
+```
+## 5 Функции из модуля time
+```py
+>>> import time
+>>> dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>> c1 = time.time(); c1
+1759138103.1649246
+>>> c2=time.time()-c1; c2
+21.219618320465088
+>>> dat=time.gmtime(); dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=9, tm_min=29, tm_sec=17, tm_wday=0, tm_yday=272, tm_isdst=0)
+>>> dat.tm_mon
+9
+>>> dat.tm_year; dat.tm_sec
+2025
+17
+>>> time.localtime()
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=12, tm_min=30, tm_sec=53, tm_wday=0, tm_yday=272, tm_isdst=0)
+>>> help(time.asctime)
+Help on built-in function asctime in module time:
+
+asctime(...)
+    asctime([tuple]) -> string
+
+    Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
+    When the time tuple is not present, current time as returned by localtime()
+    is used.
+>>> time.asctime(time.localtime())
+'Mon Sep 29 12:31:59 2025'
+>>> time.ctime()
+'Mon Sep 29 12:32:27 2025'
+>>> help(time.ctime)
+Help on built-in function ctime in module time:
+
+ctime(...)
+    ctime(seconds) -> string
+
+    Convert a time in seconds since the Epoch to a string in local time.
+    This is equivalent to asctime(localtime(seconds)). When the time tuple is
+    not present, current time as returned by localtime() is used.
+
+>>> time.ctime(time.time())
+'Mon Sep 29 12:33:19 2025'
+>>> help(time.sleep)
+Help on built-in function sleep in module time:
+
+sleep(object, /)
+    sleep(seconds)
+
+    Delay execution for a given number of seconds.  The argument may be
+    a floating-point number for subsecond precision.
+
+>>> time.sleep(10)
+>>> time.mktime(time.localtime())
+1759138661.0
+>>> time.time()
+1759138670.3741279
+```
+## 6 Графические функции
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x0000015807FF87D0>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show()
+```
+![Рисунок 1. Первый линейный график](Ris1.png)
+
+Мы видим отображение линйной зависимости x(t) в виде графика функции, являющегося прямой.
+```py
+>>> X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x00000158080ACF50>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x00000158080AD090>]
+>>> pylab.show()
+```
+![Рисунок 2. Несколько графиков на однои рисунке](Ris2.png)
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x0000015807183B60>, <matplotlib.patches.Wedge object at 0x000001580AB76990>, <matplotlib.patches.Wedge object at 0x000001580AB76D50>, <matplotlib.patches.Wedge object at 0x000001580AB76FD0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+```
+![Рисунок 3. Круговая диаграмма](Ris3.png)
+
+```py
+>>> data = [random.gauss() for i in range(1000)]
+>>> pylab.hist(data, bins = 30)
+(array([ 1.,  0.,  0.,  0.,  0.,  3.,  4., 15., 10., 19., 35., 53., 53.,
+       60., 90., 82., 90., 99., 96., 67., 65., 52., 32., 34.,  9., 14.,
+        9.,  4.,  3.,  1.]), array([-3.99649362, -3.76019089, -3.52388816, -3.28758542, -3.05128269,
+       -2.81497996, -2.57867722, -2.34237449, -2.10607176, -1.86976903,
+       -1.63346629, -1.39716356, -1.16086083, -0.92455809, -0.68825536,
+       -0.45195263, -0.2156499 ,  0.02065284,  0.25695557,  0.4932583 ,
+        0.72956103,  0.96586377,  1.2021665 ,  1.43846923,  1.67477197,
+        1.9110747 ,  2.14737743,  2.38368016,  2.6199829 ,  2.85628563,
+        3.09258836]), <BarContainer object of 30 artists>)
+>>> pylab.show()
+```
+![Рисунок 4. Гистограмма по выборке нормально распределенных значений](Ris4.png)
+
+```py
+>>> cat = ['Сентябрь', 'Октябрь', 'Ноябрь']
+>>> values = [100, 200, 30]
+>>> pylab.bar(cat, values)
+<BarContainer object of 3 artists>
+>>> pylab.title('Столбчатая диаграмма')
+Text(0.5, 1.0, 'Столбчатая диаграмма')
+>>> pylab.xlabel('Месяц')
+Text(0.5, 0, 'Месяц')
+>>> pylab.ylabel('Количество заявок, шт')
+Text(0, 0.5, 'Количество заявок, шт')
+>>> pylab.show()
+```
+![Рисунок 5. Столбчатая диаграмма](Ris5.png)
+
+## 7 Статистические функции
+```py
+>>> import statistics
+>>> data = [random.gauss(10,3) for i in range(1000)]
+>>> statistics.mean(data)
+10.13981944059001
+>>> statistics.stdev(data)
+3.053185233060045
+>>> statistics.median(data)
+10.073166882507437
+```

TEMA4/task.md

@@ -0,0 +1,83 @@
+# Общее контрольное задание по теме 4
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Напишите и исполните единое выражение, реализующее последовательное выполнение сле-дующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+
+•	Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+•	Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+•	Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+•	Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стан-дартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+•	Напишите инструкцию для определения временного интервала в минутах, прошедшего с мо-мента предыдущего (из п.2) определения временных параметров.
+
+
+
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+```py
+>>> ((round(cmath.phase(0.2 + 0.8j), 2)*20)//3, (round(cmath.phase(0.2 + 0.8j), 2)*20)%3)
+(8.0, 2.6000000000000014)
+```
+### Задача 2
+```py
+>>> import time
+>>> time.localtime()
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=8, tm_hour=13, tm_min=10, tm_sec=51, tm_wday=2, tm_yday=281, tm_isdst=0)
+>>> str(time.localtime().tm_hour) + ':' + str(time.localtime().tm_min)
+'13:13'
+```
+![Настоящее московское время](Ris6.png)
+### Задача 3
+```py
+>>> week = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+>>> import random
+>>> random.sample(week, 3)
+['Sunday', 'Wednesday', 'Tuesday']
+>>> random.sample(week, 3)
+['Sunday', 'Monday', 'Thursday']
+>>> random.sample(week, 3)
+['Tuesday', 'Monday', 'Wednesday']
+```
+### Задача 4
+```py
+>>> [i for i in range(14,33, 3)]
+[14, 17, 20, 23, 26, 29, 32]
+>>> random.choice([i for i in range(14,33, 3)])
+29
+>>> random.choice([i for i in range(14,33, 3)])
+20
+```
+### Задача 5
+```py
+>>> N = random.gauss(15,4)
+>>> N
+13.338543069074923
+>>> round(N)
+13
+>>> alphabet = 'qwertyuiopasdfghjklzxcvbnm'
+>>> alphabet = list(alphabet); alphabet
+['q', 'w', 'e', 'r', 't', 'y', 'u', 'i', 'o', 'p', 'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'z', 'x', 'c', 'v', 'b', 'n', 'm']
+>>> [random.choice(alphabet) for i in range(round(N))]
+['k', 'f', 'l', 'd', 'g', 'd', 'x', 'p', 'j', 'x', 't', 'q', 'c']
+>>> [random.choice(alphabet) for i in range(round(N))]
+['x', 'a', 'i', 'c', 'v', 'a', 't', 'z', 'b', 'm', 'u', 'p', 'g']
+```
+### Задача 6
+```py
+>>> c1 = time.time()
+>>> c1
+1759919247.2307003
+>>> c2 = time.time(); c2
+1759919725.6270442
+>>> c2 - c1
+478.3963439464569
+>>> (c2 - c1)//60
+7.0
+```

TEMA4/test.md

@@ -0,0 +1,26 @@
+# Индивидуальное задание по теме 4
+
+Турханов Артем, А-03-23
+
+## Работа в интерпретаторе Python
+```py
+>>> import time
+>>> t = time.time(); t
+1760343801.0813265
+>>> import random
+>>> a = [i for i in range(-37,62+1,11)]
+>>> a
+[-37, -26, -15, -4, 7, 18, 29, 40, 51, 62]
+>>> len(a)
+10
+>>> import math
+>>> b = random.choice(a)
+>>> b
+62
+>>> math.sin(b)
+-0.7391806966492228
+>>> round(math.sin(b),3)
+-0.739
+>>> print('Синус элемента',b,'равен', round(math.sin(b),3))
+Синус элемента 62 равен -0.739
+```

TEMA5/report.md

@@ -0,0 +1,274 @@
+# Отчет по Теме 5
+
+Турханов Артем, А-03-23
+
+## 1 Ветвление по условию. Условный оператор if
+```py
+>>> porog, rashod1, rashod2 = (4, 2, 3)
+>>> if rashod1>=porog:
+    	dohod=12
+		
+>>> if rashod1>=porog:
+    	dohod=12
+	elif rashod2 == porog:
+    	dohod=0
+	else:
+    	dohod=-8
+
+>>> dohod
+-8
+>>> if rashod1 >= 3 and rashod2 == 4:
+    	dohod = rashod1
+    	if rashod2 == porog or rashod1 < rashod2:
+        	dohod = porog
+>>> dohod
+-8
+>>> if porog == 3: dohod = 1
+	elif porog == 4: dohod = 2
+	elif porog == 5: dohod = 3
+	else: dohod = 0
+
+>>> dohod
+2
+>>> dohod = 4
+>>> dohod = 2 if porog >= 4 else 0
+>>> dohod
+2
+>>> if porog >= 5: rashod1 = 6; rashod2 = 0
+>>> rashod1; rashod2
+2
+3
+```
+
+## 2 Цикл по перечислению. Оператор for
+```py
+>>> temperatura=5
+>>> for i in range(3,18,3):
+    	temperatura+=i
+
+>>> temperatura
+50
+>>> 5+3+6+9+12+15
+50
+>>> 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, 2, 2, 2]
+>>> 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]
+>>> sps[:]
+[2, 15, 14, 8, 2, 2, 2, 2]
+
+>>> 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)
+
+11
+76
+150
+205
+285
+371
+427
+459
+466
+495
+>>> sps5
+[11, 65, 74, 55, 80, 86, 56, 32, 7, 29]
+>>> sum(sps5)
+495
+
+>>> sps5=[]
+>>> for i in range(10):
+    	sps5.append(rn.randint(1,100))
+    	ss=sum(sps5)
+    	if ss>500: break
+    	else: print(ss)
+
+47
+138
+200
+290
+357
+431
+438
+>>> sps5
+[47, 91, 62, 90, 67, 74, 7, 75]
+>>> sum(sps5)
+513
+
+>>> stroka='Это – автоматизированная система'
+>>> stroka1=""
+>>> for ss in stroka:
+    	stroka1+=" "+ss
+
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+>>> import math
+>>> sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+>>> import matplotlib.pyplot as plt
+>>> t = [i for i in range(100)]
+>>> plt.plot(t,sps2)
+[<matplotlib.lines.Line2D object at 0x000001D96549D810>]
+>>> plt.show()
+```
+![График синуса](Figure_1.png)
+
+## 3 Цикл по условию. Оператор while
+```py
+>>> rashod=300
+>>> while rashod:
+    	print("Расход=",rashod)
+    	rashod-=50
+
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Завершение цикла здесь произошло после прекращения выполнения условия while rashod, что аналогично условию "пока rashod раввен True". Когда rashod стал равен 0, это аналогично выражению rashod = False. Поэтому цикл завершился, так как условие прекратило выполняться
+
+```py
+>>> 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
+
+>>> len(sps2)
+39
+>>> plt.plot([i for i in range(39)], sps2); plt.show()
+[<matplotlib.lines.Line2D object at 0x000001D965822AD0>]
+```
+![График звена](Figure_2.png)
+```py
+>>> 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
+
+>>> for chislo in range(250, 301):
+    	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
+```

TEMA5/task.md

@@ -0,0 +1,65 @@
+# Общее контрольное задание по теме 5
+
+Турханов Артем, А-03-23
+
+## Задание
+•	Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+•	Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+•	Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его сред-ние баллы по двум сессиям.
+
+## Решение
+Работа в интерпретаторе Python: 
+### Задача 1
+```py
+>>> string = 'I am Artem'
+>>> alphabet = 'abcdefghijklmnopqrstuvwxyz'
+>>> for w in string:
+    	if w != ' ':
+        	print('Порядковый номер буквы ', w, 'в алафвите: ', alphabet.index(w.lower())+1)
+
+Порядковый номер буквы  I в алафвите:  9
+Порядковый номер буквы  a в алафвите:  1
+Порядковый номер буквы  m в алафвите:  13
+Порядковый номер буквы  A в алафвите:  1
+Порядковый номер буквы  r в алафвите:  18
+Порядковый номер буквы  t в алафвите:  20
+Порядковый номер буквы  e в алафвите:  5
+Порядковый номер буквы  m в алафвите:  13
+```
+### Задача 2
+```py
+>>> ls = list('Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).'.split())
+>>> w = 'словами'
+>>> for i in ls:
+    	if i == w:
+        	print('Искомое слово существует в списке!')
+        	break
+	else: print('Данного слова нет в списке!')
+
+Искомое слово существует в списке!
+>>> w = 'нет'
+>>> for i in ls:
+    	if i == w:
+        	print('Искомое слово существует в списке!')
+        	break
+	else: print('Данного слова нет в списке!')
+
+Данного слова нет в списке!
+```
+### Задача 3
+```py
+>>> stud_leto = ['Огарков', 'Турханов', 'Антонов']
+>>> ocenka_leto = [5, 4, 5]
+>>> stud_zima = ['Турханов', 'Антонов', 'Огарков']
+>>> ocenka_zima = [4, 5, 4]
+>>> name = input('Введите фамилию студента: ')
+Введите фамилию студента: Огарков
+>>> for i in stud_leto:
+    	if i == name:
+        	ocenka = (ocenka_leto[stud_leto.index(i)] + ocenka_zima[stud_zima.index(i)])/2
+        	print('Средняя оценка за две сессии: ', ocenka)
+
+Средняя оценка за две сессии:  4.5
+```