ИКЗ

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Беженарь
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')

TEMA1/protocol.py

@@ -0,0 +1,49 @@
+# Протокол по Теме 1 Беженарь
+Python 3.11.5 (tags/v3.11.5:cce6ba9, Aug 24 2023, 14:38:34) [MSC v.1936 64 bit (AMD64)] on win32
+Type "help", "copyright", "credits" or "license()" for more information.
+import os
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\\Tema1')
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')
+
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=Alena
+import Pr0
+Hello
+Your name=Alena
+import Prb1
+Traceback (most recent call last):
+  File "<pyshell#4>", line 1, in <module>
+    import Prb1
+ModuleNotFoundError: No module named 'Prb1'
+
+import prb1
+Как Вас зовут? Алёна
+Привет, Алёна
+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.
+
+
+===== RESTART: C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1\prb1.py =====
+Как Вас зовут? Алёна
+Привет, Алёна
+import(tdemo_chaos.py)
+SyntaxError: invalid syntax
+import tdemo_chaos.py
+Traceback (most recent call last):
+  File "<pyshell#11>", line 1, in <module>
+    import tdemo_chaos.py
+ModuleNotFoundError: No module named 'tdemo_chaos.py'; 'tdemo_chaos' is not a package
+import tdemo_chaos

TEMA1/report.md

@@ -0,0 +1,210 @@
+# Отчет по теме 1
+
+Беженарь Алёна, А-02-23
+
+## 0 Работа с Git
+
+Создала на сервере кафедры УИТ копию репозитория "python-labs", а после клонировала его в папку "Bezhenar" на рабочем столе и преобразовала его на исходный репозиторий (upstream).
+
+## 1 Изучение среды IDLE 
+
+#### 1.1 Знакомство с интерпритатором
+
+Запустила программу-интерпритатор "Python 3.11"
+![Окно программы-интерприаторa](figure0.PNG)
+
+#### 1.2 Работа с интерпритатором
+
+Ввела инструкцию:
+
+```py
+>>>print('Hello')
+``` 
+
+в результате, после нажатия "Enter" получила на следующей строке:
+
+```py
+Hello
+``` 
+
+После ввела другую инструкцию:
+```py
+>>>h=input('Your name=')
+``` 
+в результате, после нажатия "Enter"и введения своего имени получила:
+
+```py
+Your name=Alena
+``` 
+
+Далее завершила работу интерпритатора вводом инструкции:
+```py
+>>>exit()
+``` 
+#### 1.3 Работа с IDLE средой Python
+
+Запустила интерактивную графическую оболочку IDLE среды Python.
+
+![Окно интерактивной графической оболочки IDLE среды Python](figure1.PNG)
+
+В командном окне ввела инструкцию настройки рабочего каталога среды:
+
+```py
+>>>import os
+>>>os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')
+```
+
+Изучила главное меню и выпадающие окна.
+
+В главном меню выбрала предложение «Настройки (Options)». Установила в среде: шрифт типа Arial CYR, размер 11, размер начального окна - высоту 50 символов, ширину 100 символов, подкраску комментариев - коричневая. 
+![Установленные настройки](figure2.png)
+
+Используя предложения «Файл (File)» и «Новый файл (New File)» открыла окно текстового редактора оболочки IDLE. В первой строке окна редактора ввела комментарий, начиная его со знака #:
+
+```py
+#Программа по Теме 1 Беженарь
+```
+Во второй - пятой строках вставила инструкции, использованные при выполнении п.п. 1.2, 1.3 и вышло:
+
+```py
+#Программа по Теме 1 Беженарь
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir(r'C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1')
+```
+Сохранила введенный текст в программном файле Pr0.py в рабочем каталоге. Запустила инструкции на выполнение, используя предложение  в меню редактора: «Запустить модуль (Run module)». 
+
+Результат:
+```py
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=
+```
+Закрыла окно редактора.
+
+Рассмотрела другой способ запуска программы на выполнение. Для этого в командном окне запустила программу на выполнение инструкцией
+ import Pr0
+
+Результат:
+```py
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=
+```
+
+Третий способ: нажала функциональную клавишу F5.
+
+Результат:
+```py
+====== RESTART: C:/Users/u522-14/Desktop/Bezhenar/python-labs/TEMA1/Pr0.py =====
+Hello
+Your name=
+```
+
+Теперь запустила на выполнение программу, которая находится в рабочем каталоге в файле prb1.py инструкцией:
+```py
+import Prb1
+```
+
+Результат:
+```py
+Как Вас зовут? Алёна
+Привет, Алёна
+```
+
+Используя в меню текстового редактора предложение «Открыть (Open)», изучила состав рабочего каталога. 
+Открыла каталог __pycache__ и попыталась открыть в текстовом редакторе файл Pr0.cpython-34.pyc – результат работы компилятора среды. 
+Результат:
+![Открытый файл Pr0.cpython-34.pyc в текстовом редакторе](figure3.PNG)
+
+Большая часть текста просто не читаема. Связано этос тем, что Python - это интерпретируемый язык, а расширение .pyc это промежуточный байткод, который запускается ВМ. 
+Он не предназначен для чтения человеком его как книжки. При попытке открытия его текстовый редактор пытается преобразовать двоичный код в utf кодировку символов, но код с самого начала не записывался с учетом кодировок, поэтому большая часть файла является смесью букв и символов.
+Компиляция програм же необходима, чтобы перевести команды из формы понятной человеку в машинный код, которыйможет быть обработан процессором.
+
+В текстовом редакторе оболочки IDLE открыла новое окно. В первой строке ввела комментарий
+```py
+#Протокол по Теме 1 Беженарь
+```
+
+В последующих строках ввела копию всех строк из командного окна среды IDLE. Сохранила содержимое в файле с именем protocol.py.
+
+#### 1.4 Работа с разделом помощи
+
+Раздел помощи (Help) главного меню предлагает такие виды помощи:
+1.Документация для IDLE
+2.Документация для Python
+3.Turtle Demo - это встроенная демонстрационная программа для визуализациивозможностей граф. модуля Turtle.
+
+Ввела инструкцию обращения к оперативной помощи по функции print() и input():
+```py
+>>>help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+>>>help(print); help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+```
+
+Можно использовать другой вариант обращения к оперативной помощи – при нажатии на функциональную клавишу F1 появляется окно справочной подсистемы, в левой части на закладке «Указатель (Index)» находится упорядоченный по алфавиту список терминов языка Python. 
+Нашла в этом списке строку
+print() (built-in function)
+![строка с print()](figure5.PNG)
+и щелкнула по ней мышью и в правой части окна появилась справка по этой функции.
+![справка print()](figure6.PNG)
+В главном меню предложение «Помощь (Help)», в выпадающем меню – «Python Docs» появляется то же диалоговое окно, что и при нажатии клавиши F1.
+
+
+#### 1.5 Пункт 15
+Последовательно выполнила следующие действия:
+Выберала предложения «Файл (File)» и «Открыть (Open)» и после стандартного диалога по открытию файла выбрала файл prb1.py в папке Tema1. 
+Теперь у меня 3 открытых окна: командное окно IDLE (Python Shell) и 2 окна текстового редактора. Используя предложения «Окно (Window)» в меню этих окон поочередно активировала каждое из этих окон.
+Сделала активным окно редактора с программой prb1. Запустила программу из файла prb1.py на выполнение. В ответ на запрос в командном окне IDLE ввела своё имя и получила приветствие от программы.
+```py
+===== RESTART: C:\Users\u522-14\Desktop\Bezhenar\python-labs\TEMA1\prb1.py =====
+Как Вас зовут? Алёна
+Привет, Алёна
+```
+С использованием меню в окне редактора открыла ранее созданную программу Pr0.py. Теперь у меня 4 окна: командное окно (Python Shell) и три окна в редакторе.
+Закрыла два окна текстового редактора с программами (предложения «Файл (File)» и «Закрыть (Close)»).
+Используя инструкцию import, запустила на выполнение программу из файла tdemo_chaos.py.
+Выберала предложения «Помощь (Help)» и «Демонстрации (Turtle Demo)». В появившемся новом окне в меню выбрала предложение «Примеры (Examples)» и из появляющегося списка примеров – «Часы (Clock)». 
+Нажала кнопку «Запуск (Start)» в нижней части окна.
+Закрыла окно текстового редактора с протоколом.
+![Пример часов](figure7.PNG)
+![Пример леса](figure8.PNG)
+Завершила работу со средой. Для этого выбрала предложения «Файл (File)» и «Выход (Exit)».

TEMA1/task.md

@@ -0,0 +1,9 @@
+# Индивидуальное контрольное задание по Теме 1
+Беженарь Алёна Николаевна
+
+## Вопрос №11
+В каком месте инструкции можно написать комментарий?
+
+## Ответ
+
+Комментарий можно написать после инструкции, но обязательно после символа #. Всё что будет после этого символа до конца строки будет считаться комментарием. Если же написать символ # перед инструкцией, то при запуске на выполнение она не выполнится. Также частой практикой является написание комментария на строке выше(перед инструкцией, но нена одной с ней строках).

TEMA2/report.md

@@ -0,0 +1,484 @@
+# Отчет по теме 2
+
+Беженарь Алёна Николаевна
+
+## Базовые типы объектов
+
+## 1. Установка рабочего каталога. Создание рабочего протокола.
+В оболочке IDLE установила актуальный рабочий каталог, а затем в нём создала рабочий протокол.
+![Изменение директории и создание report.py](figure0.png)
+
+## 2. Изучение простых объектов.
+Рассмотрим операции присваивания значения объектам-переменным
+```py
+>>> f1 = 16; f2 = 3
+>>> f1, f2
+    (16, 3)
+>>> f1; f2
+    16
+    3
+```
+Для того, чтобы узнать, какие объекты существуют в среде Python на данный момент, ипользовала функцию dir():
+```py
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+Использовала эту же функцию, но уже с объектом 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', 'numerator', 'real', 'to_bytes']
+```
+Определила классовую принадлежность объекта f2 с помощью функции type(f2):
+```py
+>>>type(f2)
+<class 'int'>
+```
+Удалила объекты f1 и f2 из оперативной памяти, а затем проверила их удаление с помощью функции dir():
+```py
+>>>del f1,f2
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+Как видно из вывода после команды, f1 и f2 полностью пропали из оперативной памяти.
+
+## 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']
+```
+Сохранила его в переменной с именем keywords
+```py
+>>>keywords = keyword.kwlist
+>>> keywords
+['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', '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', '_', '__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']
+```
+В данном списке содержатся имена некоторых встроенных функций, работа которых, проверена ниже:
+```py
+>>>abs(-8800555) #Взятие модуля аргумента
+8800555
+
+>>>len("Test") # Расчет длины объекта
+4
+
+>>>max(1, 2, 3) # Поиск максимального числа среди аргументов
+3
+
+>>>min(0, -5, 10) # Поиск минимального числа среди аргументов
+-5
+
+>>>pow(2, 3) # При передаче 2 аргументов - возведение в степень, 3 - поиск остатка от деления на 3 аргумент.
+8
+
+>>>pow(2, 3, 3)
+2
+
+>>>round(2.5987,0) # Округление до количества цифр после запятой, переданного во 2 аргументе
+3.0
+
+>>>sorted([3, 7, 5, 9, -1]) # Сортировка по возрастанию (при reverse = True - по убыванию)
+[-1, 3, 5, 7, 9]
+
+>>>numbers = [1, 2, 3, 4, 5]
+total = sum(numbers) #возвращает сумму всех элементов списка.
+total
+15
+
+>>>list(zip("abcd", [1, 2, 3, 4])) # Попарное объединение элементов
+[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+```
+## 6. Проверка имён объектов на чувствительность к регистру.
+Убедилась, что имена объектов в Python являются регистрочувствительными:
+```py
+>>>Gg1=45
+>>>gg1;Gg1
+1.6
+45
+```
+## 7. Изучение простых типов объектов.
+
+### 7.1 Изучение логического типа (bool).
+Пример создания объектов логического типа:
+```py
+>>>bb1=True;bb2=False
+>>>bb1;bb2
+True
+False
+>>>type(bb1) #функция, показывающая тип (класс) объекта
+<class 'bool'>
+```
+### 7.2. Изучение остальных простых типов.
+Рассмотрела остальные простые типы, такие как int (целые числа), float (вещественные числа) и complex (комплексные числа):
+```py
+>>>ii1=-1234567890
+>>>ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+>>>dv1=0b1101010 #Это – двоичное число.
+>>>type(dv1)
+<class 'int'>
+>>.vsm1=0o52765   #Это – восьмеричное число
+>>>type(vsm1)
+<class 'int'>
+>>>shest1=0x7109af6  #Это – шестнадцатеричное число
+>>>type(shest1)
+<class 'int'>
+>>>cc1=2-3j
+>>>a=3.67; b=-0.45
+>>>cc2=complex(a,b)
+>>>cc2
+(3.67-0.45j)
+```
+
+### 7.3 Изучение строкового типа (str).
+Строки символов можно заключать в одинарные или двойные кавычки:
+
+```py
+>>>ss1='Это - строка символов'
+>>>ss1
+'Это - строка символов'
+>>>ss1="Это - строка символов"
+>>>ss1
+'Это - строка символов'  
+```
+Внутри строк могут присутствовать экранированные последовательности, начинающиеся со знака "\", что позволяет использовать в строках специальные символы:
+
+```py
+>>>ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>>print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+>>>ss1b= 'Меня зовут: \n <Беженарь А.Н.>'
+>>>print(ss1b)
+Меня зовут: 
+ <Беженарь А.Н.>
+```
+С помощью тройных кавыче можно задавать многострочные строки, ввод которых будет продолжаться, пока вновь не будут введены тройные кавычки:
+```py
+>>>mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>>print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+Символьные строки в Python индексируются, поэтому к определенным сиволам или последовательностям символов внутри них можно обращаться по индексам:
+```py
+>>>ss1[0]   #Это – символ «Э»
+'Э'
+>>>ss1[8]  #А это – символ «р»
+'р'
+>>>ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+'о'
+>>>ss1[6:9] # Это часть строки – символы с 6-го индекса по 8-й
+'стр'
+>>> ss1[13:] # Это часть строки – с 13-го индекса и до конца
+'символов'
+>>>ss1[:13] # Это часть строки – с начала и до 12-го индекса включительно
+'Это - строка '
+>>>ss1[5:-8] # Это часть строки – с 5-го индекса и до 8-го от конца
+' строка '
+>>>ss1[3:17:2] # Часть строки – с 3-го по 16-й индексы с шагом 2
+'  тоасм'
+>>>ss1[17:3:-2] # Часть строки – с 3-го по 16-й индексы с обратным шагом 2
+'омсаот '
+>>>ss1[-4:3:-2] # Часть строки – с 4-го с конца по 3-й с начала индексы с обратным шагом 2
+'омсаот '
+>>>ss1[4]='='  # Будет диагностика!
+Traceback (most recent call last):
+  File "<pyshell#74>", line 1, in <module>
+    ss1[4]='='  # Будет диагностика!
+TypeError: 'str' object does not support item assignment
+>>>ss1=ss1[:4]+'='+ss1[5:]
+>>>print(ss1)
+Это = строка символов
+```
+Проделаю тоже самое самостоятельно со строкой ss1b:
+```py
+>>>ss1b
+'Меня зовут: \n <Беженарь А.Н.>'
+>>>ss1b[3]
+'я'
+>>>ss1b[3-2]
+'е'
+>>>ss1b[-3]
+'Н'
+>>>ss1b[-3:]
+'Н.>'
+>>>ss1b[0:-1]
+'Меня зовут: \n <Беженарь А.Н.'
+>>>ss1b[3:-3]
+'я зовут: \n <Беженарь А.'
+>>>ss1b[-23:0]
+''
+>>>ss1b[::-1]
+'>.Н.А ьранежеБ< \n :тувоз янеМ'
+>>>ss1b[::-3]
+'>.ьне :в е'
+>>>ss1b=ss1b[0:15]+ss1b[16:29]
+>>>ss1b
+'Меня зовут: \n <еженарь А.Н.>'
+```
+### 7.4 Выполняю задание, самостоятельно закрепляю изученные типы переменных.
+```py
+>>>stringg = '15'+"ab"
+>>>type(stringg)
+<class 'str'>
+>>>a = 10
+>>>type(a)
+<class 'int'>
+>>>b = 0.00800
+>>>type(b)
+<class 'float'>
+>>>b = 0.8e-100
+>>>type(b)
+<class 'float'>
+>>>c = 0-1j
+>>>type(c)
+<class 'complex'>
+>>>var = c/b
+>>>type(var)
+<class 'complex'>
+>>>b = True
+>>>type(b)
+<class 'bool'>
+>>>b = None
+>>>type(b)
+<class 'NoneType'>
+```
+## 8.Изучение сложных типов объектов.
+### 8.1. Изучение списков.
+Рассмотрела такой объект Python, как списки - упорядоченные по местоположению коллекции объектов произвольных типов, размер которых практически не ограничен:
+```py
+>>>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]
+```
+Списки в Python индексируются так же как и строки:
+```py
+>>>spis1[-1] # Если индекс отрицательный, то он отсчитывается с конца, но не с 0, а с 1
+    (5-9j)
+>>> stup[-8::2] # Вывод элементов с 8-го индекса с конца с шагом 2
+    [0, 1, 1, 1]
+```
+Элементы списков можно изменять:
+```py
+>>> spis1[1] = "Список"
+>>> print(spis1)
+    [111, 'Список', (5-9j)]
+```
+Методы объекта находятся в списке его атрибутов, поэтому для их просмотра нужно опять вводить функцию dir(), а описание какого-либо метода можно получить с помощью функции help(<название метода>):
+```py
+>>>dir(spis1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+>>>len(spis1)
+3
+>>>help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+```
+С помощью методов объектов-списков можно добавлять и удалять элементы:
+```py
+>>>spis1.append('New item')  # В конец списка добавлен элемент «New item»
+>>>print(spis1)
+[111, 'Список', (5-9j), 'New item']
+>>>spis1+['Second New item'] #Конкатенация (исходный список не изменился)
+[111, 'Список', (5-9j), 'New item', 'Second New item']
+>>>print(spis1)
+[111, 'Список', (5-9j), 'New item']
+>>>spis1.append(ss1b)
+>>.print(spis1)
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>']
+>>>spis1.pop(1)   #Из списка удален элемент с индексом 1
+'Список'
+```
+Рассмотрела остальные методы объектов-списков:
+```py
+>>>list=[1,2,3,4,5]
+>>>list.insert(1, 3) # Вставка второго аргумента на индекс, определяемый первым аргументом
+>>>print(list)
+[1, 3, 2, 3, 4, 5]
+>>>list.remove(3) # Удаление первого вхождения элемента, соответствующего переданному аргументу
+>>print(list)
+[1, 2, 3, 4, 5]
+>>>list.extend(list[:2]) # Продление списка
+>>>print(list)
+[1, 2, 3, 4, 5, 1, 2]
+>>>list.sort() # Сортировка элементов списка
+>>>print(list)
+[1, 1, 2, 2, 3, 4, 5]
+>>>list.reverse() # Изменение порядка следования элементов списка на противоположный
+>>>print(list)
+[5, 4, 3, 2, 2, 1, 1]
+>>>list.copy() # Создание копии списка
+[5, 4, 3, 2, 2, 1, 1]
+>>>list.count(2) # Подсчет вхождений в список для элемента, переданного в качестве аргумента
+2
+>>>list.index(3) # Вывод индекса в списке для элемента, соответствующего переданному аргументу
+2
+```
+Списки также могут быть вложенными, то есть включать в себя другие списки:
+```py
+>>>spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
+>>>print(spis2)
+[[111, (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+>>>spis2[0][1]  #обращение к элементу списка spis1
+(5-9j)
+>>>spis2[0][1]=78  #Значение элемента заменено на 78
+>>>print(spis2)
+[[111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+>>>print(spis1)
+[111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>']
+```
+Видим, что spis1 тоже изменился. Это происходит потому, что python работает не просто с объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке, а не по значению.Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]] мы не создаем копию spis1, а сообщаем именно тот список, поэтому его изменения в составе spis2 отображаются на исходном spis1.
+
+Создание своего списка - объекта:
+```py
+>>>spis3 = [100, 'Test', True, spis1]
+>>>print(spis3)
+[100, 'Test', True, [111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>']]
+```
+### 8.2. Изучение кортежей.
+Объекты-кортежи очень похожи на списки, но их нельзя изменять, также литерал кортежа заключается в круглые скобки, а не в квадратные как у списков. В примере ниже рассмотрены варианты создания кортежей и их 2 основных метода:
+```py
+>>>kort1=(222,'Kortezh',77+8j)
+>>>kort1= kort1+(1,2)
+>>>print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2)
+>>>kort1= kort1+(ss1b,)
+>>>print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+>>>kort2=kort1[:2]+kort1[3:]
+>>>print(kort2)
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+>>>kort1.index(2)
+4
+>>>kort1.count(222)
+1
+>>>kort1[2]=90 #Будет получена диагностика о невозможности изменения кортежа
+Traceback (most recent call last):
+  File "<pyshell#142>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+Создала свой объект-кортеж, в котором все элементы разного типа:
+```py
+>>> kort3 = (123, "Text", [1, 2, 3], (1, 2, 3))
+>>> print(kort3)
+(123, 'Text', [1, 2, 3], (1, 2, 3))
+```
+### 8.3. Изучение словарей.
+Объект-словарь представляет из себя набор пар «ключ-значение», причем в качестве ключей могут использоваться неизменяемые типы объектов, а в виде значений - объекты любых типов:
+```py
+>>>dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>>print(dic1)
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+>>>dic1["Orel"] # Обращение к элементам словаря осуществляется по ключам, а не по индексам
+56
+>>>dic1["Pskov"] = 78 # Добавление нового элемента в словарь
+>>>dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+К ключам словаря можно обратиться с помощью метода keys(), а к значениям - с помощью метода values():
+```py
+>>>sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+>>>sorted(dic1.values())
+[45, 56, 78, 145]
+```
+Элементы словаря также могут быть словарями:
+```py
+>>>dic2={1:'mean',2:'standart deviation',3:'correlation'}
+>>>dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+>>>dic3['statistics'][2]
+'standart deviation'
+```
+С помощью функции dict() можно создавать словарь из списка с элементами-кортежами:
+```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 еженарь А.Н.>'}
+```
+Также с помощью этой функции и функции zip() можно создавать словари и просто из двух списков:
+```py
+>>>dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+>>>dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n еженарь А.Н.>'}
+```
+Так как элементы словаря являются парами «ключ-значение», то каждому ключу должно соответствовать своё значение, поэтому, если при создании словаря число ключей не равно числу значений, то словарь создастся с количеством элементов, равным наименьшей из длин списка ключей или списка значений:
+```py
+>>>cort=(1,2,3,4)
+>>>cort=(1,2,3,4,5,6,7)
+>>>spisok = ["A", "B", "C", "D", "E"]
+>>>dictionary = dict(zip(cort, spisok))
+>>>dictionary
+{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E'}
+```
+Пример словаря с описанием состава студентов, обучающихся на АВТИ:
+```py
+>>>AVTI = {"Курс I" : [22, 23, 17, 24, 30, 29, 28, 25, 23, 0, 4, 31, 30, 33, 18, 12, 27],
+            "Курс II" : [18, 16, 12, 15, 29, 18, 21, 23, 13, 0, 4, 20, 31, 26, 16],
+            "Курс III" : [17, 12, 0, 6, 17, 15, 19, 19, 0, 0, 5, 17, 22, 18, 12],
+            "Курс IV" : [27, 16, 0, 13, 17, 15, 19, 20, 0, 0, 2, 15, 18, 16, 17]}
+>>>AVTI["Курс III"][5]
+15
+```
+### 8.4. Изучение объектов-множеств.
+Объекты-множества – это неупорядоченные совокупности неповторяющихся элементов неизменяемых типов. Пример создания такого объекта:
+```py
+>>>mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>>mnoz1
+{'двигатель', 'микропроцессор', 'линия связи', 'датчик'}
+```
+Некоторые операции с множествами:
+```py
+>>> len(mnoz1) # Определение числа элементов
+4
+>>> "датчик" in mnoz1 # Проверка наличия элемента в множестве
+True
+>>> mnoz1.add("реле") # Добавление элемента в множество
+>>> print(mnoz1)
+{'линия связи', 'двигатель', 'микропроцессор', 'реле', 'датчик'}
+>>> mnoz1.remove("линия связи") # Удаление элемента из множества
+>>> print(mnoz1)
+{'двигатель', 'микропроцессор', 'реле', 'датчик'}
+```
+Придумала свой объект-множество с элементами разных типов и выполнил над ним некоторые операции:
+```py
+>>>mnozhestvo = {123, "Text", (1, 2, 3)}
+>>>mnozhestvo.add(100)
+>>>mnozhestvo
+{'Text', 123, (1, 2, 3), 100}
+>>>mnozhestvo.remove(123)
+>>>mnozhestvo
+{'Text', (1, 2, 3), 100}
+```
+## 9. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.

TEMA2/report.py

@@ -0,0 +1,311 @@
+#Протокол по Теме 2 Беженарь Алёна Николаевна
+import os
+os.chdir("D:\\ПОАС\\python-labs\\TEMA2")
+f1=16;f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+gg1 = 1.6 # Значение в виде вещественного числа
+hh1 = "Строка" # Значение в виде символьной строки
+73sr = 3 # Неправильное имя – начинается с цифры - будет диагностика
+SyntaxError: invalid decimal literal
+and = 7 # Недопустимое имя – совпадает с ключевым словом - будет диагностика
+SyntaxError: invalid syntax
+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']
+keywords = keyword.kwlist
+keywords
+['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']
+abs(-8800555)
+8800555
+abs(-8800555) #Взятие модуля аргумента
+8800555
+len("Test") # Расчет длины объекта
+4
+max(1, 2, 3) # Поиск максимального числа среди аргументов
+3
+min(0, -5, 10) # Поиск минимального числа среди аргументов
+-5
+pow(2, 3) # При передаче 2 аргументов - возведение в степень, 3 - поиск остатка от деления на 3 аргумент.
+8
+pow(2, 3, 3)
+2
+round(2.5987,0) # Округление до количества цифр после запятой, переданного во 2 аргументе
+3.0
+sorted([3, 7, 5, 9, -1]) # Сортировка по возрастанию (при reverse = True - по убыванию)
+[-1, 3, 5, 7, 9]
+numbers = [1, 2, 3, 4, 5]
+total = sum(numbers)
+total
+15
+list(zip("abcd", [1, 2, 3, 4])) # Попарное объединение элементов
+[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
+Gg1=45
+gg1;Gg1
+1.6
+45
+ii1=-1234567890
+ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+dv1=0b1101010 #Это – двоичное число.
+type(dv1)
+<class 'int'>
+vsm1=0o52765   #Это – восьмеричное число
+type(vsm1)
+<class 'int'>
+shest1=0x7109af6  #Это – шестнадцатеричное число
+type(shest1)
+<class 'int'>
+cc1=2-3j
+a=3.67; b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j)
+ss1='Это - строка символов'
+ss1
+'Это - строка символов'
+ss1="Это - строка символов"
+ss1
+'Это - строка символов'
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+ss1b= 'Меня зовут: \n <Беженарь А.Н.>'
+print(ss1b)
+Меня зовут: 
+ <Беженарь А.Н.>
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+ss1[0]   #Это – символ «Э»
+'Э'
+ss1[8]  #А это – символ «р»
+'р'
+ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+'о'
+ss1[6:9] # Это часть строки – символы с 6-го индекса по 8-й
+'стр'
+ss1[13:] # Это часть строки – с 13-го индекса и до конца
+'символов'
+ss1[:13] # Это часть строки – с начала и до 12-го индекса включительно
+'Это - строка '
+ss1[5:-8] # Это часть строки – с 5-го индекса и до 8-го от конца
+' строка '
+ss1[3:17:2] # Часть строки – с 3-го по 16-й индексы с шагом 2
+'  тоасм'
+ss1[17:3:-2] # Часть строки – с 3-го по 16-й индексы с обратным шагом 2
+'омсаот '
+ss1[-4:3:-2] # Часть строки – с 4-го с конца по 3-й с начала индексы с обратным шагом 2
+'омсаот '
+ss1[4]='='  # Будет диагностика!
+Traceback (most recent call last):
+  File "<pyshell#74>", line 1, in <module>
+    ss1[4]='='  # Будет диагностика!
+TypeError: 'str' object does not support item assignment
+ss1=ss1[:4]+'='+ss1[5:]
+print(ss1)
+Это = строка символов
+ss1b
+'Меня зовут: \n <Беженарь А.Н.>'
+ss1b[3]
+'я'
+ss1b[3-2]
+'е'
+ss1b[-3]
+'Н'
+ss1b[-3:]
+'Н.>'
+ss1b[0:-1]
+'Меня зовут: \n <Беженарь А.Н.'
+ss1b[3:-3]
+'я зовут: \n <Беженарь А.'
+ss1b[-23:0]
+''
+ss1b[::-1]
+'>.Н.А ьранежеБ< \n :тувоз янеМ'
+ss1b[::-3]
+'>.ьне :в е'
+ss1b=ss1b[0:15]+ss1b[16:29]
+ss1b
+'Меня зовут: \n <еженарь А.Н.>'
+ss1b=ss1b[0:14]+ss1b[15:29]
+stringg = '15'+"ab"
+type(stringg)
+<class 'str'>
+a = 10
+type(a)
+<class 'int'>
+b = 0.00800
+type(b)
+<class 'float'>
+b = 0.8e-100
+type(b)
+<class 'float'>
+c = 0-1j
+type(c)
+<class 'complex'>
+var = c/b
+type(var)
+<class 'complex'>
+b = True
+type(b)
+<class 'bool'>
+b = None
+type(b)
+<class 'NoneType'>
+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]
+spis1[-1] # Если индекс отрицательный, то он отсчитывается с конца, но не с 0, а с 1
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+spis1[1] = "Список"
+print(spis1)
+[111, 'Список', (5-9j)]
+dir(spis1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+len(spis1)
+3
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+spis1.append('New item')  # В конец списка добавлен элемент «New item»
+print(spis1)
+[111, 'Список', (5-9j), 'New item']
+spis1+['Second New item'] #Конкатенация (исходный список не изменился)
+[111, 'Список', (5-9j), 'New item', 'Second New item']
+print(spis1)
+[111, 'Список', (5-9j), 'New item']
+spis1.append(ss1b)
+print(spis1)
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>']
+spis1.pop(1)   #Из списка удален элемент с индексом 1
+'Список'
+list=[1,2,3,4,5]
+list.insert(1, 3) # Вставка второго аргумента на индекс, определяемый первым аргументом
+print(list)
+[1, 3, 2, 3, 4, 5]
+list.remove(3) # Удаление первого вхождения элемента, соответствующего переданному аргументу
+print(list)
+[1, 2, 3, 4, 5]
+list.extend(list[:2]) # Продление списка
+print(list)
+[1, 2, 3, 4, 5, 1, 2]
+list.sort() # Сортировка элементов списка
+print(list)
+[1, 1, 2, 2, 3, 4, 5]
+list.reverse() # Изменение порядка следования элементов списка на противоположный
+print(list)
+[5, 4, 3, 2, 2, 1, 1]
+list.copy() # Создание копии списка
+[5, 4, 3, 2, 2, 1, 1]
+list.count(2) # Подсчет вхождений в список для элемента, переданного в качестве аргумента
+2
+list.index(3) # Вывод индекса в списке для элемента, соответствующего переданному аргументу
+2
+spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
+print(spis2)
+[[111, (5-9j), 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+spis2[0][1]  #обращение к элементу списка spis1
+(5-9j)
+spis2[0][1]=78  #Значение элемента заменено на 78
+print(spis2)
+[[111, 78, 'New item', 'Меня зовут: \n еженарь А.Н.>'], [4, 5, 6, 7]]
+kort1=(222,'Kortezh',77+8j)
+kort1= kort1+(1,2)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+kort2=kort1[:2]+kort1[3:]
+print(kort2)
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n еженарь А.Н.>')
+kort1.index(2)
+4
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#142>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+kort3 = (123, "Text", [1, 2, 3], (1, 2, 3))
+print(kort3)
+(123, 'Text', [1, 2, 3], (1, 2, 3))
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+print(dic1)
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45}
+dic1["Orel"] # Обращение к элементам словаря осуществляется по ключам, а не по индексам
+56
+dic1["Pskov"] = 78 # Добавление нового элемента в словарь
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+dic3['statistics'][2]
+'standart deviation'
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n еженарь А.Н.>'}
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n еженарь А.Н.>'}
+cort=(1,2,3,4)
+cort=(1,2,3,4,5,6,7)
+spisok = ["A", "B", "C", "D", "E"]
+dictionary = dict(zip(cort, spisok))
+dictionary
+{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E'}
+AVTI = {"Курс I" : [22, 23, 17, 24, 30, 29, 28, 25, 23, 0, 4, 31, 30, 33, 18, 12, 27],
+            "Курс II" : [18, 16, 12, 15, 29, 18, 21, 23, 13, 0, 4, 20, 31, 26, 16],
+            "Курс III" : [17, 12, 0, 6, 17, 15, 19, 19, 0, 0, 5, 17, 22, 18, 12],
+            "Курс IV" : [27, 16, 0, 13, 17, 15, 19, 20, 0, 0, 2, 15, 18, 16, 17]}
+AVTI["Курс III"][5]
+15
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'двигатель', 'микропроцессор', 'линия связи', 'датчик'}
+len(mnoz1) # Определение числа элементов
+4
+"датчик" in mnoz1 # Проверка наличия элемента в множестве
+True
+mnoz1.add("реле") # Добавление элемента в множество
+mnoz1
+{'микропроцессор', 'датчик', 'реле', 'двигатель', 'линия связи'}
+mnoz1.remove("линия связи") # Удаление элемента из множества
+mnoz1
+{'микропроцессор', 'датчик', 'реле', 'двигатель'}
+mnozhestvo = {123, "Text", (1, 2, 3)}
+mnozhestvo.add(100)
+mnozhestvo
+{'Text', 123, (1, 2, 3), 100}
+mnozhestvo.remove(123)
+mnozhestvo
+{'Text', (1, 2, 3), 100}

TEMA2/task.md

@@ -0,0 +1,60 @@
+# ОКЗ по теме 2
+
+Беженарь Алёна Николаевна
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+•	Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+•	Создать переменную со значением, совпадающим с первой буквой из familia.
+
+•	Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+•	Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+•	Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+•	Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+•	Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+•	Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+
+## Решение
+
+```py
+>>> familia = "Bezhenar" # 1 пункт
+>>> firstLetter = familia[0] # 2 пункт
+>>> print(firstLetter)
+    B
+>>> import keyword # 3 пункт
+>>> sp_kw = keyword.kwlist # 3 пункт
+>>> print(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']
+>>> sp_kw.remove("nonlocal") # 4 пункт
+>>> print(sp_kw)
+    ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+>>> kort_nam = ("Alyona", "Lena", "Deniska", "Yuriy") # 5 пункт
+>>> type(kort_nam)
+    <class 'tuple'>
+>>> kort_nam += ("Artyom", "Dima") # 6 пункт
+>>> print(kort_nam)
+    ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')
+>>> kort_nam.count("Dima") # 7 пункт
+    1
+>>> dict_bas = {'строка': familia,'список': sp_kw,'кортеж': kort_nam} # 8 пункт
+print(dict_bas)
+{'строка': 'Bezhenar', 'список': ['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'], 'кортеж': ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')}
+>>>dict_bas.keys()
+dict_keys(['строка', 'список', 'кортеж'])
+>>>dict_bas.values()
+dict_values(['Bezhenar', ['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'], ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')])
+```
+Второй способ:
+```py
+dict_bas = dict([('строка',familia,),('список',sp_kw),('кортеж',kort_nam)])
+print(dict_bas)
+{'строка': 'Bezhenar', 'список': ['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'], 'кортеж': ('Alyona', 'Lena', 'Deniska', 'Yuriy', 'Artyom', 'Dima')}
+```

TEMA2/task1.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по Теме 2
+Беженарь Алёна, А-02-23
+
+## Задание (10)
+Создайте два объекта
+x=(1,2,3,4,5)
+y=(11,22,33,44,55)
+К какому классу относятся эти объекты? Объедините их и напишите инструкцию расчета суммы элементов, находящихся на 4,6,8… позициях.
+
+## Решение
+Создаем два объекта и смотрим их классы:
+```py
+>>>x=(1,2,3,4,5)
+>>>y=(11,22,33,44,55)
+>>>type(x);type(y)
+<class 'tuple'>
+<class 'tuple'>
+```
+Объединим списки в один и напишем инструкцию рассчета суммы элементов, находящихся на 4,6,8... позициях:
+```py
+>>>xy=x+y
+>>>xy
+(1, 2, 3, 4, 5, 11, 22, 33, 44, 55)
+>>>summ=sum(xy[3::2])
+>>>summ
+103
+```

TEMA3/report.md

@@ -0,0 +1,679 @@
+# Отчет по Теме 3
+
+Беженарь Алёна Николаевна
+
+## Способы использования объектов разных типов.
+
+## 1. Установка рабочего каталога. Создание рабочего протокола.
+В оболочке IDLE установила актуальный рабочий каталог, а затем в нём создала рабочий протокол.
+![Скриншот созданного рабочего протокола](figure0.png)
+## 2. Преобразование простых базовых типов объектов.
+### 2.1. Преобразование в логический тип.
+Функция bool() позволяет преобразовывать переданные ей объекты в логический тип.
+```py
+>>> logiz1 = bool(56) # Любое целое число, кроме 0, преобразуется в True
+>>> logiz1
+    True
+>>> logiz2 = bool(0) # 0 преобразуется в False
+>>> logiz2
+    False
+>>> logiz3 = bool("Beta") # Непустая строка преобразуется в True
+>>> logiz3
+    True
+>>> logiz4 = bool("") # Пустая строка преобразуется в False
+>>> logiz4
+    False
+>>> type(logiz1);type(logiz2);type(logiz3);type(logiz4)
+    <class 'bool'>
+    <class 'bool'>
+    <class 'bool'>
+    <class 'bool'>
+```
+### 2.2. Преобразование объекта в число.
+Функция int(<Объект>,[<Система счисления, в которой определен объект>]) позволяет преобразовывать переданные ей объекты в целое десятичное число.
+```py
+>>> tt1 = int(198.9) # Отбрасывается дробная часть
+>>> tt1
+    198
+>>> tt2 = int("-76") # Число – в строке символов, система по умолчанию - десятичная
+>>> tt2
+    -76
+>>> tt3 = int("B", 16) # Число в шестнадцатеричной системе счисления
+>>> tt3
+    11
+>>> tt4 = int("71", 8) # Число в восьмеричной системе счисления
+>>> tt4
+     57
+>>> tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+    Traceback (most recent call last):
+      File "<pyshell#18>", line 1, in <module>
+        tt5 = int("98.76")
+    ValueError: invalid literal for int() with base 10: '98.76'
+```
+Функция float() позволяет преобразовывать переданные ей объекты в вещественное число.
+```py
+>>> flt1 = float(789) # Преобразование целого числа в вещественное
+>>> flt1
+    789.0
+>>> flt2 = float(-6.78e2)
+>>> flt2
+    -678.0
+>>> flt3 = float("Infinity") # В функцию float() можно передавать строки со значениями inf и NaN
+>>> flt3
+    inf
+>>> flt4 = float("-inf") # Значения inf и NaN являются нерегистрочувствительными
+>>> flt4
+    -inf
+```
+### 2.3. Преобразование десятичных чисел в другие систем счисления.
+Функции bin(), oct() и hex() позволяют преобразовать переданные ей десятичные числа в двоичную, восьмеричную и шестнадцатеричную системы счисления соответственно.
+```py
+>>> hh = 123
+>>> dv1 = bin(hh)
+>>> dv1
+    '0b1111011'
+>>> vos1 = oct(hh)
+>>> vos1
+    '0o173'
+>>> shs1 = hex(hh)
+>>> shs1
+    '0x7b'
+>>> int(dv1, 2) # Обратное преобразование из двоичной системы счисления
+    123
+>>> int(vos1, 8) # Обратное преобразование из восьмеричной системы счисления
+    123
+>>> int(shs1, 16) # Обратное преобразование из шестнадцатеричной системы счисления
+    123
+```
+## 3. Изучение преобразования более сложных базовых типов объектов.
+### 3.1. Преобразование в строку символов.
+Функция str() позволяет преобразовывать переданные ей объекты в строку символов.
+```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']
+>>> spis4=list({"A":1,"B":2,"C":9}.values())  #Преобразование словаря в список по значениям
+>>> spis4
+[1, 2, 9]
+>>> spis5=list({"A":1,"B":2,"C":9}.items())  #Преобразование словаря в список ключи и значения
+>>> spis5
+[('A', 1), ('B', 2), ('C', 9)]
+```
+### 3.3. Преобразование в кортеж.
+Функция tuple() позволяет преобразовывать переданные ей объекты в кортеж.
+```py
+>>> kort7 = tuple("Строка символов") # Преобразование строки символов в кортеж
+>>> kort7
+    ('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8 = tuple(spis2) # Преобразование списка в кортеж
+>>> kort8
+    (124, 236, -15, 908)
+>>> kort9 = tuple({"A" : 1, "B" : 2, "C" : 3}) # Преобразование словаря в кортеж
+>>> kort9
+    ('A', 'B', 'C')
+```
+### 3.4. Удаление объектов.
+С помощью функции del можно удалить объекты из оперативной памяти.
+```py
+>>>del strk5, kort8
+>>>dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+Использую операции с приведением типов на практике
+```py
+>>> fullName = "BezhenarAN"
+>>> spisok = list(fullName) # Преобразование строки символов в список
+>>> spisok
+    ['B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N']
+>>> kortezh = tuple(spisok) # Преобразование списка в кортеж
+>>> kortezh
+    ('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')
+>>> stroka = str(kortezh) # Преобразование кортежа в строку символов
+>>> stroka
+    "('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')"
+```
+## 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 # Деление целых чисел, но результат всё равно вещественное число
+>>> a
+    3.9555555555555557
+>>> type(a)
+    <class 'float'>
+```
+### 4.4. Деление с округлением вниз.
+```py
+>>> b = 178 // 45 # 3.956 округляется вниз, т.е. до 3
+>>> b
+    3
+>>> type(b)
+    <class 'int'>
+>>> c = -24.6 // 12.1 # -2.033 округляется вниз, т.е. до -3
+>>> c
+    -3.0
+>>> type(c)
+    <class 'float'>
+>>> 12 // 6.5
+    1.0
+>>> 12.0 // 5
+    2.0
+```
+### 4.5. Получение остатка от деления.
+```py
+>>> 148 % 33 # Остаток от деления двух целых чисел
+    16
+>>> 12.6 % 3.8 # Остаток от деления двух вещественных чисел
+    1.2000000000000002
+>>> 12 % 6.5
+    5.5
+>>> 12.0 % 5
+    2.0
+```
+### 4.6. Возведение в степень.
+```py
+>>> 14 ** 3 #Целое число возводится в целую степень
+    2744
+>>> e = 2.7 ** 3.6 #Вещественное число возводится в вещественную степень
+>>> e
+    35.719843790663525
+>>> 12 ** 6.5
+    10343751.997175492
+>>> 12.0 ** 5
+    248832.0
+```
+Проведем операции с комплексными числами
+
+```py
+>>> z1 = 1 + 1j
+>>> z2 = 2 + 2j
+>>> z1 + z2
+    (3+3j)
+>>> z1 - z2
+    (-1-1j)
+>>> z1 * z2
+    4j
+>>> z1 / z2
+    (0.5+0j)
+>>> z1 ** 2
+    2j
+>>> z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
+    Traceback (most recent call last):
+      File "<pyshell#115>", line 1, in <module>
+        z1 // 2
+    TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+>>> z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+    Traceback (most recent call last):
+      Fle "<pyshell#116>", line 1, in <module>
+        z1 % z2
+    TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+При проведении арифметических операций над числами разных типов, получается число, имеющее более сложный тип из использованных при его получении.
+
+## 5. Операции с двоичными представлениями целых чисел.
+### 5.1. Двоичная инверсия.
+При использовании двоичной инверсии (~) значение каждого бита в двоичном представлении числа меняется на противоположное.
+```py
+>>> dv1 = 9
+>>> bin(dv1)
+    '0b1001'
+>>> dv2 = ~dv1
+>>> dv2
+    -10
+>>> bin(dv2)
+    '-0b1010'
+```
+### 5.2. Двоичное «И».
+Двоичное «И» - логическое умножение, побитовое совпадение двоичных представлений чисел. 
+```py
+>>> 7 & 9 # 0111 & 1001 = 0001
+    1
+>>> bin(7)
+    '0b111'
+>>> bin(9)
+    '0b1001'
+>>> 7 & 8 # 0111 & 1000 = 0000
+    0
+>>> bin(8)
+    '0b1000'
+```
+### 5.3. Двоичное «ИЛИ».
+Двоичное «ИЛИ» - логическое сложение, побитовое совпадение двоичных представлений чисел, в котором 0 получается, только если оба сравниваемых разряда равны 0.
+```py
+>>> 7 | 9 # 0111 | 1001 = 1111
+    15
+>>> bin(7)
+    '0b111'
+>>> bin(9)
+    '0b1001'
+>>> bin(15)
+    '0b1111'
+>>> 7 | 8 # 0111 | 1000 = 1111
+    15
+>>> bin(8)
+    '0b1000'
+>>> 14 | 5 # 1110 & 0101 = 1111
+    15
+>>> bin(14)
+    '0b1110'
+>>> bin(5)
+    '0b101'
+```
+### 5.4. Двоичное «исключающее ИЛИ».
+Двоичное «исключающее ИЛИ» - побитовое совпадение двоичных представлений чисел, в котором 0 получается, только если оба сравниваемых разряда имеют одинаковые значения.
+```py
+>>> 14 ^ 5 # 1110 ^ 0101 = 1011
+    11
+>>> bin(14)
+    '0b1110'
+>>> bin(5)
+    '0b101'
+>>> bin(11)
+    '0b1011'
+```
+### 5.5. Поразрядный сдвиг.
+Поразрядный сдвиг двоичного представления числа на заданное количество шагов осуществляется с помощью операторов << и >>.
+```py
+>>> h = 14
+>>> bin(h)
+    '0b1110'
+>>> g = h << 2 # Сдвиг на два разряда влево (добавление двух 0 в конец двоичного представления числа)
+>>> g
+     56
+>>> bin(g)
+    '0b111000'
+>>> g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
+>>> bin(g1)
+    '0b111'
+>>> g1
+    7
+>>> g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)
+
+>>> bin(g2)
+    '0b11'
+>>> g2
+    3
+```
+Использование операций с двоичным представлением чисел на практике
+
+```py
+>>> a = 0b111010111
+>>> a
+    471
+>>> b = 0b100100100
+>>> b
+    292
+>>> ~a # Двоичная инверсия
+    -472
+>>> bin(~a)
+    '-0b111011000'
+>>> a & b # Двоичное «И» 
+    260
+>>> bin(a & b)
+    '0b100000100'
+>>> a | b # Двоичное «ИЛИ
+    503
+>>> bin(a | b)
+    '0b111110111'
+>>> a ^ b # Двоичное «исключающее ИЛИ»
+    243
+>>> bin(a ^ b)
+   '0b11110011'
+>>> a >> 3 # Поразрядный сдвиг
+    58
+>>> bin(a >> 3)
+    '0b111010'
+```
+
+## 6. Операции при работе с последовательностями.
+### 6.1. Объединение последовательностей.
+Конкатенация - операция объединения(склеивания) двух и более последовательностей одного типа.
+```py
+>>> "Система " + "регулирования" # Конкатенация двух строк символов
+    'Система регулирования'
+>>> ["abc", "de", "fg"] + ["hi", "jkl"] # Конкатенация двух списков
+    ['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ("abc", "de", "fg") + ("hi", "jkl") # Конкатенация двух кортежей
+    ('abc', 'de', 'fg', 'hi', 'jkl')
+```
+### 6.2. Повторение.
+С помощью оператора * в Python можно повторять объект заданное количество раз.
+```py
+>>> "ля-" * 5 # Повторение строки 5 раз
+    'ля-ля-ля-ля-ля-'
+>>> ["ку", "-"] * 3 # Повторение списка 3 раза
+    ['ку', '-', 'ку', '-', 'ку', '-']
+>>> ("кис", "-") * 4 # Повторение кортежа 4 раза
+    ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1 = [0] * 3 + [1] * 99
+>>> signal1
+    [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+>>> signal2 = (0,) * 3 + (1,) * 5 + (0,) * 7
+>>> signal2
+    (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+### 6.3. Проверка наличия элемента в последовательности.
+Наличие элемента в последовательность можно проверить с помощью оператора in.
+```py
+>>> stroka = "Система автоматического управления"
+>>> "автомат" in stroka # Наличие подстроки в строке
+    True
+>>> "ку" in ["ку", "-"] * 3 # Наличие контекста в списке
+    True
+>>> "ля-" in ("abc", "de", "fg", "hi", "jkl") # Наличие контекста в кортеже
+    False
+```
+### 6.4. Подстановка значений в строку.
+В строку символов можно подставлять заданные значения с помощью оператора %.
+```py
+>>> stroka = "Температура = %g %s %g"
+>>> stroka % (16, "меньше", 25)
+    'Температура = 16 меньше 25'
+>>> stroka = "Температура = %(zn1)g %(sravn)s %(zn2)g"
+>>> stroka % {"zn1" : 16, "sravn" : "меньше", "zn2" : 25}
+    'Температура = 16 меньше 25'
+```
+## 7. Оператор присваивания.
+### 7.1. Обычное присваивание значения переменной.
+Оператор присваивания = позволяет задать определенное значение переменной.
+
+```py
+>>> zz = -12
+>>> zz
+    -12
+```
+### 7.2. Увеличение/уменьшение значения переменной на заданную величину.
+Операторы += и -= позволяют увеличить или уменьшить значение переменной на заданную величину соответственно.
+```py
+>>> zz += 5 # Увеличение значения на 5
+>>> zz
+    -7
+>>> zz -= 3 # Уменьшение значения на 3
+>>> zz
+    -10
+>>> stroka = "Система"
+>>> stroka += " регулирования" # Конкатенация строк символов через оператор +=
+>>> stroka
+    'Система регулирования'
+```
+### 7.3. Умножение/деление значения переменной на заданную величину.
+Операторы /= и *= позволяют разделить или умножить значение переменной на заданную величину соответственно.
+```py
+>>> zz /= 2 # Деление значения на 2
+>>> zz
+    -5.0
+>>> zz *= 5 # Умножение значения на 5
+>>> zz
+    -25.0
+>>> stroka = "ABC "
+>>> stroka *= 3 # Повторение строки символов 3 раза
+>>> stroka
+    'ABC ABC ABC '
+```
+### 7.4. Дополнительные сокращенные арифметические операции.
+В Python также существуют дополнительные сокращенные арифметические операции:
+
+// - целочисленное деление,
+% - получение остатка от деления,
+** - возведение в степень.
+```py
+>>> a = 14
+>>> a //= 5 # Целочисленное деление
+>>> a
+    2
+>>> b = 13
+>>> b %= 6 # Получение остатка от деления
+>>> b
+    1
+>>> c = 2
+>>> c **= 4 # Возведение в степень
+>>> c
+    16
+```
+### 7.5. Множественное присваивание.
+Присваивать определенные значения можно сразу нескольким переменным за раз.
+```py
+>>> w = v = 10
+>>> w, v
+    (10, 10)
+>>> n1, n2, n3 = (11, -3, "all")
+>>> n1, n2, n3
+    (11, -3, 'all')
+>>> n1, n2, n3 = "11 -3 all".split(" ") #строка
+>>> n1, n2, n3
+    ('11', '-3', 'all')
+>>> n1, n2, n3 = [11, -3, "all"]
+>>> n1, n2, n3
+    (11, -3, 'all')
+>>> n1, n2, n3 = {1 : 11, 2 : -3, 3 : "all"}
+>>> n1, n2, n3
+    (1, 2, 3)
+>>> n1, n2, n3 = {11, -3, "all"}
+>>> n1, n2, n3
+    (11, 'all', -3)
+```
+## 8.Логические операции.
+### 8.1. Основные логические операции.
+```py
+>>> w == v # Операция равенства
+    True
+>>> w != v # Операция неравенства
+    False
+>>> w += 1
+>>> w < v # Операция меньше
+    True
+>>> w > v # Операция больше
+    False
+>>> w <= v # Операция меньше или равно
+    True
+>>> w >= v # Операция больше или равно
+    False
+```
+### 8.2. Проверка наличия элемента в последовательности или сложном объекте.
+Наличие элемента в сложном объекте также можно проверить с помощью оператора in. 
+```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. Создание больших логических выражений.
+С помощью соединительных слов and, or и not можно создавать большие логические выражения.
+```py
+>>> a = 17
+>>> b = -6
+>>> (a >= b) and ("book" in mnoz1) and not ("Pskov" in dic1)
+    True
+>>> (a % 2 == 1) and (("cap" in mnoz1) or (145 in dic1.values()))
+    False
+>>> not (b < 0) or (len(mnoz1)== 4)
+    True
+```
+### 8.4. Ссылки переменных на один и тот же объект.
+Сравнивать ссылки на объект можно с помощью оператора is.
+```py
+>>> w = v = 10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+>>> w is v
+    True
+>>> w1 = ["A", "B"]
+>>> v1 = ["A", "B"]
+>>> w1 is v1
+    False
+```
+В последнем случае результатом сравнения является False, т.к. переменные создавались по отдельности, хоть их знаечния и полностью совпадают, а значит они хранятся в разных ячейках память, следовательно ссылки на них будут разными.
+
+## 9. Изучение методов объектов.
+### 9.1. Методы для работы со строками.
+Для работы со строками существуют различные методы, использование которых рассмотрено ниже.
+```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']
+
+>>> stroka.find("пр") # Поиск первого вхождения подстроки в строку(Возвращает номер позиции первого вхождения указанного контекста или значение -1)
+    5
+>>> stroka.count("с") # Подсчет вхождений подстроки в строку
+    4
+>>> stroka.replace(" у", " автоматического у") # Замена всех вхождений подстроки в строку
+    'Микропроцессорная система автоматического управления'
+>>> spis22 = stroka.split(" ") # Разделение строки на список подстрок по определенному разделителю
+>>> spis22
+    ['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper() # Перевод строки в верхний регистр
+    'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3 = " ".join(spis22) # Создание строки из списка построк с некоторым разделителем
+>>> stroka3
+    'Микропроцессорная система управления'
+>>> stroka3.partition("с") # Создание кортежа с результатом первого вхождения подстроки  в строку
+    ('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с") # Создание кортежа с результатом последнего вхождения подстроки  в строку
+    ('Микропроцессорная си', 'с', 'тема управления')
+```
+Метод format() используется для форматирования строк по следующему принципу:
+
+1. Если в форматированной строке не указан порядок вставки элементов, то они войдут в неё в порядке их передачи в метод,
+2. Если в форматированной строке указан порядок вставки элементов, то они войдут в неё в с таким же порядком,
+3. Если в форматированной строке поименно указаны позиции вставки элементов, то они войдут в неё в соответствии с ними.
+```py
+>>> strk1 = "Момент времени {}, значение {}"
+>>> strk1.format(1, 89.7) # Случай 1
+    'Момент времени 1, значение 89.7'
+>>> strk2 = "Момент времени {1}, значение = {0} : {2}"
+>>> strk2.format(36.7, 2, "норма") # Случай 2
+    'Момент времени 2, значение = 36.7 : норма'
+>>> strk3 = "Момент времени {num}, значение = {znch}"
+>>> strk3.format(znch = 89.7, num = 2) # Случай 3
+    'Момент времени 2, значение = 89.7'
+```
+### 9.2. Методы для работы со списками.
+Для работы со списками тоже существуют различные методы, принцип работы которых представлен ниже.
+```py
+>>> spsk = [1, 2, 3, 4, 5, 6]
+>>> spsk.pop(2) # Удаление элемента по индексу из списка, с возвращением его значения
+    3
+>>> spsk
+    [1, 2, 4, 5, 6, 7]
+>>> spsk.append("c") # Добавление элемента в конец списка
+>>> spsk
+    [1, 2, 4, 5, 6, 7, 'c']
+>>> spsk.insert(2, "a") # Добавление элемента на определенную позицию в списке
+>>> spsk
+    [1, 2, 'a', 4, 5, 6, 7, 'c']
+>>> spsk.count("a") # Подсчет количества соответствующих элементов в списке
+    1
+```
+### 9.3. Методы для работы с кортежами.
+Для работы с кортежами существует два основных метода, применение которых представлено ниже.
+```py
+>>> kortezh = (1, 2, 3, 4, 5, 6, 7)
+>>> dir(kortezh)
+    ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+>>> kortezh.count(3) # Подсчет количества соответствующих элементов в кортеже
+    1
+>>> kortezh.index(2) # Вычисление индекса переданного элемента, если он есть в кортеже
+    1
+```
+### 9.4. Методы для работы с словарями и множествами.
+Методы для работы со словарями рассмотрены в примере ниже.
+```py
+>>> dictionary = {"A" : 1, "B" : 2, "C" : 3, "D" : 4, "E" : 5}
+>>> dictionary.get("D") # Получение значения из словаря по соответствующему ему ключу
+    4
+>>> dictionary.items() # Получение списка кортежей всех пар ключ-значений в словаре
+    dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5)])
+>>> dictionary.keys() # Получение списка всех ключей в словаре
+    dict_keys(['A', 'B', 'C', 'D', 'E'])
+>>> dictionary.values() # Получение списка всех значений в словаре
+    dict_values([1, 2, 3, 4, 5])
+>>> dictionary.pop("C") # Удаление определенной пары ключ-значение из словаря по переданному ключу
+    3
+>>> dictionary
+    {'A': 1, 'B': 2, 'D': 4, 'E': 5}
+>>> dictionary.popitem() # Удаление последней пары ключ-значение из словаря
+    ('E', 5)
+>>> dictionary
+    {'A': 1, 'B': 2, 'D': 4}
+>>> dictionary.update({"A" : 5}) # Обновление словаря новыми значениями
+>>> dictionary
+    {'A': 5, 'B': 2, 'D': 4}
+>>> dictionary.clear() # Очистка словаря
+>>> dictionary
+    {}
+```
+Методы для работы с множествами отчасти схожи с методами словарей, однако среди них также есть и уникальные методы.
+```py
+>>> mnozhestvo = {"Apple", "Orange", "Peach", "Pear"}
+>>> mnozhestvo.add("Banana") # Добавление элемента в множество
+>>> mnozhestvo
+    {'Apple', 'Orange', 'Peach', 'Banana', 'Pear'}
+>>> mnozhestvo2 = mnozhestvo.copy() # Копирование множества
+>>> mnozhestvo2
+    {'Apple', 'Peach', 'Orange', 'Banana', 'Pear'}
+>>> mnozhestvo2.remove("Apple") # Удаление элемента из множества
+>>> mnozhestvo2
+    {'Peach', 'Orange', 'Banana', 'Pear'}
+>>> mnozhestvo.difference(mnozhestvo2) # Сравнение двух множеств по содержимому, возвращает разницу
+    {'Apple'}
+>>> mnozhestvo2.clear() # Очистка множества
+>>> mnozhestvo2
+    set()
+```
+## 10.Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончила сеанс работы с IDLE.
+
+

TEMA3/report.py

@@ -0,0 +1,481 @@
+#Протокол по ТЕМЕ 3 Беженарь Алёна Николаевна
+import os
+os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA3")
+logiz1 = bool(56) # Любое целое число, кроме 0, преобразуется в True
+logiz1
+True
+logiz2 = bool(0) # 0 преобразуется в False
+logiz2
+False
+logiz3 = bool("Beta") # Непустая строка преобразуется в True
+logiz3
+True
+logiz4 = bool("") # Пустая строка преобразуется в False
+logiz4
+False
+tt1 = int(198.9) # Отбрасывается дробная часть
+tt1
+198
+tt2 = int("-76") # Число – в строке символов, система по умолчанию - десятичная
+tt2
+-76
+tt3 = int("B", 16) # Число в шестнадцатеричной системе счисления
+tt3
+11
+tt4 = int("71", 8) # Число в восьмеричной системе счисления
+tt4
+57
+tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    tt5 = int("98.76") # Число, передающееся в виде строки, должно быть целым(int останавливается на первом не-цифровом символе)
+ValueError: invalid literal for int() with base 10: '98.76'
+flt1 = float(789) # Преобразование целого числа в вещественное
+flt1
+789.0
+flt2 = float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity") # В функцию float() можно передавать строки со значениями inf и NaN
+flt3
+inf
+flt4 = float("-inf") # Значения inf и NaN являются нерегистрочувствительными
+flt4
+-inf
+hh=123
+dv1=bin(hh)
+dv1
+'0b1111011'
+vos1 = oct(hh)
+vos1
+'0o173'
+shs1 = hex(hh)
+shs1
+'0x7b'
+int(dv1, 2) # Обратное преобразование из двоичной системы счисления
+123
+int(vos1, 8) # Обратное преобразование из восьмеричной системы счисления
+123
+int(shs1, 16) # Обратное преобразование из шестнадцатеричной системы счисления
+123
+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}"
+spis1 = list("Строка символов") # Преобразование строки символов в список
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2 = list((124, 236, -15, 908)) # Преобразование кортежа в список
+spis2
+[124, 236, -15, 908]
+spis3 = list({"A" : 1, "B" : 2, "C" : 9}) # Преобразование словаря в список
+spis3
+['A', 'B', 'C']
+spis4=list({"A":1,"B":2,"C":9}.values())  #Преобразование словаря в список по значениям
+spis4
+[1, 2, 9]
+spis5=list({"A":1,"B":2,"C":9}.items())  #Преобразование словаря в список ключи и значения
+spis5
+[('A', 1), ('B', 2), ('C', 9)]
+kort7 = tuple("Строка символов") # Преобразование строки символов в кортеж
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8 = tuple(spis2) # Преобразование списка в кортеж
+kort8
+(124, 236, -15, 908)
+kort9 = tuple({"A" : 1, "B" : 2, "C" : 3}) # Преобразование словаря в кортеж
+kort9
+('A', 'B', 'C')
+del strk5, kort8
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+fullName = "BezhenarAN"
+spisok = list(fullName) # Преобразование строки символов в список
+spisok
+['B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N']
+kortezh = tuple(spisok) # Преобразование списка в кортеж
+kortezh
+('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')
+stroka = str(kortezh) # Преобразование кортежа в строку символов
+stroka
+"('B', 'e', 'z', 'h', 'e', 'n', 'a', 'r', 'A', 'N')"
+12+7+90 # Сложение целых чисел
+109
+5.689e-1 - 0.456 # Вычитание вещественных чисел
+0.11289999999999994
+23.6 + 54 # Сложение вещественного и целого чисел
+77.6
+14 - 56.7 + 89 # Сложение и вычитание целых и вещественных чисел
+46.3
+-6.7 * 12 # Умножение вещественного и целого чисел
+-80.4
+-234.5 / 6 # Деление вещественного и целого чисел
+-39.083333333333336
+a = 178 / 45 # Деление целых чисел, но результат всё равно вещественное число
+a
+3.9555555555555557
+type(a)
+<class 'float'>
+b = 178 // 45 # 3.956 округляется вниз, т.е. до 3
+b
+3
+type(b)
+<class 'int'>
+c = -24.6 // 12.1 # -2.033 округляется вниз, т.е. до -3
+c
+-3.0
+type(c)
+<class 'float'>
+12 // 6.5
+1.0
+12.0 // 5
+2.0
+148 % 33 # Остаток от деления двух целых чисел
+16
+12.6 % 3.8 # Остаток от деления двух вещественных чисел
+1.2000000000000002
+12 % 6.5
+5.5
+12.0 % 5
+2.0
+14 ** 3 #Целое число возводится в целую степень
+2744
+e = 2.7 ** 3.6 #Вещественное число возводится в вещественную степень
+e
+35.719843790663525
+12 ** 6.5
+10343751.997175492
+12.0 ** 5
+248832.0
+z1 = 1 + 1j
+z2 = 2 + 2j
+z1 + z2
+(3+3j)
+z1 - z2
+(-1-1j)
+z1 * z2
+4j
+z1 / z2
+(0.5+0j)
+z1 ** 2
+2j
+z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
+Traceback (most recent call last):
+  File "<pyshell#108>", line 1, in <module>
+    z1 // 2 # Операция целочисленного деления неприменима к комплексным числам
+TypeError: unsupported operand type(s) for //: 'complex' and 'int'
+z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    z1 % z2 # Операция получения остатка от деления также неприменима к комплексным числам
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+dv1 = 9
+bin(dv1)
+'0b1001'
+dv2 = ~dv1
+dv2
+-10
+bin(dv2)
+'-0b1010'
+7 & 9 # 0111 & 1001 = 0001
+1
+bin(7)
+'0b111'
+bin(9)
+'0b1001'
+7 & 8 # 0111 & 1000 = 0000
+0
+bin(8)
+'0b1000'
+7 | 9 # 0111 | 1001 = 1111
+15
+bin(7)
+'0b111'
+bin(9)
+'0b1001'
+bin(15)
+'0b1111'
+7 | 8 # 0111 | 1000 = 1111
+15
+bin(8)
+'0b1000'
+14 | 5 # 1110 & 0101 = 1111
+15
+bin(14)
+'0b1110'
+bin(5)
+'0b101'
+14 ^ 5 # 1110 ^ 0101 = 1011
+11
+bin(14)
+'0b1110'
+bin(5)
+'0b101'
+bin(11)
+'0b1011'
+h = 14
+bin(h)
+'0b1110'
+g = h << 2
+g
+56
+bin(g)
+'0b111000'
+g1 = h >> 1 # Сдвиг на один разряд вправо (удаление первой цифры двоичного представления числа)
+bin(g1)
+'0b111'
+g1
+7
+g2 = h >> 2 # Сдвиг на два разряда вправо (удаление двух первых цифр двоичного представления числа)
+bin(g2)
+'0b11'
+g2
+3
+a = 0b111010111
+a
+471
+b = 0b100100100
+b
+292
+~a # Двоичная инверсия
+-472
+bin(~a)
+'-0b111011000'
+a & b # Двоичное «И»
+260
+bin(a & b)
+'0b100000100'
+a | b # Двоичное «ИЛИ
+503
+bin(a | b)
+'0b111110111'
+a ^ b # Двоичное «исключающее ИЛИ»
+243
+bin(a ^ b)
+'0b11110011'
+a >> 3 # Поразрядный сдвиг
+58
+bin(a >> 3)
+'0b111010'
+"Система " + "регулирования" # Конкатенация двух строк символов
+'Система регулирования'
+["abc", "de", "fg"] + ["hi", "jkl"] # Конкатенация двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+("abc", "de", "fg") + ("hi", "jkl") # Конкатенация двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+### 6.2. Повторение.
+"ля-" * 5 # Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+["ку", "-"] * 3 # Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+("кис", "-") * 4 # Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1 = [0] * 3 + [1] * 99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2 = (0,) * 3 + (1,) * 5 + (0,) * 7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+stroka = "Система автоматического управления"
+"автомат" in stroka # Наличие подстроки в строке
+True
+"ку" in ["ку", "-"] * 3 # Наличие контекста в списке
+True
+"ля-" in ("abc", "de", "fg", "hi", "jkl") # Наличие контекста в кортеже
+False
+stroka = "Температура = %g %s %g"
+stroka % (16, "меньше", 25)
+'Температура = 16 меньше 25'
+stroka = "Температура = %(zn1)g %(sravn)s %(zn2)g"
+stroka % {"zn1" : 16, "sravn" : "меньше", "zn2" : 25}
+'Температура = 16 меньше 25'
+zz = -12
+zz
+-12
+zz += 5 # Увеличение значения на 5
+zz
+-7
+zz -= 3 # Уменьшение значения на 3
+zz
+-10
+stroka = "Система"
+stroka += " регулирования" # Конкатенация строк символов через оператор +=
+stroka
+'Система регулирования'
+zz /= 2 # Деление значения на 2
+zz
+-5.0
+zz *= 5 # Умножение значения на 5
+zz
+-25.0
+stroka = "ABC "
+stroka *= 3 # Повторение строки символов 3 раза
+stroka
+'ABC ABC ABC '
+a = 14
+a //= 5 # Целочисленное деление
+a
+2
+b = 13
+b %= 6 # Получение остатка от деления
+b
+1
+c = 2
+c **= 4 # Возведение в степень
+c
+16
+w = v = 10
+w,v
+(10, 10)
+n1, n2, n3 = (11, -3, "all")
+n1,n2,n3
+(11, -3, 'all')
+n1, n2, n3 = "11 -3 all".split(" ") #строка
+n1, n2, n3
+('11', '-3', 'all')
+n1, n2, n3 = [11, -3, "all"]
+n1, n2, n3
+(11, -3, 'all')
+n1, n2, n3 = {1 : 11, 2 : -3, 3 : "all"}
+n1, n2, n3
+(1, 2, 3)
+n1, n2, n3 = {11, -3, "all"}
+n1, n2, n3
+('all', 11, -3)
+w == v # Операция равенства
+True
+w != v # Операция неравенства
+False
+v += 1
+w < v # Операция меньше
+True
+w > v # Операция больше
+False
+w <= v # Операция меньше или равно
+True
+w >= v # Операция больше или равно
+False
+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
+a = 17
+b = -6
+(a >= b) and ("book" in mnoz1) and not ("Pskov" in dic1)
+True
+(a % 3 == 1) and (("cap" in mnoz1) or (45 in dic1.values()))
+False
+not (b < 0) or (len(mnoz1)== 4)
+True
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+True
+w1 = ["A", "B"]
+v1 = ["A", "B"]
+w1 is v1
+False
+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']
+stroka.find("пр") # Поиск первого вхождения подстроки в строку
+5
+stroka.count("с") # Подсчет вхождений подстроки в строку
+4
+stroka.replace(" у", " автоматического у") # Замена всех вхождений подстроки в строку
+'Микропроцессорная система автоматического управления'
+spis22 = stroka.split(" ") # Разделение строки на список подстрок по определенному разделителю
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper() # Перевод строки в верхний регистр
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3 = " ".join(spis22) # Создание строки из списка построк с некоторым разделителем
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с") # Создание кортежа с результатом первого вхождения подстроки  в строку
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с") # Создание кортежа с результатом последнего вхождения подстроки  в строку
+('Микропроцессорная си', 'с', 'тема управления')
+strk1 = "Момент времени {}, значение {}"
+strk1.format(1, 89.7) # Случай 1
+'Момент времени 1, значение 89.7'
+strk2 = "Момент времени {1}, значение = {0} : {2}"
+strk2.format(36.7, 2, "норма") # Случай 2
+'Момент времени 2, значение = 36.7 : норма'
+strk3 = "Момент времени {num}, значение = {znch}"
+strk3.format(znch = 89.7, num = 2) # Случай 3
+'Момент времени 2, значение = 89.7'
+spsk = [1, 2, 3, 4, 5, 6]
+spsk.pop(2) # Удаление элемента по индексу из списка, с возвращением его значения 3
+3
+spsk
+[1, 2, 4, 5, 6]
+kortezh = (1, 2, 3, 4, 5, 6, 7)
+dir(kortezh)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
+kortezh.count(3) # Подсчет количества соответствующих элементов в кортеже
+1
+kortezh.index(2) # Вычисление индекса переданного элемента, если он есть в кортеже
+1
+dictionary = {"A" : 1, "B" : 2, "C" : 3, "D" : 4, "E" : 5}
+dictionary.get("D") # Получение значения из словаря по соответствующему ему ключу
+4
+dictionary.items() # Получение списка кортежей всех пар ключ-значений в словаре
+dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 5)])
+dictionary.keys() # Получение списка всех ключей в словаре
+dict_keys(['A', 'B', 'C', 'D', 'E'])
+dictionary.values() # Получение списка всех значений в словаре
+dict_values([1, 2, 3, 4, 5])
+dictionary.pop("C") # Удаление определенной пары ключ-значение из словаря по переданному ключу
+3
+dictionary
+{'A': 1, 'B': 2, 'D': 4, 'E': 5}
+dictionary.popitem() # Удаление последней пары ключ-значение из словаря
+('E', 5)
+dictionary
+{'A': 1, 'B': 2, 'D': 4}
+dictionary.update({"A" : 5}) # Обновление словаря новыми значениями
+dictionary
+
+{'A': 5, 'B': 2, 'D': 4}
+dictionary.clear() # Очистка словаря
+dictionary
+{}
+mnozhestvo = {"Apple", "Orange", "Peach", "Pear"}
+mnozhestvo.add("Banana") # Добавление элемента в множество
+mnozhestvo
+{'Orange', 'Pear', 'Peach', 'Banana', 'Apple'}
+mnozhestvo2 = mnozhestvo.copy() # Копирование множества
+mnozhestvo2
+{'Orange', 'Pear', 'Peach', 'Banana', 'Apple'}
+mnozhestvo2.remove("Apple") # Удаление элемента из множества
+mnozhestvo2
+{'Orange', 'Pear', 'Peach', 'Banana'}
+mnozhestvo.difference(mnozhestvo2) # Сравнение двух множеств по содержимому, возвращает разницу
+{'Apple'}
+mnozhestvo2.clear() # Очистка множества
+mnozhestvo2
+set()

TEMA3/task.md

@@ -0,0 +1,54 @@
+# Общее контрольное задание по теме 3
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Преобразовать восьмеричное значение 45 в целое число.
+* Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+* Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+* Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+* Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+* Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+* Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+
+## Решение
+
+```py
+>>> znch = int("45", 8) #1 пункт
+>>> znch
+    37
+>>> D = {"усиление" : 23, "запаздывание" : 12, "постоянная времени" : 78} #2 пункт
+>>> D_keys, D_values = list(D.keys()), list(D.values())
+>>> D_keys
+    ['усиление', 'запаздывание', 'постоянная времени']
+>>> D_values
+    [23, 12, 78]
+>>> D_tuple = tuple(zip(D_keys, D_values)) # Кортеж, в отличие от списка, является неизменяемым объектом 
+>>> D_tuple
+    (('усиление', 23), ('запаздывание', 12), ('постоянная времени', 78))
+>>> ((1768 // 24.8) % 3) ** 2.4 #3 пункт
+    5.278031643091577
+>>> (~(13 & 27) ^ 14) << 2 #4 пункт
+    -32
+>>> list1 = ["колебат",] * 4 #5 пункт
+>>> list1
+    ['колебат', 'колебат', 'колебат', 'колебат']
+>>> "аткол" in list1[1] + list1[2]
+    True
+>>> dir(D) #6 пункт
+    ['__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]) # Список значений словаря
+>>> string = "Создать объект - символьную строку с текстом данного предложения." #7 пункт
+>>> string_list = string.split(" ")
+>>> string_list[string_list.index("-")] = ","
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
+>>> string_list.remove("данного")
+>>> string_list
+    ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
+```

TEMA3/test.md

@@ -0,0 +1,85 @@
+# Тест по модулю 1. Вариант 9
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+1)	В каком месте инструкции и как можно написать комментарий?
+
+2)	Создайте объект-список с 10 элементами - русскоязычными названиями продуктов. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Удалите из списка 5 и 6 элементы, считая от первого. Определите число оставшихся элементов. Замените 4-й элемент на "трюфель". Отобразите получившийся объект.
+
+4)	Преобразуйте список в кортеж. Отобразите полученный объект. Создайте новый кортеж с удалением из ранее созданного кортежа элемента "трюфель".
+
+5)	Напишите инструкцию проверки наличия в списке элемента "молоко". Если его нет в списке, добавьте его туда, иначе - удалите его из списка.
+
+## Решение
+
+### Пункт 1
+
+В каком месте инструкции и как можно написать комментарий?
+
+### Ответ
+
+Комментарий можно написать после инструкции, но обязательно после символа #. 
+Всё что будет после этого символа до конца строки будет считаться комментарием. Если же написать символ # перед инструкцией, то при запуске на выполнение она не выполнится. 
+Также частой практикой является написание комментария на строке выше(перед инструкцией, но не на одной с ней строках).
+
+### Пункт 2
+
+Создайте объект-список с 10 элементами - русскоязычными названиями продуктов. 
+Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+
+```py
+>>> spisok=["огурец", "сыр", "хлеб", "сухарики", "лосось", "лук", "сметана", "молоко", "колбаса", "шоколад"]
+>>> type(spisok)
+    <class 'list'>
+>>> dir(spisok)
+    ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+```
+
+### Пункт 3
+
+Удалите из списка 5 и 6 элементы, считая от первого. Определите число оставшихся элементов. Замените 4-й элемент на "трюфель". Отобразите получившийся объект.
+
+
+```py
+>>> spisok.remove(spisok[5]) #удаляем 6 элемент(spisok[5] т.к. нумерация индексов начинается с 0)
+>>> spisok.remove(spisok[4]) #удаляем 5 элемент(spisok[4] т.к. нумерация индексов начинается с 0) 
+>>> spisok #Убеждаемся в том, что удалили 5 и 6 элементы (лосось и лук)
+    ['огурец', 'сыр', 'хлеб', 'сухарики', 'сметана', 'молоко', 'колбаса', 'шоколад']
+>>> len(spisok) #определяем кол-во оставшихся элементов
+    8
+>>> spisok[3] = "трюфель" #Меняем 4 элемент списка на "трюфель"
+>>> spisok #Отображаем получившийся объект и убеждаемся в изменении
+    ['огурец', 'сыр', 'хлеб', 'трюфель', 'сметана', 'молоко', 'колбаса', 'шоколад']
+```
+
+### Пункт 4
+
+Преобразуйте список в кортеж. Отобразите полученный объект. Создайте новый кортеж с удалением из ранее созданного кортежа элемента "трюфель".
+
+
+```py
+>>> kortez = tuple(spisok) #Преобразуем список в кортеж
+>>> kortez
+    ('огурец', 'сыр', 'хлеб', 'трюфель', 'сметана', 'молоко', 'колбаса', 'шоколад')
+>>> new_kortez=kortez[0:3]+kortez[4:] #Т.к. кортеж неизменяем, то создаем новый кортеж без трюфеля путем переопределения кортежа(берем все элементы кроме трюфеля)
+>>> new_kortez
+    ('огурец', 'сыр', 'хлеб', 'сметана', 'молоко', 'колбаса', 'шоколад')
+
+```
+
+### Пункт 5
+
+Напишите инструкцию проверки наличия в списке элемента "молоко". Если его нет в списке, добавьте его туда, иначе - удалите его из списка.
+
+```py
+>>> "молоко" in spisok #Проверяем наличие в списке элемента "молоко"
+    True
+>>> spisok.remove("молоко") #Удаляем элемент молоко, т.к. результатом прошлой инструкции было True, а значит молоко есть и его по условию задания надо удалить 
+>>> spisok
+    ['огурец', 'сыр', 'хлеб', 'трюфель', 'сметана', 'колбаса', 'шоколад']
+```

TEMA4/report.md

@@ -0,0 +1,299 @@
+# Отчет по Теме 4
+
+Беженарь Алёна, А-02-23
+
+# Встроенные функции языка Python.
+
+## 1. Настройка текущего каталога.
+```py
+import os
+os.chdir("C:\\Users\\Дружок\\Desktop\\ПОАС\\python-labs\\TEMA4")
+```
+## 2. Стандартные функции.
+### 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
+>>> round(123.456,0)
+    123.0
+>>> type(round(123.456,0))
+    <class 'float'>
+>>> type(round(123.456,1))
+    <class 'float'>
+>>> round(123.456)
+    123
+>>> type(round(123.456))
+    <class 'int'>
+```
+### 2.2.Функция создания последовательности целых чисел с заданным шагом range().
+```py
+>>> gg=range(76,123,9)
+>>> gg
+    range(76, 123, 9)
+>>> type(gg)
+    <class 'range'>
+>>> list(gg)
+    [76, 85, 94, 103, 112, 121]
+>>> range(23)
+    range(0, 23) #range(23) создает последовательность целых чисел от 0 до 22 с шагом 1
+>>> 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().
+```py
+>>> qq = ["Беженарь", "Володин", "Степанов", "Киреев"]
+>>> ff = zip(gg,qq)
+>>> ff
+    <zip object at 0x0000021877EA6D80>
+>>> tuple(ff)
+    ((76, 'Беженарь'), (85, 'Володин'), (94, 'Степанов'), (103, 'Киреев'))
+>>> ff[1] # К "итерируему объекту" класса zip нельзя обратиться по индексу
+    Traceback (most recent call last):
+      File "<pyshell#5>", line 1, in <module>
+        ff[1]
+    TypeError: 'zip' object is not subscriptable
+
+```
+Важно заметить, что длина результирующего объекта равна длине самого короткого объекта из переданных функции.
+### 2.4. Функция вычисляющая значения выражения, корректно записанного на языке Python и представленного в виде символьной строки eval().
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+    коэффициент усиления=25
+>>> dan
+    -31.0
+```
+### 2.5. Похожая на eval() функция чтения и выполнения объекта-аргумента функции exec(). 
+```py
+>>> exec(input('введите инструкции:'))
+    введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+>>> gg
+    221.456
+>>> type(gg)
+    <class 'float'>
+```
+### 2.6.
+```py
+>>> abs(-100) # Получение модуля числа
+    100
+>>> pow(2, 5) # Возведение чисда в степень
+    32
+>>> max(1, 2, 3, 10) # Получение максимального числа из переданной последовательности
+    10
+>>> min(1, 2, 3, 10) # Получение минимального числа из переданной последовательности
+    1
+>>> sum([1, 2, 3, 10]) # Суммирование элементов переданной последовательности
+    16
+>>> divmod(11, 4) # Получение кортежа с двумя элементами: результатами целочисленного деления и деления с остатком
+    (2, 3)
+>>> len([1, 2, 3, 10])
+    4
+>>> def cube(x):
+...     return x ** 2
+...
+>>> map(cube, [1, 2, 3, 10]) # Применение заданной функции ко всем элементам переданной последовательности
+    <map object at 0x000002187A7EB7C0>
+>>> list(map(cube, [1, 2, 3, 10]))
+    [1, 8, 27, 1000]
+```
+## 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', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+    Help on built-in function factorial in module math:
+
+    factorial(n, /)
+        Find n!.
+    
+        Raise a ValueError if x is negative or non-integral.
+>>> math.factorial(5) # Расчет  факториала числа
+    120
+>>> math.sin(math.pi / 6) # Расчет синуса числа
+    0.49999999999999994
+>>> math.acos(0.5) * 180 / math.pi # Расчет арккосинуса числа
+    60.00000000000001
+>>> math.degrees(math.pi / 6) # Перевод угла в радианах в градусы
+    29.999999999999996
+>>> math.radians(60) # Перевод угла в градусах в радианы
+    1.0471975511965976
+>>> math.exp(2) # Возведение числа Эйлера в определенную степень
+    7.38905609893065
+>>> math.log(8, 2) # Вычисление логарифма с определенным основанием
+    3.0
+>>> math.log10(100) # Вычисление десятичного логарифма
+    2.0
+>>> math.sqrt(64) # Вычисление квадратного корня
+    8.0
+>>> math.ceil(4.25) # Округление в большую сторону
+    5
+>>> math.floor(4.25) # Округление в меньшую сторону
+    4
+```
+С помощью функций из модуля math можно вычислять значения сложных математических выражений:
+```py
+>>> math.sin(2 * math.pi / 7 + math.exp(0.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', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> help(random.seed)
+    Help on method seed in module random:
+
+    seed(a=None, version=2) method of random.Random instance
+        Initialize internal state from a seed.
+    
+        The only supported seed types are None, int, float,
+        str, bytes, and bytearray.
+    
+        None or no argument seeds from current time or from an operating
+        system specific randomness source if available.
+    
+        If *a* is an int, all bits are used.
+    
+        For version 2 (the default), all of the bits are used if *a* is a str,
+        bytes, or bytearray.  For version 1 (provided for reproducing random
+        sequences from older versions of Python), the algorithm for str and
+        bytes generates a narrower range of seeds.
+>>> random.seed() #задает случайное начальное состояние для псевдослучайных чисел
+>>> random.random() # Равномерно распределенное случайное число
+    0.3956737606722922
+>>> random.uniform(1, 2) # Равномерно распределенное случайное число
+    1.2506275428676115
+>>> random.randint(5, 6) # Случайное целое число
+    5
+>>> random.gauss(5, 0.2) # Нормально распределенное случайное число
+    4.575306564580744
+>>> random.choice(["Apple", "Orange", "Pear"]) # Случайный выбор элемента из совокупности
+    'Orange'
+>>> fruits = ["Apple", "Orange", "Pear"]
+>>> random.shuffle(fruits) # Перемешивание элементов списка
+>>> fruits
+    ['Pear', 'Orange', 'Apple']
+>>> random.sample(fruits, 2) # Получение выборки заданной размерности из совокупности
+    ['Orange', 'Apple']
+>>> random.betavariate(1, 2) # Случайное число с бета-распределением
+    0.5112342600587575
+>>> random.gammavariate(1, 2) # Случайное число с гамма-распределением
+    0.2940579511803219
+```
+Создала список с 4 случайными значениями, подчиняющимися равномерному, нормальному, бета и гамма - рапределениям соответственно:
+```py
+>>> [random.uniform(1, 5), random.gauss(2, 1), random.betavariate(1, 2), random.gammavariate(1, 2)]
+    [1.073448712376535, 1.410859882433433, 0.3802040796620913, 1.1399302392050947]
+```
+## 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']
+>>> c1=time.time() # Время в секундах, прошедшее с начала эпохи 1.1.1970
+>>> c1
+    1760782789.2863443
+>>> c2=time.time()-c1 # Получение времени со ввода предыдущей команды
+>>> c2
+    50.22490692138672
+>>> dat=time.gmtime() # Получение полной информации о текущем времени
+>>> dat
+    time.struct_time(tm_year=2025, tm_mon=10, tm_mday=18, tm_hour=10, tm_min=21, tm_sec=13, tm_wday=5, tm_yday=291, tm_isdst=0)
+>>> dat.tm_mon # Получение текущего месяца
+    10
+>>> dat.tm_hour # Получение текущего часа
+    10
+>>> datLocal = time.localtime() # Получение полной информации о текущем "местном" времени
+>>> datLocal
+    time.struct_time(tm_year=2025, tm_mon=10, tm_mday=18, tm_hour=13, tm_min=24, tm_sec=48, tm_wday=5, tm_yday=291, tm_isdst=0)
+>>> time.asctime(datLocal) # Преобразование представления времени из кортежа в строку
+    'Sat Oct 11 18:16:38 2025'
+>>> time.ctime(c1) # Преобразование времени в секундах, прошедшего с начала эпохи, в строку
+    'Sat Oct 18 13:19:49 2025'
+>>> time.sleep(10) # Прерывание работы программы на заданное количество секунд
+>>> time.mktime(datLocal) # Преобразование времени из кортежа или структуры в число секунд с начала эпохи
+    1760783088.0
+```
+## 7. Графические функции.
+```py
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> t=list(range(15))
+>>> pylab.plot(t,x)  #Создание графика в оперативной памяти
+    [<matplotlib.lines.Line2D object at 0x000001BA5FA0BFD0>]
+>>> pylab.title('Первый график') # Добавление названия графика
+    Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время') # Добавление названия оси абсцисс
+    Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал') # Добавление названия оси ординат
+    Text(0, 0.5, 'сигнал')
+>>> pylab.show() #Отображение графика на экране
+```
+
+![Первый график](pictures/Ris1.png)
+
+На одном рисунке можно отобразить несколько графиков:
+
+![Второй график](pictures/Ris4.png)
+
+Также данный модуль дает возможность строить круговые и столбиковые диаграммы и гистограммы.
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  #Метки для диаграммы
+>>> naselen=[65,12,23,17]  # Значения для диаграммы
+>>> pylab.pie(naselen,labels=region) #Создание диаграммы в памяти
+    ([<matplotlib.patches.Wedge object at 0x000001BA60C673D0>, <matplotlib.patches.Wedge object at 0x000001BA60D255D0>, <matplotlib.patches.Wedge object at 0x000001BA60D40410>, <matplotlib.patches.Wedge object at 0x000001BA60D41950>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()  #Отображение диаграммы
+```
+
+![Третий график](pictures/Ris2.png)
+
+```py
+>>> pylab.hist([1, 2, 3, 1, 1, 2, 2, 2, 2], bins = 3)                          
+    (array([3., 5., 1.]), array([1.        , 1.66666667, 2.33333333, 3.        ]), <BarContainer object of 3 artists>)
+>>> pylab.show()
+```
+
+![Четвертый график](pictures/Ris3.png)
+```py
+
+>>> pylab.bar(region, naselen)                            
+    <BarContainer object of 4 artists>
+>>> pylab.show()
+```
+
+![Пятый график](pictures/Ris5.png)
+
+## 8. Статистические функции из модуля statistics.
+```py
+>>> import statistics
+>>> dir(statistics)
+    ['Counter', 'Decimal', 'Fraction', 'LinearRegression', 'NormalDist', 'StatisticsError', '_SQRT2', '__all__', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_coerce', '_convert', '_decimal_sqrt_of_frac', '_exact_ratio', '_fail_neg', '_float_sqrt_of_frac', '_integer_sqrt_of_frac_rto', '_isfinite', '_mean_stdev', '_normal_dist_inv_cdf', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'mul', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sys', 'tau', 'variance']
+>>> statistics.mean([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднего
+    5
+>>> statistics.stdev([1, 2, 3, 4, 5, 6, 7, 8, 9]) # Вычисление среднеквадратичного отклонения
+    2.7386127875258306
+>>> statistics.median([1, 2, 3, 4, 5, 6, 7, 8])  # Вычисление медианы
+    4.5
+```
+## 9. Завершение работы со средой.
+Сохранила файлы отчета в своем рабочем каталоге и закончил сеанс работы с IDLE.

TEMA4/task.md

@@ -0,0 +1,51 @@
+# Общее контрольное задание по теме 4
+
+Беженарь Алёна, А-02-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+* Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+* Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+* Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+* Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+* Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+
+## Решение
+
+```py
+>>> # Пункт 1
+>>> import cmath
+>>> divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
+    (8.0, 2.6000000000000014)
+>>> # Пункт2
+>>> import time
+>>> Time=time.time()
+>>> MosSec= Time + 3*60*60
+>>> MosTime=time.gmtime(MosSec)
+>>> print("Current time: {}:{}".format(MosTime.tm_hour, MosTime.tm_min))
+    Current time: 10:55
+>>> # Пункт 3
+>>> Days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]      
+>>> import random
+>>> random.sample(Days, 3)
+    ['Sunday', 'Tuesday', 'Monday']
+>>> # Пункт 4
+>>> random.choice(range(14, 33, 3))
+    14
+>>> # Пункт 5
+>>> import math
+>>> N = math.floor(random.gauss(15, 4))
+>>> N
+    18
+>>> import string #Импортировали модуль в котором есть латинский алфавит, чтобы из него выбрать буквы. Без использования этого модуля создавать список с алфавитом нужно было бы вручную.
+>>> letters = random.sample(string.ascii_letters, N)
+>>> letters
+    ['l', 'c', 'b', 'P', 'S', 'q', 'B', 'm', 'K', 'I', 'T', 'u', 'n', 'f', 'v', 'p', 'E', 'j']
+>>> # Пункт 6
+>>> timeDiff = round(time.time() - time.mktime(localTime))
+>>> print(timeDiff // 60, "minutes and", timeDiff % 60, "seconds")
+    15 minutes and 47 seconds
+```

TEMA4/test.md

@@ -0,0 +1,17 @@
+# Индивидуальное контрольное задание по Теме 4
+
+Беженарь Алёна, А-02-23, Вариант 4
+
+## Задание
+
+Напишите инструкцию определения текущего Московского времени. С задержкой на 5 секунд выведите его на экран по шаблону: «В Москве <> часов и <> минут».
+
+## Решение
+```py
+>>> import time
+>>> MosTime=time.gmtime(time.time()+ 3*60*60) # Определение текущего Московского времени
+>>> time.sleep(5) #задержка на 5 секунд
+
+>>> print("В Москве {} часов и {} минут".format(MosTime.tm_hour, MosTime.tm_min)) #вывод Московского времени по шаблону
+    В Москве 11 часов и 10 минут  
+```

TEMA4/test.py

@@ -0,0 +1,4 @@
+import time
+MosTime=time.gmtime(time.time()+ 3*60*60)
+time.sleep(5)
+print("В Москве {} часов и {} минут".format(MosTime.tm_hour, MosTime.tm_min))