Task 1:Tema 5

TEMA1/Pr0.py

@@ -0,0 +1,6 @@
+#Privet vsem
+#Программа по Теме 1 <Симанков Богдан>
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir ('C:\\Users\\u207-06\\python-labs\\TEMA1\\')

TEMA1/Vse komandi.py

@@ -0,0 +1,16 @@
+# Протокол по Теме 1 <Симанков Богдан>
+
+print('Hello')
+
+h=input('Your name=')
+
+import os
+os.chdir ('C:\\Users\\u207-06\\python-labs\\TEMA1\\')
+
+import Pr0
+Hello
+Your name=Bogdan
+
+import prb1
+Как Вас зовут? bogdan
+Привет, bogdan

TEMA1/report.md

@@ -0,0 +1,165 @@
+# Отчет по теме 1 
+
+Симанков Богдан, А-02-23
+
+## Знакомство с интерпретатором и интерактивной оболочкой IDLE
+
+## Пункт 3
+```py
+>>> print('Hello')
+Hello
+```
+
+## Пункт 4
+```py
+>>> h=input('Your name=')
+Your name=Bogdan
+```
+
+## Пункт 5
+```py
+>>> exit()
+```
+
+## Пункты 6-7
+Запущена IDLE PYTHON, изучено устройство главного командного окна среды
+
+## Пункт 8
+```py
+>>> import os
+>>> os.chdir ('C:\\Users\\u207-06\\python-labs\\TEMA1\\')
+```
+
+
+## Пункт 9
+Изменил параметры текста в редакторе
+
+## Пункт 10
+Создал новый файл
+
+```py
+#Privet vsem
+#Программа по Теме 1 <Симанков Богдан>
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir ('C:\\Users\\u207-06\\python-labs\\TEMA1\\')
+```
+Модуль был запущен
+#Вывод:
+```py
+= RESTART: C:/Users/u207-06/python-labs/TEMA1/Pr0.py = 
+Hello
+Your name=
+```
+
+Файл запускался другим образом:
+```py
+import Pr0
+Hello
+Your name=Bogdan
+```
+
+## Пункт 11
+В консоли вызван prb1.py
+
+```py
+>>> import prb1.py
+
+Как Вас зовут? bogdan
+Привет, bogdan
+```
+
+## Пункт 12
+Файл Pr0.cpython-311 был открыт в приложении "Блокнот".
+Вывод получился таким:
+
+§
+
+    йєhЅ   г                   уZ   —  e d ¦
  «
        
  e
d
¦
  «
        ZddlZ ej        d¦
  «
        
 dS )ЪHelloz
+Your name=й    Nz#C:\Users\u207-06\python-labs\TEMA1\)ЪprintЪinputЪ
hЪosЪchdir© у    ъ)C:\Users\u207-06\python-labs\TEMA1\Pr0.pyъ<module>r   
   sE   р


р 
ЂЂgЃ„ЂШЂ%€СФЂ
Ш 	Ђ	Ђ	Ђ	Ш Ђ„Р
+4С 5Ф 5Р 5Р 5Р 5r
+
+Так получилось, потому что в приложении "Блокнот" не получится считать бинарный код, который выводится из файла.
+
+## Пункт 13
+
+Команды из командного окна сохранены в отдельный файл
+
+## Пункт 14
+
+Python docs - документация по языку
+
+About IDLE - описание среды
+
+>>>help(print)
+
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+>>>help(print), help(input)
+
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+
+F1 -> Указатель -> print() (built-in fuction) выводит справку по функции
+
+## Пункт 15
+
+Открыл файл prb1.py и запустил программу на выполнение:
+
+============== RESTART: C:\Users\u207-06\python-labs\TEMA1\prb1.py =============
+Как Вас зовут? Bogdan
+Привет, Bogdan
+
+>>>import tdemo_chaos
+
+Выбрал предложения «Помощь (Help)» и «Демонстрации (Turtle Demo)», в примерах указал «Часы (Clock)» и которые вывел на экран циферблат часов.
+
+![Часики](Cloak.png)
+
+## Пункт 16
+
+Завершил работу со средой, выбрав File -> Exit.
+
+
+
+
+
+
+ 

TEMA1/test.md

@@ -0,0 +1,11 @@
+# Индивидуальное контрольное задание по теме 1
+
+Симанков Богдан, А-02-23
+
+## Вопрос
+
+Какие способы могут использоваться для получения помощи при работе со средой Python?
+
+## Ответ
+
+Например, благодаря команде help(print), мы можем получить информацию о команде print, будет показана форма вызова, параметры самой команды с объяснением для каждой из них. Также можно с помощью клавиши F1, появится окно справочной подсистемы.

TEMA2/report.md

@@ -0,0 +1,588 @@
+# Отчет по теме 2: Базовые типы объектов
+
+Симанков Богдан, А-02-23
+
+# 1. Запуск оболочки IDLE и установка рабочего каталога
+```py
+>>> import os
+>>> os.chdir ('C:\\Users\\Bogdan\\python-labs\\TEMA2')
+```
+
+# 2. Изучение простых объектов. Операции присваивания значения объектам-переменным
+Операция присваивания
+```py
+>>> f1=16; f2=3
+```
+Значения переменных:
+```py
+>>> f1,f2
+(16,3)
+```
+
+Какие объекты существуют в данный момент в среде:
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+
+__annotations__ — хранит аннотации типов переменных, функций и классов в модуле
+ __builtins__ — список строенных идентификаторов
+ __doc__ — строка документации модуля
+ __loader__ — объект, который загрузил модуль
+ __name__ — имя модуля
+ __package__ — имя пакета, к которому принадлежит модуль
+
+
+Получение списка атрибутов любого объекта, например f1:
+```py
+>>>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']
+```
+
+Определение классовой принадлежности объекта:
+```py
+>>> type (f2)
+<class 'int'>
+```
+
+Удаление объекта из оперативной памяти:
+```py
+>>> del f1,f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+# 3. Правила именования объектов
+Правила именования: 
+ имена должны состоять из латинских букв, цифр и символов подчеркивания;
+ имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
+ имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
+ большие и малые буквы в именах различаются (имена – чувствительные к регистру)!
+```py
+>>> gg1=1.6 #значение в виде вещественного числа
+
+>>> hh1='Строка' #значение в виде символьной строки
+
+>>> 73sr=3 #неправильное имя – начинается с цифры - будет диагностика!
+SyntaxError: invalid decimal literal
+
+>>> and=7 #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+SyntaxError: invalid syntax
+```
+
+# 4. Вывод списка ключевых слов 
+```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']
+
+```py
+>>> s=keyword.kwlist
+>>> s
+['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. Вывод списка встроенных идентификаторов
+```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.1 Изучение назначения функций: abs, len, max, min, pow, round, sorted, sum, zip
+Взятие модуля:
+```py
+>>> abs(-7)
+7
+```
+
+Длина списка:
+```py
+>>> len([1,2,3])
+3
+```
+
+Выбор максимального и минимального значения:
+```py
+>>> max(2,8)
+8
+>>> min(1,16)
+1
+
+Возведение в степень:
+```py
+>>> pow(3,2)
+9
+```
+
+Округление до целого:
+```py
+>>> round(5,6789)
+5
+```
+
+Сортировка по возрастанию:
+```py
+>>> sorted([1,2,3,-7,-9])
+[-9, -7, 1, 2, 3]
+```
+
+Суммирование:
+```py
+>>> sum([5,6,7])
+18
+```
+
+Объединение последовательности объектов в последовательность кортежей:
+```py
+>>> list1=[1,2,3,4]
+>>> list1
+[1, 2, 3, 4]
+>>> list2=[5,6,7,8]
+>>> list2
+[5, 6, 7, 8]
+>>> zip(list1,list2)
+<zip object at 0x00000261BEC1D480>
+```
+
+# 6. Большие и малые буквы в именах объекта
+```py
+>>> Gg1=45
+>>> gg1
+1.6
+>>> Gg1
+45
+```
+Большая и маленькая буква одной и той же буквы в начале имеют различие в имени переменной, так как получилось два разных объекта
+
+# 7. Изучение базовых типов объектов
+
+## 7.1 Логический тип
+```py
+>>> bb1=True; bb2=False
+>>> bb1,bb2
+(True, False)
+>>> type(bb1)
+<class 'bool'>
+```
+
+## 7.2 Другие простые типы
+```py
+>>> ii1=-1234567890
+>>> ii1
+-1234567890
+>>> ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+>>> dv1=0b1101010 #Это – двоичное число.
+>>> type(dv1)
+<class 'int'>
+>>> vsm1=0o52765   #Это – восьмеричное число
+>>> shest1=0x7109af6  #Это – шестнадцатеричное число
+>>> cc1=2-3j
+>>> a=3.67; b=-0.45
+>>> ccs=complex(a,b)  #Создается комплексное число
+>>> ccs
+(3.67-0.45j)
+```
+
+## 7.3 Строка символов
+```py
+>>> ss1='Это - строка символов'
+>>> ss1
+'Это - строка символов'
+```
+
+Внутри строк можно использовать экранированные последовательности, начинающиеся со знака \
+```py
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+
+Создание строки по шаблону:
+```py
+>>>ss1b= 'Меня зовут: \n SimankovBV'
+>>>print(ss1b)
+Меня зовут: 
+SimankovBV
+>>>ss1b
+'Меня зовут: \n SimankovBV'
+```
+
+Многострочные строки можно задавать в виде объекта с использованием тройных кавычек:
+```py
+>>> mnogo="""Нетрудно заметить , что в результате операции
+        над числами разных типов получается число,
+        имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+        над числами разных типов получается число,
+        имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Обращение к частям строки символов с использованием индексов символов по их порядку в строке. Нумерация символов начинается с 0
+```py
+>>> ss1[0]   #Это – символ «Э»
+'Э'
+>>> ss1[8]   #Это – символ «р»
+'р'
+>>> ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+'о'
+>>> ss1[6:9]  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+'стр'
+>>> ss1[13:]  #Это часть строки – с 13-го индекса и до конца
+'символов'
+>>> ss1[:13]  #Это часть строки – с начала и до 12-го индекса включительно
+'Это - строка '
+>>> ss1[5:-8]  #Это часть строки – с 5-го индекса и до 8-го от конца
+' строка '
+>>> ss1[3:17:2]  #Часть строки – с 3-го по 16-й индексы с шагом 2
+'  тоасм'
+```
+
+Указываемая правая граница в срез не включается, при отрицательном значении шага получается следующее:
+```py
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[17:3:-2]
+'омсаот '
+>>> ss1[-4:3:-2]
+'омсаот '
+>>> ss1
+'Это - строка символов'
+```
+
+Строка является неизменяемым объектом
+```py
+>>> ss1[4]='='  # Будет диагностика!
+TypeError: 'str' object does not support item assignment
+```
+
+Однако, можно переопределить строку
+```py
+>>> ss1=ss1[:4]+'='+ss1[5:]
+ss1
+'Это = строка символов'
+```
+
+Создание объекта с разными срезами исходной строки
+```py
+>>> ss1b_1=ss1b[::-1]
+>>> print(ss1b_1)
+VBvoknamiS 
+ :тувоз янеМ
+```
+
+Создание объектов разных типов
+```py
+>>> number1=45
+>>> type(number1)
+<class 'int'>
+>>> number2='Число'
+>>> type(number2)
+<class 'str'>
+```
+
+# 8. Изучение более сложных типов объектов
+## 8.1 Список
+Список – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания
+```py
+>>> spis1=[111,'Spisok',5-9j]
+>>> spis1
+[111, 'Spisok', (5-9j)]
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> spis=[1,2,3,4,
+          5,6,7,
+          8,9,10] #Список можно вводить на нескольких строках
+```
+
+Можно использовать индексы точно также, как и с элементами символьной строки
+```py
+>>> spis1[-1]
+(5-9j)
+>>> stup[-8::2]
+[0, 1, 1, 1]
+>>> spis1[1]='Список'
+>>> spis1
+[111, 'Список', (5-9j)]
+```
+
+Текущее число элементов
+```py
+>>> len(spis1)
+3
+```
+
+С помощью методов объектов-списков можно добавлять и удалять элементы:
+```py
+>>> spis1.append('New item')
+>>> spis1
+[111, 'Список', (5-9j), 'New item']
+```
+
+Добавление в конец списка spis1 строку ss1b:
+```py
+>>> spis1.append(ss1b)
+>>> spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n SimankovBV']
+```
+
+Удаление элемента из списка:
+```py
+>>> spis1.pop(1)
+'Список'
+```
+
+Вставка элемента в определенное место по индексу:
+```py
+>>> spis1.insert(1, "hello")
+>>> spis1
+[111, 'hello', (5-9j), 'New item', 'Меня зовут: \n SimankovBV', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', 'S', 'i', 'm', 'a', 'n', 'k', 'o', 'v', 'B', 'V']
+```
+
+Удаление элемента по значению:
+```py
+>>> spis1.remove(5-9j)
+>>> spis1
+[111, 'hello', 'New item', 'Меня зовут: \n SimankovBV', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', 'S', 'i', 'm', 'a', 'n', 'k', 'o', 'v', 'B', 'V']
+```
+
+Добавление элементов объекта в конец другого объекта:
+```py
+>>> spis2=['hello', 255, 5-10j]
+>>> spis1.extend(spis2)
+>>> spis1
+[111, 'hello', 'New item', 'Меня зовут: \n SimankovBV', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', 'S', 'i', 'm', 'a', 'n', 'k', 'o', 'v', 'B', 'V', 'hello', 255, (5-10j)]
+```
+
+Полное очищение списка:
+```py
+>>> spis1.clear()
+>>> spis1
+[]
+```
+
+Сортировка списка без создания нового объекта:
+```py
+>>> spis3=[4,-3,5,-7,10]
+>>> spis3.sort(key=abs, reverse=False)
+>>> spis3
+[-3, 4, 5, -7, 10]
+>>> spis3.sort(key=abs, reverse=True)
+>>> spis3
+[10, -7, 5, 4, -3]
+```
+
+Создание копии списка:
+```py
+>>> spis4=spis3.copy()
+>>> spis4
+[10, -7, 5, 4, -3]
+```
+
+Подсчет количества элементов по значению:
+```py
+>>> spis4.count(-7)
+1
+```
+
+Поиск индекса по значению:
+```py
+>>> spis4.index(5)
+2
+```
+
+Списки могут быть вложенными:
+```py
+>>> spis1=[10, -7, 5, 4, -3]
+>>> spis2=[spis1,[4,5,6,7]]
+>>> spis2
+[[10, -7, 5, 4, -3], [4, 5, 6, 7]]
+```
+
+Обращение к элементам вложенного списка:
+```py
+>>> spis2[0][1]  #обращение к элементу списка spis1
+-7
+```
+
+Изменение элемента вложенного списка:
+```py
+>>> spis2[0][1]=78
+>>> spis2
+[[10, 78, 5, 4, -3], [4, 5, 6, 7]]
+>>> spis1
+[10, 78, 5, 4, -3]
+```
+Видим, что spis1 тоже изменился. Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]] мы не создаем копию spis1, поэтому его изменения в составе spis2 отображаются на исходном spis1.
+
+
+Создание объекта-списка, элементами которого будут объекты разных типов:
+```py
+>>> spis5 = [100, 'Test', True, spis1]
+>>> spis5
+[100, 'Test', True, [10, 78, 5, 4, -3]]
+```
+
+## 8.2 Кортежи
+Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддерживают включение в них объектов различных типов и операции, типичные для последовательностей.
+
+Создание кортежа:
+```py
+>>> kort1=(222,'Kortezh',77+8j)
+```
+
+Кортеж нельзя изменить, но можно переопределить
+```py
+>>> kort1= kort1+(1,2)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1= kort1+(ss1b,)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n SimankovBV')
+```
+
+Переопределение кортежа с удалением комплексного элемента:
+```py
+>>> kort2=kort1[:2]+kort1[3:]
+>>> kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n SimankovBV')
+```
+
+Определение индекса заданного элемента:
+```py
+>>> kort1.index(2)  # Будет получено значение 4
+4
+```
+
+Подсчёт числа вхождений заданного элемента:
+```py
+>>> kort1.count(222)   #Будет получено значение 1
+1
+```
+
+Операция замены элемента в кортеже:
+```py
+>>> kort1[2]=90   #Будет получена диагностика о невозможности изменения кортежа
+TypeError: 'tuple' object does not support item assignment
+```
+
+Создание объекта-кортежа с элементами разных типов:
+```py
+>>> kort3 = ("h","True", 54)
+>> kort3
+('h', 'True', 54)
+```
+
+ ## 8.3 Словарь
+Объект-словарь похож на ассоциативные массивы в других языках программирования. Его содержанием является совокупность пар: «ключ (key)»:«значение (value)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений.
+
+Создание словаря:
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+```
+
+Обращение к элементам словаря (не по индексам, а по ключам):
+```py
+>>> dic1['Orel']
+56
+```
+
+Пополнение словаря:
+```py
+>>> dic1['Pskov']=78
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+Упорядочение списка по ключам или по значениям:
+```py
+>>> sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>> dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+>>> sorted(dic1.values())
+[45, 56, 78, 145]
+```
+
+Элементы словаря, могут быть любого типа, в том числе и словарями:
+```py
+>>> dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+```
+
+Создание более сложного словаря из списка с элементами-кортежами:
+```py
+>>> 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 SimankovBV'}
+```
+
+Создание словаря из двух списков (одного для ключей, другой для значений):
+```py
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+>>> dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n SimankovBV'}
+```
+
+Создание объекта-кортежа из 7 элементов и объекта-списка с 5 элементами, создание из них словаря:
+```py
+>>> kort6=('f', 'd', 's', 'a', 'l', 'k', 'j')
+>>> spis6=[2,5,6,8,3]
+>>> dic6=dict(zip(spis6,kort6))
+>>> dic6
+{2: 'f', 5: 'd', 6: 's', 8: 'a', 3: 'l'}
+```
+Как мы видим длина словаря составляет 5 объектов. Это связано с функцией zip, которая делает так, что длина итогового объекта будет соответствовать минимальной длине составляющего.
+
+
+## 8.4 Множество
+Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).
+
+Создание множества:
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>> mnoz1
+{'двигатель', 'датчик', 'линия связи', 'микропроцессор'}
+```
+Повторяющееся элементы были удалены
+
+Определение числа элементов:
+```py
+>>> len(mnoz1)
+4
+```
+
+Проверка наличия элемента во множестве:
+```py
+>>> 'датчик' in mnoz1
+True
+```
+
+Добавление элемента:
+```py
+>>> mnoz1.add('реле')
+```
+
+Удаление элемента:
+```py
+>>> mnoz1.remove('линия связи')
+>>> mnoz1
+{'двигатель', 'датчик', 'микропроцессор'}
+```
+
+Создание объекта-множества с элементами разных типов и выполнение различных операций с ним:
+```py
+mnoz2 = {'реле', 20, False}
+mnoz2.add(60)
+mnoz2
+{False, 'реле', 20, 60}
+mnoz2.remove(False)
+mnoz2
+{'реле', 20, 60}
+```
+
+# 9. Завершение работы в среде IDLE
+
+
+

TEMA2/task.md

@@ -0,0 +1,81 @@
+ # Общее контрольное задание по теме 2
+
+Симанков Богдан, А-02-23
+
+ # Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+1. Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+2. Создать переменную со значением, совпадающим с первой буквой из familia.
+
+3. Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+4. Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+5. Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. 
+
+6. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+7. Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+8. Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+9. Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+    
+ # Решение
+1. Создаю переменную familia:
+```py
+>>> familia='Simankov'
+```
+2. Создаю переменную, которая равна первой букве familia:
+```py
+>>> first=familia[0]
+>>> first
+'S'
+```
+
+3. Создаю переменную с именем sp_kw, значение – списк всех ключевых слов Python:
+```py
+>>> 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']
+>>> type(sp_kw)
+<class 'list'>
+```
+
+4. Удаляю из списка sp_kw значение 'nonlocal', затем убедился, что это значение удалено из списка.
+```py
+>>> 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.
+```py
+>>> kort_nam=('Bogdan', 'Semen', 'Vera', 'Dima')
+>>> type(kort_nam)
+<class 'tuple'>
+```
+
+6. Добавляю в kort_nam имена двух студентов.
+```py
+>>> kort_nam=kort_nam+('Dima', 'Liza')
+>>> kort_nam
+('Bogdan', 'Semen', 'Vera', 'Dima', 'Dima', 'Liza')
+```
+
+7. Определяю, сколько раз в кортеже присутствуют студенты с именем «Дима».
+```py
+>>> kort_nam.count('Dima')
+2
+```
+
+8. Создаю словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные перемен-ные, соответствующие этим типам.
+```py
+>>> dict_bas={"строка" : familia, "символ" : first, "список" : sp_kw,  "кортеж" : kort_nam}
+>>> dict_bas
+{'строка': 'Simankov', 'символ': 'S', 'список': ['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'], 'кортеж': ('Bogdan', 'Semen', 'Vera', 'Dima', 'Dima', 'Liza')}
+```

TEMA3/report.md

@@ -0,0 +1,864 @@
+# Отчёт по теме 3: "Операции с объектами"
+Симанков Богдан, А-02-23
+
+# 1. Запуск интерактивной оболочки IDLE
+
+# 2. Преобразование простых базовых типов объектов
+
+## 2.1 Преобразование в логический тип с помощью функции bool(<Объект>)
+
+Выполним следующие инструкции и после каждой из них проверим получившееся значение:
+```py
+>>> logiz1=bool(56)
+>>> logiz1
+True
+>>> type(logiz1)
+<class 'bool'>
+>>> logiz2=bool(0)
+>>> logiz2
+False
+>>> type(logiz2)
+<class 'bool'>
+>>> logiz3=bool("Beta")
+>>> logiz3
+True
+>>> type(logiz3)
+<class 'bool'>
+>>> logiz4=bool("")
+>>> logiz4
+False
+>>> type(logiz4)
+<class 'bool'>
+```
+
+## 2.2 Преобразование в целое десятичное число объекта с заданной системой счисления 
+
+Осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.
+```py
+>>> 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#191>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+При выполнении последней инструкции выдано диагностическое сообщение, это происходит
+потому, что команда int ожидает, что ей сообщат строку (только цифры, может быть знак в начале). Здесь есть точка, поэтому возникает несоответствие ожидаемого формата. Нужно сначала переопределить это число как float, а потом уже применить команду int.
+
+
+Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>)
+```py
+>>> 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 Преобразование десятичных чисел в другие системы счисления
+```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
+```
+
+# 3. Преобразование более сложных базовых объектов
+
+## 3.1 Преобразование в строку символов с помощью функции str(<Объект>)
+```py
+>>> 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(<Объект>)
+```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]
+```
+
+## 3.3 Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>)
+```py
+>>> kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+>>> kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2)   #Преобразование списка в кортеж
+>>> kort8
+(124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9})   # Преобразование ключей словаря в кортеж
+>>> kort9
+('A', 'B', 'C')
+>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values())) # Преобразование значений словаря в кортеж
+>>> kort9
+(1, 2, 9)
+```
+
+## 3.4 Удаление объектов
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del
+```py
+>>> del strk5, kort8
+```
+
+Проверим, остались ли после этой операции объекты в оперативной памяти:
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+Удалённых объектов нет.
+
+
+Создадим строку с моей фамилией и инициалами. Преобразуем её в список, затем список - в кортеж, затем кортеж - в строку.
+```py
+>>> strk1='SimankovBV'
+>>> spis11=list(strk1)
+>>> spis11
+['S', 'i', 'm', 'a', 'n', 'k', 'o', 'v', 'B', 'V']
+>>> kort11=tuple(spis11)
+>>> kort11
+('S', 'i', 'm', 'a', 'n', 'k', 'o', 'v', 'B', 'V')
+>>> strk2=str(kort11)
+>>> strk2
+"('S', 'i', 'm', 'a', 'n', 'k', 'o', 'v', 'B', 'V')"
+```
+
+# 4. Арифметические операции
+
+## 4.1 Сложение и вычитание (+ и -)
+```py
+>>> 12+7+90   # Сложение целых чисел
+109
+>>> 5.689e-1 - 0.456  #Вычитание вещественных чисел
+0.11289999999999994
+>>> 23.6+54   #Сложение вещественного и целого чисел
+77.6
+>>> 14-56.7+89  # Сложение и вычитание целых и вещественных чисел
+46.3
+```
+
+## 4.2 Умножение (*)
+```py
+>>> -6.7*12   #Умножение вещественного числа на целое число
+-80.4
+```
+ 
+## 4.3 Деление (/). 
+```py
+>>> -234.5/6   #Деление вещественного числа на целое
+-39.083333333333336
+>>> a=178/45  #Деление двух целых чисел
+>>> type(a)
+<class 'float'>
+>>> a
+3.9555555555555557
+```
+
+## 4.4 Деление с округлением вниз (//)
+```py
+>>> b=178//45   #Деление двух целых чисел
+>>> type(b)
+<class 'int'>
+>>> b
+3
+>>> c=-24.6//12.1  #Деление двух вещественных чисел
+>>> type(c)
+<class 'float'>
+>>> c
+-3.0
+```
+Здесь результат может быть целым или вещественным.
+Попробуем смешанные комбинации типов чисел:
+
+```py
+>>> d=178//24.6
+>>> type(d)
+<class 'float'>
+>>> d
+7.0
+```
+
+## 4.5 Получение остатка от деления (%)
+```py
+>>> 148%33   #Остаток от деления двух целых чисел
+16
+>>> 12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+>>> 36%2.6
+2.199999999999999
+>>> 52.06%2
+0.060000000000002274
+```
+
+## 4.6 Возведение в степень (**)
+```py
+>>> 14**3  #Целое число возводится в целую степень
+2744
+>>> e=2.7**3.6  #Вещественное число возводится в вещественную степень
+>>> e
+35.719843790663525
+>>> 2.7**3
+19.683000000000003
+>>> 3**5.2
+302.71261832657075
+```
+
+Попробуем операции с участием комплексных чисел:
+```py
+>>> comp1 = (5 + 7j) #Создадим первое комплексное число
+>>> type(comp1)
+<class 'complex'>
+>>> comp2=(6-4j) #Создадим второе комплексное число
+>>> comp1+comp2 #Сумма комплексных чисел
+(11+3j)
+
+>>> comp1-comp2 #Разность комплексных чисел
+(-1+11j)
+
+>>> comp1*comp2 #Произведение комплексных чисел
+(58+22j)
+
+>>> comp1/comp2 #Частное комплексных чисел
+(0.03846153846153853+1.1923076923076923j)
+
+>>> comp1//comp2 #Частное комплексных чисел с округлением вниз
+Traceback (most recent call last):
+  File "<pyshell#108>", line 1, in <module>
+    comp1//comp2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+
+comp1%comp2 #Получение остатка от деления комплексных чисел
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    comp1%comp2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+
+>>> comp1**comp2 #Возведение комплексного числа в комплексную степень
+(-17647296.212723836-4257726.663737518j)
+```
+
+# 5. Операции с двоичными представлениями целых чисел
+
+## 5.1 Двоичная инверсия (~)
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+```py
+>>> dv1=9
+>>> dv2=~dv1
+>>> dv2
+-10
+>>> dv1
+9
+>>> bin(dv1)
+'0b1001'
+>>> bin(dv2)
+'-0b1010'
+```
+
+Результат не совсем совпадает с ожидаемым видом "0110". Это происходит, потому что в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака.
+Было число 9 (1001), меняем все значения на противоположные (0110), затем надо поменять знак (это значит, что надо инвертировать все значения разрядов - будет 1001) и прибавить к полученному числу единицу (которая отвечает за знак), получаем число 1010.
+  
+Двоичная инверсия делает из числа n число -(n+1).
+
+## 5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```py
+>>> 7&9    # 111 и 1001 = 0001
+1
+>>> bin(7&9)
+'0b1'
+7&8    # 111 и 1000 = 0000
+0
+bin(7&8)
+'0b0'
+```
+Первый случай: 7 в двоичной системе счисления - 0111, а 9 в двоичной системе счисления - 1001. Совпадение единиц только в первом разряде, поэтому итог - 0001 или 1.
+
+Второй случай: 8 в двоичной системе счисления - 1000, совпадений единиц нет, итог - 0000 или 0.
+
+
+## 5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
+```py
+>>> 7|9     # 111 или 1001 = 1111
+15
+>>> bin(7|9)
+'0b1111'
+>>> 7|8     # 111 или 1000 = 1111
+15
+>>> bin(7|8)
+'0b1111'
+>>> 14|5   # 1110 или 0101 = 1111
+15
+>>> bin(14|5)
+'0b1111'
+```
+
+Первый случай: 7 в двоичной системе счисления - 0111, 9 в двоичной системе счисления - 1001.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+Второй случай: 8 в двоичной системе счисления - 1000.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+Третий случай: 14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+
+## 5.4 Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+
+```py
+>>> 14^5  # 1110 исключающее или 0101 = 1011
+11
+>>> bin(14^5)
+'0b1011'
+```
+
+Первый случай: 14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101. Возвращается 1, если оба разряда разные, поэтому итог - 1011
+
+
+## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева
+
+```py
+>>> h=14   #Двоичное представление = 1110
+>>> bin(h)
+'0b1110'
+>>> g=h<<2  # Новое двоичное представление = 111000, сдвиг на два разряда влево
+>>> bin(g)
+'0b111000'
+>>> g1=h>>1  # Новое двоичное представление = 0111, сдвиг на один разряд вправо
+>>> bin(g1)
+'0b111'
+>>> g2=h>>2  # Новое двоичное представление = 0011, сдвиг на два разряда вправо
+>>> bin(g2)
+'0b11'
+```
+Слева можно добавить сколько угодно незначащих нулей.
+
+Возьмём два любых числа 52 и 30. Проведём с ними двоичные операции:
+```py
+>>> bin(52)
+'0b110100'
+>>> bin(30)
+'0b11110'
+>>> dv3=~52 # Инверсия числа 52
+>>> bin(dv3)
+'-0b110101'
+>>> bin(52|30) # Двоичное или
+'0b111110'
+>>> bin(52>>2) # сдвиг двоичного представления числа 52 на два разряда вправо
+'0b1101'
+```
+
+ # 6. Операции при работе с последовательностями (строками, списками, кортежами)
+
+## 6.1 Объединение последовательностей (конкатенация)(+)
+```py
+>>> 'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+Конкатенировать словари нельзя. Так как у словарей ключи должны быть
+уникальными.
+```py
+>>> {'one':1 , 'two':2} + {'three':3}
+Traceback (most recent call last):
+  File "<pyshell#90>", line 1, in <module>
+    {'one':1 , 'two':2} + {'three':3}
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+```
+
+## 6.2 Повторение (*)
+```py
+>>> 'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99 # Создание списка со 100 отсчётами сигнала-ступеньки
+>>> 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)
+```py
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka  #Наличие подстроки в строке
+True
+>>> 'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+## 6.4 Подстановка значений в строку с помощью оператора «%»
+Пример 1:
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> stroka
+'Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+Пример 2:
+```py
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+Подстановка возвращает новую строку, но не перезаписывает исходную.
+Типы вставок для оператора %:
+    %s - строка
+    %d и %i - целое число (d - всегда десятичное, а i - десятичное или переведенное
+         в десятичное из другой системы счисления)
+    %f - число с плавающей точкой
+    %e - экспоненциальная форма записи числа
+    %g - автовыбор между e и f  
+    %.nf - число с плавающей точкой, но конкретным количеством знаков после запятой
+
+ # 7. Оператор присваивания
+
+## 7.1 Обычное присваивание значения переменной (=)
+```py
+>>> zz=-12
+>>> zz
+-12
+```
+
+## 7.2 Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```py
+>>> zz+=5   # Значение zz увеличивается на 5
+>>> zz
+-7
+>>> zz-=3  # Значение уменьшается на 3
+>>> zz
+-10
+```
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+```py
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+```
+
+## 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+>>> zz/=2
+>>> zz
+-5.0
+>>> zz*=5
+>>> zz
+-25.0
+```
+Для строк операция (*=) означает повторение текущего значения объекта заданное число раз.
+```py
+>>> stroka = 'Система'
+>>> stroka *= 3
+>>> stroka
+'СистемаСистемаСистема'
+```
+
+ ## 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+```py
+>>> zz
+-0.5
+>>> zz//=4
+>>> zz
+-1.0
+>>> zz%=-0.2
+>>> zz
+-0.19999999999999996
+>>> zz**=5
+>>> zz
+-0.00031999999999999965
+```
+
+## 7.5 Множественное присваивание
+```py
+>>> w=v=10  # Переменным присваивается одно и то же значение
+>>> w
+10
+>>> v
+10
+>>> n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+>>> n1,n2,n3
+(11, -3, 'all')
+>>> n1
+11
+```
+Проверим, можно ли использовать так строку, список, словарь, множество:
+```py
+>>> a1, a2, a3 = "a", "b", "c" # Строка
+>>> a1, a2, a3
+('a', 'b', 'c')
+>>> b1, b2, b3 = ["a", 1, None] # Список
+>>> b1
+'a'
+>>> b3
+>>> c1, c2, c3 = {"one": 1, "two": 2, "three": 3} # Словарь
+>>> c1, c2, c3
+('one', 'two', 'three')
+>>> m1, m2, m3 = {52, 0, 3} # Множество
+>>> m1, m2, m3
+(0,3,52)
+```
+
+# 8. Логические операции – при создании логических выражений, дающих в результате вычисления значения True или False.
+
+## 8.1 Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=)
+```py
+>>> w
+10
+>>> v
+10
+>>> w==v # Равенство
+True
+>>> w!=v # Не равно
+False
+>>> w<v # Меньше
+False
+>>> w<=v # Меньше или равно
+True
+```
+
+## 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in)
+Операции с множеством 
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+```
+
+Операции со словарем:
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> 'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> 56 in dic1.values()
+True
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+```
+
+## 8.3 Cоздание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Пример сложного логического выражения:
+```py
+>>> (len(dic1) == 3) or (sum(dic1.values()) > 300) or ('IVTI' in dct1['Depart'])
+True
+
+
+## 8.3 Cоздание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Пример сложного логического выражения:
+```py
+>>> (len(dic1) == 3) or (sum(dic1.values()) > 300) or ('IVTI' in dct1['Depart'])
+True
+```
+
+## 8.4 Проверка ссылок переменных на один и тот же объект (is)
+```py
+>>> w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+>>> w is v
+True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> w1 is v1
+False
+>>> w1 == v1
+True
+```
+Оператор is проверяет, ссылаются ли объекты на один и тот же адрес в памяти. Переменные
+целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти.
+Списки были созданы в разных строках, и адреса у них разные, т.е. они ссылаются на разные
+участки в памяти, поэтому is возвращает False. 
+```py
+>>> w2=20
+>>> v2=20
+>>> w2 is v2
+True
+
+>>> a=10002
+>>> b=10002
+>>> a is b
+False
+
+>>> a=b=10002
+>>> a is b
+True
+```
+Иногда использование памяти в Python оптимизировано. Например, числа от -5 до 256: Python делает так, чтобы они ссылались на один участок памяти. Но с числами, не попадающими в этот диапазон, это не работает.
+В данном случае эти переменные не записаны в один адрес памяти, питон создает для списков два разных обьекта, так как список это изменяемый тип и так как значение для переменных присваивалось по-отдельности.
+
+
+# 9. Операции с объектами, выполняемые с помощью методов
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir
+```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']
+```
+
+## 9.1 Методы для работы со строками
+```py
+>>> stroka.find('пр')  #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+
+>>> stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+
+>>> stroka.replace(' у',' автоматического у') #Замена подстроки, не перезаписывает исходную строку
+'Микропроцессорная система автоматического управления'
+
+>>> spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+
+>>> stroka.upper()   #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+
+>>> stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+>>> stroka3
+'Микропроцессорная система управления'
+
+>>> stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+
+>>> stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола.
+```py
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1
+'Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+```
+
+Можно указать порядок. Здесь цифры в фигурных скобках – это индексы, определяющие порядок использования аргументов формата. Поэтому такой способ называют основанным на позиционных аргументах.
+```py
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+```
+
+Можно подставить имена аргументов-вставок, и тогда порядок подстановки может быть
+произвольным:
+```py
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3
+'Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+
+## 9.2 Методы для работы со списками
+```py
+>>> spsk = [10, 'd', (1, 2), 'a', 3] # Создание списка
+>>> spsk
+[10, 'd', (1, 2), 'a', 3]
+
+>>> spsk.pop(2) # Удаление элемента по индексу
+(1, 2)
+>>> spsk
+[10, 'd', 'a', 3]
+
+>>> spsk.append('c') # Вставка элемента в конец
+>>> spsk
+[10, 'd', 'a', 3, 'c']
+
+>>> spsk.insert(2,'a') # Вставка элемента в конкретное место по индексу
+>>> spsk
+[10, 'd', 'a', 'a', 3, 'c']
+
+>>> spsk.count('a') # Подсчет количества элементов по значению
+2
+>>> spsk
+[10, 'd', 'a', 'a', 3, 'c']
+```
+
+## 9.3 Методы для работы с кортежами
+Кортежи неизменяемы, поэтому методов, связанных с удалением или добавлением элементов, нет.
+```py
+>>> cor = (1, 'a', 'b', 0.05, 10+3j) # Создание кортежа
+
+>>> cor.count(1) # Подсчет количества элементов по значению
+1
+
+>>> cor.index(0.05) # Поиск индекса первого вхождения
+3
+>>> cor.index('d') 
+Traceback (most recent call last):
+  File "<pyshell#172>", line 1, in <module>
+    cor.index('d')
+ValueError: tuple.index(x): x not in tuple
+```
+
+## 9.4 Методы для работы со словарями и множествами
+Методы словарей:
+```py
+>>> dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+
+>>> new_dct1=dct1.copy() # Создается копия, но новые значения ссылаются на предыдущие
+>>> new_dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+
+>>> dct1.get('Depart') # Возвращение значения по ключу
+['UII', 'PM', 'VMSS', 'MM']
+
+>>> dct1.keys() # Возвращение объекта только из ключей
+dict_keys(['Institut', 'Depart', 'gruppa'])
+
+>>> dct1.values() # Возвращение объекта только из значений
+dict_values([['AVTI', 'IEE', 'IBB'], ['UII', 'PM', 'VMSS', 'MM'], ['A-01-15', 'A-02-15']])
+```
+Возвращаемые объекты dict_keys, dict_values, dict_items - объекты-итераторы. Они ссылаются на адреса ключей или значений в памяти, но не хранят значения. Также эти объекты автоматически обновляются при обновлении словаря.
+```py
+>>> new_dct1.clear() # Полное очищение списка
+>>> new_dct1
+{}
+
+>>> dct1.pop('Depart') # Удаление ключа и возвращение значения
+['UII', 'PM', 'VMSS', 'MM']
+>>> dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'gruppa': ['A-01-15', 'A-02-15']}
+```
+Методы множеств:
+```py
+>>> mnoz1={1, 'датчик', False, 256, 'двигатель'}
+>>> mnoz1
+{False, 256, 1, 'двигатель', 'датчик'}
+
+>>> mnoz1.add(10+7j) # Добавление элемента
+>>> mnoz1
+{False, 256, 1, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz2=mnoz1.copy() # Создание копии
+>>> mnoz2
+{False, 256, 1, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz1.remove(1) # Удаление элемента по значению
+>>> mnoz1
+{False, 256, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz2.clear() # Очищение множества
+>>> mnoz2
+set()
+
+>>> mnoz1.pop() # Удаление случайного элемента из множества
+False
+>>> mnoz1
+{256, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz1.update({True, 'b'}) # Добавление элементов
+>>> mnoz1
+{256, True, 'b', 'двигатель', 'датчик', (10+7j)}
+```
+
+
+# 10. Завершение сеанса работы со средой
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA3/task.md

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

TEMA3/test.md

@@ -0,0 +1,112 @@
+# Выполнение модульного задания
+Симанков Богдан, А-02-23
+
+# Задание
+M1_17
+1)	Можно ли работать со средой без использования интерактивной оболочки IDLE?
+
+2)	Создайте объект-словарь с 7 элементами: ключи - названия (аббревиатура) вузов, значения - число студентов (задать произвольно). Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию, позволяющую вычислить общее число студентов в двух указываемых вузах из словаря. 
+
+4)	Преобразуйте значения из словаря в список и, затем, список - в строку. Отобразите полученные объекты. Получите новый список, разделением строки на части по разделителю: ",".
+
+5)	Используя операцию подстановки, отобразить рассчитанное число студентов в 2-х вузах по шаблону: "Число студентов в <название вуза 1> и <название вуза 2> =:". 
+
+
+# Выполнение
+
+## 1. Можно ли работать со средой без использования интерактивной оболочки IDLE?
+
+Да, можно работать с Python без использования интерактивной оболочки IDLE.
+
+- Запуск из командной строки
+
+Пишете программу в обычном текстовом редакторе (например, VS Code, Notepad++) и сохраняете с расширением .py.
+Затем запускаете её в терминале/консоли командой:
+
+python имя_файла.py
+
+
+- Использование других редакторов
+
+Есть много альтернатив: PyCharm, VS Code, Jupyter Notebook, и др.
+
+- Среды внутри браузера
+
+Можно использовать онлайн-платформы (Google Colab и др.), которые позволяют писать и запускать Python-код без установки.
+
+
+## 2. Создайте объект-словарь с 7 элементами: ключи - названия (аббревиатура) вузов, значения - число студентов (задать произвольно). Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+```py
+>>> dct1={'MEI':500,  'Baumanka':400, 'VSHE':700, 'MFTI':640, 'MIIT':550, 'MGU':250, 'OXFORD':150}
+
+>>> type(dct1)
+<class 'dict'>
+
+>>> dir(dct1)
+['__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']
+```
+
+## 3. Напишите инструкцию, позволяющую вычислить общее число студентов в двух указываемых вузах из словаря.
+```py
+>>> uni1='MGU'
+>>> uni2='MEI'
+>>> total_stud=dct1[uni1]+dct1[uni2]
+>>> total_stud
+750
+```
+
+## 4. Преобразуйте значения из словаря в список и, затем, список - в строку. Отобразите полученные объекты. Получите новый список, разделением строки на части по разделителю: ",".
+```py
+>>> val_list=list(dct1.values())
+>>> val_list
+[500, 400, 700, 640, 550, 250, 150]
+
+>>> stroka=",".join(str(num) for num in val_list)
+>>> stroka
+'500,400,700,640,550,250,150'
+
+>>> spisok=stroka.split(",")
+>>> spisok
+['500', '400', '700', '640', '550', '250', '150']
+```
+
+## 5. Используя операцию подстановки, отобразить рассчитанное число студентов в 2-х вузах по шаблону: "Число студентов в <название вуза 1> и <название вуза 2> =:".
+```py
+>>> "Число студентов в MEI и MGU = " + str(total_stud)
+'Число студентов в MEI и MGU = 750'
+
+Или
+>>> val1_list=list(dct1.values())+list(dct1.keys())
+>>> val1_list
+[500, 400, 700, 640, 550, 250, 150, 'MEI', 'Baumanka', 'VSHE', 'MFTI', 'MIIT', 'MGU', 'OXFORD']
+>>> print(f"Число студентов в {val1_list[7]} и {val1_list[8]} = {val1_list[0] + val1_list[1]}")
+Число студентов в MEI и Baumanka = 900
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA4/report.md

@@ -0,0 +1,462 @@
+# Отчёт по теме 4: "Встроенные функции"
+Симанков Богдан, А-02-23
+
+ # 1. Запуск интерактивной оболочки.
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\Bogdan\\python-labs\\TEMA4')
+```
+
+Встроенные функции – это готовые к использованию функции, реализующие различные полезные операции, необходимость в которых часто возникает при решении прикладных задач. Часть из них имеется в виде стандартных функций – то есть они не требуют дополнительных усилий, готовы к употреблению сразу после запуска среды Python и относятся к классу 'builtin_function_or_method'. Другие собраны в совокупности, называемые модулями, и требуют выполнения операции импорта соответствующего модуля, прежде чем воспользоваться входящими в него функциями. Они являются объектами класса 'function'. Модули также являются объектами класса 'module' и тогда входящие в них функции представляют собой методы этих объектов. Фактически, модули представляют собой библиотеки включенных в них функций.
+
+ # 2. Стандартные функции
+Находятся в модуле builtins, который становится доступным без импорта при запуске среды IDLE.
+
+ ## 2.1 Функция round - округление числа с заданной точностью.
+```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)
+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'>
+```
+Если не указана точность, функция возвращает округленное целое число.
+Если указана, даже ноль, - то число с плавающей точкой.
+
+## 2.2 Функция range – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```py
+>>> gg=range(76,123,9)
+>>> gg
+range(76, 123, 9)
+>>> type(gg)
+<class 'range'>
+```
+Аргументами функции являются границы диапазона значений и шаг. При этом правая граница в создаваемую последовательность включена не будет. 
+Инструкция создает «итерируемый объект» класса range. Чтобы увидеть получившуюся последовательность чисел, его надо преобразовать, например, в список.
+```py
+>>> 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]
+```
+
+ ## 2.3 Функция zip – создание общего объекта, элементами которого являются кортежи, составленные из элементов двух или более объектов-последовательностей (zip – застежка-«молния»).
+Длина результирующего объекта равна длине самого короткого объекта из двух аргументов функции.
+Создадим объект-список с именем qq, содержащий строку с моей фамилией и строки-фамилии еще 3-х студентов. После этого применим функцию zip:
+
+```py
+>>> qq=['Simankov','Savin','Volodin','Efremov']
+>>> qq
+['Simankov','Savin','Volodin','Efremov']
+>>> ff=zip(gg,qq)
+```
+Чтобы увидеть результат вычисления функции, превратим его, например, в кортеж:
+```py
+>>> tuple(ff)
+((76, 'Simankov'), (85, 'Savin'), (94, 'Volodin'), (103, 'Efremov'))
+>>> ff[0]
+Traceback (most recent call last):
+  File "<pyshell#25>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+```
+Объект класса zip не итерируемый, имеет длину меньшую из длин объектов-параметров, не изменяем.
+
+ ## 2.4 Функция eval – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=100
+>>> dan
+344.0
+```
+
+ ## 2.5 Функция exec – чтение и выполнение объекта-аргумента функции. Этот объект должен представлять собой строку символов с совокупностью инструкций на языке Python.
+```py
+>>> exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+221.456
+```
+
+ ## 2.6 Изучение других функций модуля builtins
+```py
+>>> abs(-658) #Взятие модуля
+658
+>>> pow(5,2) #Возведение в степень
+25
+>>> pow(5,4,10) #Возведение 5 в степень 4 и взятие остатка от деления на модуль = 10
+5
+```
+
+Максимальное из значений
+```py
+>>> max(30,1,625)
+625
+>>> max([10,0,-5])
+10
+>>> max({'a': 1, 'b': 2, 'c': 3})
+'c'
+>>> max(["aaa", "aaaa", "a"], key = len)
+'aaaa'
+```
+Выбор большего в словаре происходит из ключей. Среди буквенных символов больше то, которое ближе к концу алфавита. С разными типами функция не работает. Также в данной функции можно указать по какому критерию выбирать максимальное значение.
+
+Функция минимального из значений работает аналогично и для неё справедливы все нюансы, аналогично максимуму
+```py
+>>> min(10,-1,625)
+-1
+```
+
+Функция сумма элементов:
+```py
+>>> help(sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+>>> sum([1,2,3,4])
+10
+>>> sum([1,2,3,4], -10) #Суммирование и затем вычитание значения из суммы
+0
+```
+
+Функция возвращения кортежа из целой части и остатка от деления (divmod):
+```py
+>>> help(divmod)
+Help on built-in function divmod in module builtins:
+divmod(x, y, /)
+    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
+>>> divmod(15,3)
+(5, 0)
+>>> divmod(3,2)
+(1, 1)
+```
+
+Длина объекта:
+```py
+>>> len((1,2,3))
+3
+>>> len("aaaaaaaaaa")
+10
+```
+
+Применение функции к каждому элементу коллекции
+```py
+>>> help(map)
+Help on class map in module builtins:
+class map(object)
+ |  map(func, *iterables) --> map object
+ |  
+ |  Make an iterator that computes the function using arguments from
+ |  each of the iterables.  Stops when the shortest iterable is exhausted.
+>>> numbers = [1, 2, 3, 4]
+>>> str1 = list(map(str, numbers))
+>>> str1
+['1', '2', '3', '4']
+```
+
+ # 3. Функции из стандартного модуля 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!.
+>>> math.factorial(5) # Взятие факториала
+120
+```
+
+Попробуем другие функции
+```py
+>>> math.sin(2.152) # Взятие синуса
+0.8358024024003236
+
+>>> math.acos(1) # Взятие арккосинуса
+0.0
+
+>>> math.degrees(5.256) # Перевод из радиан в градусы
+301.1466171207607
+
+>>> math.radians (360) # Перевод из градусов в радианы
+6.283185307179586
+
+>>> math.exp(1) # Число е в степени
+2.718281828459045
+
+>>> math.log(25,5) # Нахождение логарифма
+2.0
+
+>>> math.log(25) # Если не задано основание логарифма, то он натуральный
+3.2188758248682006
+
+>>> math.log10(10000) # Десятичный логарифм
+4.0
+
+>>> math.sqrt(49) # Извлечение квадратного корня
+7.0
+
+>>> math.ceil(5.542) # Округление числа до ближайшего целого вверх
+6
+>>> math.ceil(2.111)
+3
+
+>>> math.floor(5.252) # Округление вниз
+5
+>>> math.floor(9.999)
+9
+
+>>> math.pi # Число пи
+3.141592653589793
+
+>>> math.sin(2 * math.pi / 7 + math.exp(0.23)) # Вычислите значение функции sin(2π/7+e0.23 )
+0.8334902641414562
+```
+
+ # 4. Функции из модуля 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
+```
+
+ # 5. Стандартный модуль 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()
+```
+Данная функция задаёт случайное начальное состояние для псевдослучайных чисел, не имеет возвращаемых значений.  При одинаковом seed последовательность "случайных" чисел будет одинаковой при каждом запуске программы. Если не использовать seed(), Python автоматически использует текущее время системы как seed, что даcт случайные результаты между запусками.
+
+```py
+>>> random.random() # Случайное число от 0 до 1
+0.6896328742186021
+>>> random.random()
+0.1726529816841289
+
+>>> random.uniform(2,4) # Равномерно распределенное случайное число
+2.735006538726008
+
+>>> random.randint(1,5) # Равномерное случайное целое
+1
+
+>>> random.choice([True, "a", 1, 5.25, 1+7j]) # Случайный выбор из совокупности
+True
+
+>>> lis1=[True, "a", 1, 5.25, 1+7j]
+>>> random.shuffle(lis1) # Случайное перемешивание элементов коллекции (изменяет исходный объект)
+>>> lis1
+[True, 'a', 1, (1+7j), 5.25]
+
+>>> random.gauss(0,1) # Нормально распределенное случайное число, без заданных матожидания и дисперсии выдаст ошибку
+0.24764673316146607
+
+>>> random.sample(lis1, 5) # Случайное подмножество заданного множества
+[(1+7j), True, 1, 5.25, 'a']
+>>> random.sample(lis1, 2)
+['a', (1+7j)]
+
+>>> random.betavariate(1,2) # Случайное число, подчиняющееся бета-распределению
+0.7155538539701354
+
+>>> random.gammavariate(1,2) # Случайное число, подчиняющееся гамма-распределению
+0.9953376942065243
+```
+
+Создадим список с 4 случайными элементами, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма – распределениям
+```py
+>>> spis1 = [0] * 4
+>>> spis1[0] = random.uniform(1,2)
+>>> spis1[1] = random.gauss(2, 0.5)
+>>> spis1[2] = random.betavariate(2,1)
+>>> spis1[3] = random.gammavariate(1,0.5)
+>>> spis1
+[1.577778913715452, 2.3612752923145632, 0.4957050262397597, 1.0422258764453651]
+```
+
+ # 6. Функции из модуля 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']
+```
+
+Функция time, возвращающая время в секундах, прошедшее с начала эпохи, за которое принимается 1.01.1970г.
+```py
+>>> c1=time.time() 
+>>> c1
+1759092688.1569457
+>>> c2=time.time()-c1 # Временной интервал в секундах, со времени ввода предыдущей инструкции
+>>> c2
+18.95661425590515
+```
+
+Функция gmtime, возвращающая объект класса struct_time, содержащий полную информацию о текущем времени: год (tm_year), месяц (tm_mon), день tm_mday). Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC). Московское время MSK опережает UTC на 3 часа.
+```py
+>>> dat=time.gmtime()
+>>> dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=28, tm_hour=20, tm_min=52, tm_sec=8, tm_wday=6, tm_yday=271, tm_isdst=0)
+>>> dat.tm_mon # Обращение к компонентам получившегося объекта
+9
+>>> dat.tm_year
+2025
+>>> dat.tm_yday
+271
+```
+
+Для получения местного времени используется функция localtime:
+```py
+>>> now=time.localtime()
+>>> now
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=28, tm_hour=23, tm_min=57, tm_sec=45, tm_wday=6, tm_yday=271, tm_isdst=0)
+
+>>> time.asctime(now) # Преобразование представления времени из кортежа в строку
+'Sun Sep 28 23:57:45 2025'
+
+>>> time.ctime() # Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+'Sun Sep 28 23:59:29 2025'
+
+>>> time.sleep(5) # Прерывание работы программы на заданное время
+
+>>> time.mktime(now) # Преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи
+1759093065.0
+
+>>> time.localtime(c1) # Обратное преобразование из секунд в местное время
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=28, tm_hour=23, tm_min=51, tm_sec=28, tm_wday=6, tm_yday=271, tm_isdst=0)
+```
+
+ # 7. Графические функции
+В развернутой версии Python должны быть установлены модули пакета matplotlib, в состав которого входит модуль pylab, содержащий ряд полезных вычислительных функций и графических возможностей.
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4)) # Создание списка, который хранит значение сигнала x
+>>> t=list(range(15)) # Создание списка, который хранит моменты времени измерения значений сигнала t
+
+>>> pylab.plot(t,x)  #Создание графика в оперативной памяти
+[<matplotlib.lines.Line2D object at 0x0000026ABB0B0E10>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show() #Отображение графика на экране
+```
+![График](Ris1.png)
+
+Открылось внешнее окно с графиком. График сохранен в файле с именем Ris1.png
+
+Рассмотри способ построения нескольких графиков на одном рисунке.
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000026ABB1756D0>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x0000026ABB175810>]
+>>> pylab.show()
+```
+![График](Ris1.1.png)
+
+Появились две ломаные линии синего и оранжевого цвета. График сохранен в файле с именем Ris1.1.png
+
+Изучение возможности построения круговой диаграммы
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+([<matplotlib.patches.Wedge object at 0x0000026ABA668050>, <matplotlib.patches.Wedge object at 0x0000026ABD80B110>, <matplotlib.patches.Wedge object at 0x0000026ABD80B4D0>, <matplotlib.patches.Wedge object at 0x0000026ABD80B750>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+![График](Ris2.png)
+
+График сохранён в файле Ris2.png
+
+Изучение применения функций hist и bar:
+```py
+>>> pylab.bar(region, naselen) # Создание столбиковой диаграммы
+<BarContainer object of 4 artists>
+>>> pylab.show()
+```
+![График](Ris3.png)
+
+Столбиковая диаграмма сохранена в файле Ris3.png
+
+```py
+>>> data = [1, 2, 3, 3, 2, 3, 3, 3, 2]
+>>> pylab.hist(data, bins=3)
+...   
+(array([1., 3., 5.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>> pylab.show()
+```
+![График](Ris5.png)
+
+Гистограмма сохранена в файле Ris5.png
+
+
+ # 8. Изучение статистического модуля statistics
+```py
+>>> data = [1, 2, 3, 4, 5]
+>>> statistics.mean(data) # Математическое ожидание
+3
+>>> statistics.median(data) # Медиана
+3
+>>> statistics.stdev(data) # Среднеквадратическое отклонение
+1.5811388300841898
+>>> statistics.variance(data) # Дисперсия
+2.5
+```
+
+ # 9. Завершение сеанса работы с IDLE

TEMA4/task.md

@@ -0,0 +1,68 @@
+# Общее контрольное задание по теме 4
+Симанков Богдан, А-02-23
+
+ # Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+
+2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+
+ # Решение
+1. 
+```py
+>>> import cmath
+>>> divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+(8.0, 2.6000000000000014)
+```
+
+2. 
+```py
+>>> import time
+>>> dat=time.localtime() # Временные параметры для текущего московского времени
+>>> dat
+time.struct_time(tm_year=2025, tm_mon=9, tm_mday=29, tm_hour=9, tm_min=42, tm_sec=16, tm_wday=0, tm_yday=272, tm_isdst=0)
+>>> stroka=str(dat.tm_hour)+ ' ' + str(dat.tm_min) # Создание строки с текущим часом и минутами
+>>> stroka
+'9 42'
+```
+
+3. 
+```py
+>>> spis=['Sunday', 'Monday', 'Thusday', 'Wendsday', 'Thuesday', 'Friday', 'Saturday']
+>>> import random
+>>> random.sample(spis,3) # Случайная выборка из списка с тремя элементами
+['Thusday', 'Sunday', 'Wendsday']
+```
+
+4. 
+```py
+>>> random.choice(range(14,32,3)) # Случайный выбор числа из последовательности целых чисел
+26
+>>> random.choice(range(14,32,3))
+23
+```
+
+5. 
+```py
+>>> N=round(random.gauss(15,4)) # Нормально распределённое число с мат ожиданием 15 и стндартным отклонением 4, округлённое до целого
+>>> N
+13
+>>> list1=list('abcdefghijklmnopqrstuvwxyz') # Создание списка
+>>> random.sample(list1,N)  # Случайно выбранные буквы
+['i', 'n', 'q', 'e', 'k', 'b', 'h', 'z', 't', 'u', 'd', 'l', 'f']
+```
+
+6. 
+```py
+>>> (time.mktime(dat)-time.mktime(time.localtime()))/60 # Определение интервала в минутах с момента времени из пункта 2 
+-20.75
+```

TEMA4/test.md

@@ -0,0 +1,20 @@
+ # Контрольное задание по теме 4
+Симанков Богдан, А-02-23
+
+ # Задание
+Создайте кортеж с целочисленными значениями, равномерно размещенными на интервале от 121 до 163 с шагом 7. Создайте список с 4 элементами – случайными, нормально распределенными числами с математическим ожиданием 23 и стандартным отклонением 7. Создайте общий список с элементами – кортежами, объединяющими пары соответствующих элементов из ранее созданных списка и кортежа. Отобразите на экране с округлением до одного знака после точки второе число из кортежа – третьего элемента созданного списка.
+
+ # Решение
+```py
+>>> import random
+
+>>> tuple_znach = tuple(range(121, 164, 7))
+
+>>> random_znach = [random.gauss(23, 7) for _ in range(4)]
+
+>>> combined_list = list(zip(tuple_znach, random_znach))
+
+>>> print(round(combined_list[2][1], 1))
+
+25.7
+```

TEMA5/report.md

@@ -0,0 +1,423 @@
+# Отчёт по теме 5: "Блоки инструкций, управляющие инструкции"
+Симанков Богдан, А-02-23
+
+ # 1. Запуск интерактивной оболочки IDLE
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\Bogdan\\python-labs\\TEMA5')
+```
+
+Управляющие инструкции, как и в других языках программирования, используются в Python для разветвления линий потока. Их применение имеет как сходство, так и заметные отличия по сравнению с другими языками программирования. В программах на Python они применяются по следующей общей схеме:
+<Управляющая инструкция>:
+<отступы><Блок инструкций>
+
+Здесь управляющая инструкция начинается зарезервированными словами, такими как if, while, for… и дополняется логическим выражением, со значением True или False.
+Блок инструкций – это совокупность инструкций на языке Python, возможно, включающая вложенные управляющие инструкции. Относительно управляющей инструкции блок инструкций сдвигается влево с использованием одинаковых отступов, задаваемых либо некоторым числом пробелов, либо одной или несколькими табуляциями. Величина отступа задаётся в настройках среды (Indentation Width). По умолчанию – это 4 пробела или 1 табуляция.
+
+
+ # 2. Ветвление по условию – управляющая инструкция if.
+Общее правило написания:
+if <условие>:
+<отступы><Блок инструкций, выполняемый, если условие истинно>
+      [elif <условие2>:
+<отступы><Блок инструкций2, выполняемый, если условие2 истинно>
+]
+[else:
+< отступы><Блок инструкций3, выполняемый, если условие ложно>
+]
+
+Условие задается в виде логического выражения, которое может принимать значение True или False. Блок инструкций может располагаться на нескольких строках. Отступы во всех строках блока должны быть одинаковыми по отношению к первому символу управляющей инструкции. Если имеется вложенная управляющая инструкция, то она вводится с таким же отступом, а все строки ее блоков – отступают по отношению к ее первому символу. Признак конца блока – отсутствие отступов в очередной строке или ввод пустой строки.
+Если в Блоке инструкций только одна инструкция, её можно записывать без отступов сразу за знаком «:».
+
+```py
+>>> porog=50
+>>> rashod1=200
+>>> rashod2=30
+>>> if rashod1>=porog:
+... 		dohod=12
+... elif rashod2==porog:
+... 		dohod=0
+... else:
+... 		dohod=-8 # Это выполняется, если ни первое, ни второе условия не были истинными
+... 
+... 		
+>>> dohod
+12
+```
+
+В конструкции if-elif-else всегда выполняется только одна ветвь. Даже если условие
+в elif также истинно, оно не будет проверено и, соответственно, не выполнится, если до
+этого уже выполнился блок if. Это связано с тем, что после выполнения любого блока
+инструкции (будь то if, elif или else) остальные части конструкции игнорируются.
+
+```py
+>>> rashod2=4
+>>> porog=4
+>>> rashod1=8
+>>> if porog==3:
+... 		dohod=1
+... elif porog==4:
+... 		dohod=2 # Верно
+... elif porog==5:
+... 		dohod=3 # Игнорируется
+... else:
+... 		dohod=0 # Игнорируется
+... 
+... 		
+>>> dohod
+2
+```
+
+Условные инструкции могут записываться также в одну строку в операторе присваивания по следующей схеме:
+<Объект>=<значение 1> if <условие>  else <значение 2>
+или ещё:
+if <условие>: <инструкция1>[;<инструкция2>….]
+
+```py
+>>> dohod=2 if porog>=4 else 0
+>>> dohod
+2
+>>> if porog>=5 : rashod1=6; rashod2=0 # 
+... 
+>>> rashod1 # Условие не выполнено, значения прежние
+8
+>>> rashod2
+4
+```
+
+
+ # 3. Цикл по перечислению – управляющая инструкция for.
+Общее правило написания:
+for <Объект-переменная цикла> in <объект>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else: 
+< отступы ><Блок инструкций 2 – если  в цикле не сработал break>]
+
+Здесь <объект> - любой определенный до начала цикла объект из классов строка, список, кортеж, множество, словарь. 
+<Объект-переменная цикла> - объект, в качестве значений которого поочередно будут задаваться элементы объекта, которые могут быть объектами любого типа. 
+<Блок инструкций 1 – тело цикла> - совокупность инструкций, которая может содержать или не содержать инструкцию break, вызывающую досрочное завершение цикла при некоторых условиях.  Блок инструкций 1 обычно выполняется многократно по мере того, как объект-переменная цикла принимает значения из сложного объекта. Если в цикле имеется необязательная часть: else и Блок инструкций 2, то он будет выполняться перед завершением цикла только в том случае, если при выполнении цикла не было его прерывания по инструкции break.
+Если в Блоке инструкций 1 или в Блоке инструкций 2 только одна инструкция, то её можно записывать без отступов сразу за двоеточием.
+
+ ## 3.1 Простой цикл
+```py
+>>> temperatura=5
+>>> for i in range(3,18,3):
+... 	temperatura+=i
+... 
+... 	
+>>> temperatura
+50
+```
+
+Также можно увидеть, какое значение имеет переменная i на каждой итерации:
+```py
+>>> for i in range(3,18,3):
+...     i
+...     temperatura+=i
+... 
+...     
+3
+6
+9
+12
+15
+```
+
+ ## 3.2 Более сложный цикл
+```py
+>>> 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]
+```
+Как видно, в конец цикла добавляется двойка до тех пор, пока длина не превысит 10. sps - это объект, по которому проходит k, и объект, изменяющийся внутри цикла. Если список изменяется во время цикла, это влияет на последующие итерации.
+(При этом else в данном случае относится к if, а не к for.
+
+Теперь выполним чуть-чуть отличающуюся совокупность операций:
+```py
+>>> 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[:] создает полную копию исходного списка (срез от начала до конца включительно).
+Теперь список, по которому пробегается k, и список, изменяющийся внутри цикла - это объекты, имеющие разные адреса. Цикл итерируется по копии, но изменяет оригинальный список sps. Итерации происходят только 4 раза (по 4 элементам в копии), независимо от того, как растет оригинальный список.
+
+ ## 3.3 Пример
+Создание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране.
+```py
+>>> 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)
+... 
+... 	
+321
+```
+
+Программа вывела ответ, потому что сработал else, и за все десять итераций цикла так и не успел выполниться break по условию if. Блок else выполняется только если цикл завершился нормально (не был прерван break). Если срабатывает break, блок else пропускается.
+
+Попробуем обнулить список и запустить программу ещё раз:
+```py
+>>> for i in range(10):
+...     sps5.append(rn.randint(1,100))
+...     ss=sum(sps5)
+...     if ss>500: break
+... else: print(ss)
+...
+>>> ss
+521
+>>> sps5
+[97, 78, 21, 54, 32, 74, 62, 60, 10, 33]
+```
+
+После того, как прошло девять итераций, сумма элементов списка уже была больше 500, поэтому
+цикл закончился из-за if, а не из-за окончания диапазона range(10).
+
+ ## 3.4 Пример с символьной строкой
+```py
+>>> stroka='Это – автоматизированная система'
+>>> stroka1=""
+>>> for ss in stroka:
+... 	stroka1+=" "+ss
+... 
+... 	
+>>> stroka1
+' Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+Переменная ss проходит по всему строковому объекту, на каждой итерации принимая значение
+одного знака. Этот знак с предшествующим пробелом дописывается в конец другой, изначально
+пустой строки. Цикл закончится, когда закончится исходная строка.
+
+ ## 3.5 Запись цикла в строке
+Пример: создание списка с синусоидальным сигналом.
+```py
+>>> import math
+>>> sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+>>> sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+>>> import pylab
+>>> pylab.plot(sps2, label='Синусоидальный сигнал', color = 'green')
+[<matplotlib.lines.Line2D object at 0x00000244DD254A50>]
+>>> pylab.show()
+```
+Здесь используется конструкция list comprehention (генератор списков). В общем
+виде она выглядит так:
+<итоговый список> = [<выражение> for <элемент> in <исходный объект> if <условие>]
+
+Полученный график сохранен в файле Figure_1
+![Синусоида](Figure_1.png)
+
+
+ # 4. Цикл «пока истинно условие» – управляющая инструкция while.
+Общее правило написания:
+while <Условие>:
+<отступы><Блок инструкций 1 – тело цикла>
+[else:
+<отступы><Блок инструкций 2 – если в цикле не сработал break>]
+Здесь <Условие> - некоторое логическое выражение. Если на очередном витке цикла оно принимает значение True (или не равно 0), то выполняется Блок инструкций 1. При этом, если в этом блоке присутствует инструкция break и она будет выполнена, то цикл завершается, иначе – переходит к новому витку цикла. В блоке инструкций 1 могут быть изменены значения объектов, входящих в Условие и его значение тоже может измениться. Если же его значением останется True, то вновь выполняется Блок инструкций 1 и т.д. Если в цикле присутствует Блок инструкций 2, то он будет выполнен, если завершение цикла произошло не по инструкции break, а по значению False (или значению =0) условия.
+
+ ## 4.1 Цикл со счетчиком.
+```py
+>>> rashod=300
+>>> while rashod:
+... 	print("Расход=",rashod)
+... 	rashod-=50
+... 
+... 	
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Мы не видим в выводе: когда rashod = 0, потому что цикл уже завершился. Все числа, кроме нуля, при конвертации в логический тип данных имеют логическое значение True и только ноль имеет значение False.
+Сравниваемая в управляющей инструкции переменная уменьшается в самом цикле, поэтому, когда
+строка со сравнением обнаружит 0, то воспримет это как False, и действия по выводу
+и уменьшению числа выполняться больше не будут.
+
+ ## 4.2 Пример с символьной строкой
+```py
+>>> import math
+>>> stroka='Расчет процесса в объекте регулирования'
+>>> i=0
+>>> sps2=[]
+>>> while i<len(stroka):
+... 	r=1-2/(1+math.exp(0.1*i))
+... 	sps2.append(r)
+... 	print('Значение в момент',i,"=",r)
+... 	i+=1
+... 
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 
+11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+```
+У цикла 38 повторений, по числу элементов в строке, но на 1 меньше.
+
+```py
+>>> pylab.plot(sps2, label='Сигнал выхода', color='black')
+[<matplotlib.lines.Line2D object at 0x00000244DD305BD0>]
+>>> pylab.title("Сигнал на выходе инерционного звена")
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+>>> pylab.show()
+```
+График сохранен под именем Figure_2.
+![График](Figure_2.png)
+
+ ## 4.3 Определение, является ли число простым (делится только на самого себя или 1)
+```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
+```
+
+Программа работает так: переменная kandidat отвечает за потенциальный делитель заданного
+числа. Изначально мы задаем половину от заданного числа, потому что у числа не может быть
+делителя большего, чем половина от него. Далее мы последовательно уменьшаем потенциальный
+множитель, каждый раз проверяя, получилось ли поделить без остатка. Если получилось, то
+число непростое, и цикл можно прекращать досрочно.
+
+Дополним программу так, чтобы она проверяла все числа от 250 до 300.
+```py
+>>> chislo = [x for x in range (250, 301)]
+>>> for a in chislo:
+...     kandidat = a // 2
+...     while kandidat > 1:
+...         if a % kandidat == 0:
+...             print(a, ' имеет множитель ', kandidat)
+...             break
+...         kandidat -= 1
+...     else: print(a, " является простым!")
+... 
+...     
+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
+```
+
+ ## 4.4 Инструкция continue
+Она используется, когда надо при определенном условии не завершить весь цикл, а завершить
+только текущую итерацию.
+
+Пример (вывод нечётных чисел):
+```py
+>>> for i in range(1, 11):
+...     if i % 2 == 0:  # Если число четное
+...         continue    # Пропускаем оставшуюся часть цикла
+...     print(i)
+... 
+...     
+1
+3
+5
+7
+9
+```
+
+ # 5. Завершение сеанса работы с IDLE

TEMA5/task.md

@@ -0,0 +1,126 @@
+ # Общее контрольное задание по теме 5
+Симанков Богдан, А-02-23
+
+ # Задание:
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+
+1. Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+2. Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+3. Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+ # Решение
+1.
+```py
+>>> stroka="Enter help below or click Help above for more information."
+>>> abc = "abcdefghijklmnopqrstuvwxyz"
+>>> for x in stroka:
+...    small = x.lower()
+...    if small in abc:
+...        numbers = abc.find(small)+1
+...        print("Буква",x, "с порядковым номером", numbers)
+...
+Буква E с порядковым номером 5
+Буква n с порядковым номером 14
+Буква t с порядковым номером 20
+Буква e с порядковым номером 5
+Буква r с порядковым номером 18
+Буква h с порядковым номером 8
+Буква e с порядковым номером 5
+Буква l с порядковым номером 12
+Буква p с порядковым номером 16
+Буква b с порядковым номером 2
+Буква e с порядковым номером 5
+Буква l с порядковым номером 12
+Буква o с порядковым номером 15
+Буква w с порядковым номером 23
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква c с порядковым номером 3
+Буква l с порядковым номером 12
+Буква i с порядковым номером 9
+Буква c с порядковым номером 3
+Буква k с порядковым номером 11
+Буква H с порядковым номером 8
+Буква e с порядковым номером 5
+Буква l с порядковым номером 12
+Буква p с порядковым номером 16
+Буква a с порядковым номером 1
+Буква b с порядковым номером 2
+Буква o с порядковым номером 15
+Буква v с порядковым номером 22
+Буква e с порядковым номером 5
+Буква f с порядковым номером 6
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква m с порядковым номером 13
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква e с порядковым номером 5
+Буква i с порядковым номером 9
+Буква n с порядковым номером 14
+Буква f с порядковым номером 6
+Буква o с порядковым номером 15
+Буква r с порядковым номером 18
+Буква m с порядковым номером 13
+Буква a с порядковым номером 1
+Буква t с порядковым номером 20
+Буква i с порядковым номером 9
+Буква o с порядковым номером 15
+Буква n с порядковым номером 14
+```
+
+2. 
+```py
+>>> text="Создайте список со словами из задания данного пункта Для этого списка определите есть ли в н`м некоторое заданное значение и выведите соответствующее сообщение либо о нахождении элемента либо о его отсутствии в списке проверить как с имеющимся так и с отсутствующим словом"
+>>> spis=text.split(" ")
+>>> spis
+['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'н`м', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
+
+>>> slovo="сообщение" # Цикл с имеющимся словом в списке
+>>> for x in spis:
+...     if x ==slovo:
+...         print ("Такое слово есть :",slovo)
+...         break
+... else:
+...         print ("Такого слова нет")
+... 
+...         
+Такое слово есть : сообщение
+
+>>> slovo="нет" # Цикл без слова в списке
+>>> for x in spis:
+...     if x ==slovo:
+...         print ("Такое слово есть :",slovo)
+...         break
+... else:
+...         print ("Такого слова нет")
+... 
+...         
+Такого слова нет
+```
+
+3.
+```py
+>>> spis=['Savin', 'Volodin', 'Simankov']
+>>> spis1=[3.0, 2.5, 4.2]
+>>> spis_1=[2.5, 3.5, 4]
+>>> spis_0=['Volodin', 'Simankov', 'Savin']
+>>> student = input("Введите фамилию: ")
+Введите фамилию: Simankov
+>>> if student in spis:
+>>> if (student in spis) and (student in spis_0):
+...     index_summer=spis.index(student)   # Индекс студента по летней сессии
+...     ball_summer=spis1[index_summer]    # Балл студента по летней сессии
+...     index_winter=spis_0.index(student) # Индекс студента по зимней сессии
+...     ball_winter=spis_1[index_winter]   # Балл студента по зимней сессии
+...     print("Студент - ",student) 
+...     print("Летняя сессия: ",ball_summer)
+...     print("Зимняя сессия: ",ball_winter)
+... else: print("Студент не найден")
+... 
+Студент -  Simankov
+Летняя сессия:  4.2
+Зимняя сессия:  3.5
+```