Переименовывание файла

TEMA1/Pr0.py

@@ -0,0 +1,58 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Параметры системы
+K = 2.0
+
+# Частотный диапазон (логарифмическая шкала)
+omega = np.logspace(-1, 2, 500)  # от 0.1 до 100 рад/с
+
+# Действительная и мнимая части АФХ
+U = np.zeros_like(omega)  # Всегда 0
+V = -K / omega  # Мнимая часть
+
+# Построение годографа
+plt.figure(figsize=(8, 8))
+plt.plot(U, V, 'b-', linewidth=2, label='АФХ (годограф)')
+plt.plot(U[0], V[0], 'go', markersize=8, label='Начало (ω=0.1)')
+plt.plot(U[-1], V[-1], 'ro', markersize=8, label='Конец (ω=100)')
+
+# Стрелки направления увеличения частоты
+for i in [50, 150, 300]:  # индексы для стрелок
+    plt.arrow(U[i], V[i], U[i+10]-U[i], V[i+10]-V[i],
+              head_width=0.1, head_length=0.1, fc='k', ec='k')
+
+plt.xlabel('Действительная часть Re(W)')
+plt.ylabel('Мнимая часть Im(W)')
+plt.title(f'АФХ для интегрирующего звена $W(p) = K/p$\nK={K}')
+plt.grid(True, alpha=0.3)
+plt.axis('equal')
+plt.legend()
+plt.show()
+
+# Дополнительно: построение отдельно действительной и мнимой частей
+plt.figure(figsize=(12, 4))
+
+plt.subplot(1, 2, 1)
+plt.semilogx(omega, U, 'r-', linewidth=2)
+plt.xlabel('ω (рад/с)')
+plt.ylabel('Re(W)')
+plt.title('Действительная часть')
+plt.grid(True, alpha=0.3)
+
+plt.subplot(1, 2, 2)
+plt.semilogx(omega, V, 'g-', linewidth=2)
+plt.xlabel('ω (рад/с)')
+plt.ylabel('Im(W)')
+plt.title('Мнимая часть')
+plt.grid(True, alpha=0.3)
+
+plt.tight_layout()
+plt.show()
+
+# Вывод таблицы значений
+print("Таблица значений АФХ:")
+print("ω\t\tRe(W)\t\tIm(W)")
+print("-" * 40)
+for i in range(0, len(omega), 50):
+    print(f"{omega[i]:.2f}\t\t{U[i]:.2f}\t\t{V[i]:.2f}")

TEMA1/protocolIDLE.py

@@ -0,0 +1,14 @@
+ #Программа по Теме 1 <Зеленкина Ксения Михайловна>
+import os
+os.chdir("C:/Users/user/OneDrive/Documents/ZelenkinaKs/python-labs/TEMA1/Отчет")
+
+import Pr0
+Hello
+Your name=Ksenia
+
+import os
+os.chdir("C:/Users/user/OneDrive/Documents/ZelenkinaKs/python-labs/TEMA1/Отчет")
+
+import prb1
+Hello
+Your name=Ksenia

TEMA1/Отчет/report.md

@@ -0,0 +1,86 @@
+# Отчет по Теме 1
+
+Зеленкина Ксения, А-02-23
+
+## Интерпретатор
+## __п. 2 - 5__
+Запустила на выполнение программу-интерпретатор. Изучила содержание открывающегося диалогового окна интерпретатора. Ввела инструкцию, указанную в п.3-5.
+
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+### Изучение среды IDLE
+##### __п. 6 - 8__
+Запустила оболочку интерактивную графическую оболочку IDLE среды Python и изучила устройство главного командного окна среды. В командном окне после символов приглашения к диалогу ввела инструкцию настройки рабочего каталога среды по образцу.
+
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\user\\OneDrive\\Documents\\KseniaZelenkina\\python-labs\\TEMA1\\Отчет')
+```
+
+## Стиль и запуск файла Pr0
+## __п. 9 - 10__
+Изучила предложения главного меню, а также предложения выпадающих меню. Установила в среде шрифт типа _Arial CYR_, размер 11, размер начального окна - высота 50 символов, ширина 100 символов, подкраска комментариев - коричневая.
+В окне текстового редактора оболочки IDLE вставьте инструкции, использованные при выполнении п.п. 3, 4 и 8.  
+
+<img src = "./photo3.png">
+
+Сохранила в файле __Pr0__ с расширением __py__ и запустите инструкции 3 способами:
+__1 способ:__ через «Run module». 
+__2 способ:__ через import Pr0
+__3 способ:__ с помощь F5
+
+<img src = "./photo4.png">
+
+<img src = "./photo5.png">
+
+## Запуск файла prb1
+## __п. 11__
+prb1 запустила также через _import prb1_, _«Run module»_ и _F5_.
+
+<img src = "./photo6.png">
+
+## Каталог pycache
+## __п. 12__
+Открыл в каталоге __pycache__  и открыла в текстовом редакторе файл __Pr0.cpython-34.pyc__, а также запустила его.
+
+<img src = "./photo7.png">
+
+Мы видим скомпилированный байт-код Python, а не исходный код. Это происходит потому, что Python сначала компилирует программу в промежуточный байт-код, который затем выполняется виртуальной машиной Python. 
+Компиляция программ нужна для: проверки синтаксиса, оптимизации, сокрытия исходного кода.
+
+<img src = "./photo8.png">
+
+## Раздел Help
+## __п. 13 - 14__
+Изучила раздел помощи __Help__, в которой прилагаются такие виды помощи как _About IDLE_, _IDLE Doc_, _Python Docs_, _Turtle Demo_.
+Также в командном окне ввела инструкцию __help(print)__,  а затем попробовала ввести сразу несколько инструкций __help(print)__, __help(input)__.
+
+<img src = "./photo9.png" width="500" height="400" align="center">
+
+Затем попробовала ранее рассмотренный способ: поставила в командном окне IDLE курсор на строку с ранее введенной инструкцией помощи по функции print и нажала клавишу _Enter_. Копия инструкции появилась в новой строке.
+Также попробовала обратиться к оперативной помощи через клавишу __F1__ _(fn + F1)_. Нашла через  закладку __Index__ строку __print() (built-in function)__.
+
+<img src = "./photo10.png" width="500" height="400" align="center">
+
+<img src = "./photo11.png" width="500" height="400" align="center">
+
+## Window и возможности Help
+## __п. 15 - 14__
+Открыла 3 окна: командное окно IDLE (Python Shell) и 2 окна текстового редактора. Воспользовалась предложением __Window__.
+
+<img src = "./photo12.png">
+
+Сделала активным окно редактора с программой prb1 и запустила её. Теперь у меня 4 окна: командное окно (Python Shell) и три окна в редакторе. Поочередно активизировала эти окна.
+Запустила программу из файла __tdemo_chaos__. . Открыла этот файл в окне текстового редактора и оценила краткость программы и её графические возможности.
+
+<img src = "./photo13.png" width="500" height="400" align="center">
+
+Выберите предложения __Help => Turtle Demo => Examples__ и из появляющегося списка примеров - __Clock => Start__.
+
+<img src = "./photo14.png" width="500" height="300" align="center">
+
+Попробовала другие примеры.
+
+<img src = "./photo15.png" width="500" height="300" align="center">
+
+## Завершение работы со средой

TEMA1/Отчет/Ответ.md

@@ -0,0 +1,13 @@
+# Общее контрольное задание по теме 1
+
+Зеленкина Ксения, А-02-23
+
+## Вопрос
+Для чего предназначено предложение __«Окно (Window)»__ главного меню?
+
+## Ответ
+
+"Окно (Window)" позволяет:
+1) Посмотреть, какие файлы открыты ( а также увидеть их расположение)
+2) Переключаться между файлами
+3) Увидеть, в какой последовательности они были открыты

TEMA2/Кз.md

@@ -0,0 +1,26 @@
+# Общее контрольное задание по теме 2
+
+Зеленкина Ксения, А-02-23
+
+## Задание
+__Вариант 15__
+
+Создайте объект
+nm=(12,23,34,14,-7,-34)
+К какому классу относится этот объект? Напишите инструкцию, обеспечивающую расчет разности сумм первых трех элементов и последних трех.
+
+## Решение
+
+Данный объект относится к классу _кортеж_.
+__Код:__
+```py
+>>> nm=(12,23,34,14,-7,-34)
+>>> a = sum(nm[:3])
+>>> b = sum(nm[3:])
+>>> print(a - b)
+```
+
+__Вывод:__
+```py
+96
+```

TEMA2/Отчет2.md

@@ -0,0 +1,416 @@
+# Отчет по Теме 2
+
+Зеленкина Ксения, А-02-23
+
+## Простые объекты
+#### п. 2
+Изучила простые объекты и рассмотрела операции присваивания значения объектам-переменным.
+```py
+f1 = 16
+f2 = 3
+```
+<img src = "./photo1.png">
+
+ ## Правила именования объектов в Python
+ #### п. 3
+ Изучила правила наименования переменных. С учетом этих правил в командном окне IDLE выполнила следующие операции:
+```py
+>>> gg1 = 1.6
+>>> hh1 = 'Строка' 
+```
+Также попробовала создать переменную, нарушив правила именования.
+
+```py
+>>> 73sr = 3
+```
+Выдало ошибку "_SyntaxError: invalid decimal literal_"
+
+```py
+>>> and = 7 
+```
+Выдало ошибку "_SyntaxError: invalid syntax_"
+
+## Cписок ключевых слов
+#### п. 4
+Вывела список ключевых слов с помощью инструкции, посмотрела его и сохранила в переменную k.
+```py
+>>> import keyword
+>>> k = keyword.kwlist
+>>> k
+```
+Вывод списка ключевых слов:
+```py
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## Встроенные идентификаторы
+#### п. 5
+Вывела список встроенных идентификаторов с помощью инструкций.
+```py
+>>> import builtins
+>>> dir(builtins)
+```
+Выведенный список:
+```py
+['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']
+```
+Изучила назначение функций: _abs, len, max, min, pow, round, sorted, sum, zip_. Применив фнкцию __help()__.
+```py
+>>> help(abs), help(len)
+```
+и т.д.
+Узнала данные функции и попробовала применить некоторые из них.
+```py
+>>> abs(-2)
+    2
+>>> pow(2, 3)
+    8
+```
+## Малые и большие буквы в именах объектов
+#### п. 6
+Убедилась, что малые и большие буквы в именах объектов различаются.
+```py
+>>> Gg1 = 45
+>>> gg1, Gg1
+    (1.6, 45)
+```
+
+## Типы объектов
+#### п. 7
+Типы объектов: 
+- логический (bool), 
+- целый (int), 
+- вещественный (float), 
+- комплексный (complex), 
+- строка символов (str).
+
+#### п. 7.1. Логический тип
+```py
+>>> bb1=True; bb2=False
+>>> bb1;bb2
+    True
+    False
+>>> type(bb1) 
+    <class'bool'>
+```
+
+#### п. 7.2. Другие простые типы.
+Аналогичным способом изучила другие типы.
+```py
+>>> ii1=-1234567890
+>>> ff1=-8.9876e-12
+>>> dv1=0b1101010
+>>> vsm1=0o52765 
+>>> shest1=0x7109af6 
+>>> cc1=2-3j
+>>> a=3.67; b=-0.45
+>>> cc2=complex(a,b)  
+>>> ii1, ff1,dv1, vsm1, shest1, cc1, cc2
+    (-1234567890, -8.9876e-12, 106, 22005, 118528758, (2-3j), (3.67-0.45j))
+>>> type(ii1), type(ff1), type(dv1), type(vsm1), type(shest1), type(cc1), type(cc2)
+    (<class 'int'>, <class 'float'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'complex'>, <class 'complex'>)
+```
+
+#### п. 7.3. Строка символов.
+Изучила создание строки и создала строку по шаблону.
+```py
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1a)
+    Это - " строка символов ", 
+ 	 выводимая на двух строках
+```
+Также создала ещё одну строку по шаблону.
+```py
+>>> ss1b= 'Меня зовут: \n Зеленкина Ксения'
+>>> print(ss1b)
+    Меня зовут: 
+    Зеленкина Ксения
+```
+Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек, например:
+```py
+>>>  mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+    Нетрудно заметить , что в результате операции
+    над числами разных типов получается число,
+    имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке.
+```py
+>>> ss1='Это - строка символов'
+>>> ss1[0]   #Это – символ «Э»
+>>> ss1[8]  #А это – символ «р»
+>>> ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+```
+
+Операция _«разрезания»_ или _«создания среза»_, создающая новый объект:
+```py
+  ss1[6:9]  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+  ss1[13:]  #Это часть строки – с 13-го индекса и до конца
+  ss1[:13]  #Это часть строки – с начала и до 12-го индекса включительно
+  ss1[5:-8]  #Это часть строки – с 5-го индекса и до 8-го от конца
+  ss1[3:17:2]  #Часть строки – с 3-го по 16-й индексы с шагом 2
+```
+
+Самостоятельно посмотрела, что получилось при __отрицательном__ значении шага:
+```py
+>>> ss1[17:3:-2]
+    'омсаот '
+>>> ss1[-4:3:-2]
+    'омсаот '
+```
+
+Строка является неизменяемым объектом!
+```diff
+>>> 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:]
+>>> ss1
+    'Это = строка символов'
+```
+
+Мои придуманные срезы:
+```py
+>>> ss1[10:15]
+    'ка си'
+>>> ss1[-3:-15:-1]
+    'ловмис акорт'
+>>> ks = 4e938
+>>> type(ks)
+    <class 'float'>
+>>> x = 'Hello'
+>>> type(x)
+    <class 'str'>
+```
+
+#### п. 8. Более сложные типы объектов
+- списки (list), 
+- кортежи (tuple), 
+- словари (dict), 
+- множества (set).
+
+#### п. 8.1. Список
+__Список__ – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. 
+Пример списка с 3 элементами разных типов, список как последовательность сигнала («единичная ступенька») и многострочный ввод списка.
+```py
+>>> spis1=[111,'Spisok',5-9j]
+>>> spis1
+    [111, 'Spisok', (5-9j)]
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> stup
+    [0, 0, 1, 1, 1, 1, 1, 1, 1]
+>>> spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+>>> spis
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+```
+При работе с элементами списка таже можно пользоваться индексами.
+```py
+>>> spis1[-1]
+    (5-9j)
+>>> stup[-8::2]
+    [0, 1, 1, 1]
+```
+Индексы в исходном списке: 1, 3, 5, 7 (или -8, -6, -4, -2).
+Посмотрим на изменняемость списка.
+```py
+>>> spis1[1]='Список'
+>>> spis1
+    [111, 'Список', (5-9j)]
+```
+Предыдущий список: [111, 'Spisok', (5-9j)]
+Измененный список: [111, 'Список', (5-9j)]
+Узнаем текущее число элементов в списке.
+```py
+ >>> len(spis1)
+    3
+```
+```py
+>>> help(spis1.append)
+    Help on built-in function append:
+        append(object, /) method of builtins.list instance
+        Append object to the end of the list.
+```
+С помощью методов объектов-списков добавим и удалим элементы:
+```py
+>>> spis1.append('New item')
+>>> spis1
+    [111, 'Список', (5-9j), 'New item']
+>>> spis1.append(ss1b)
+>>> spis1
+    [111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Зеленкина Ксения']
+>>> spis1.pop(1)
+    'Список'
+>>> spis1
+    [111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина Ксения']
+```
+Также использовала методы insert, remove, extend, clear, sort, reverse, copy, count, index и изучила их самостоятельно и попробовала их применить.
+Списки могут быть вложенными:
+```py
+>>> spis1
+    [111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина Ксения']
+>>> spis2=[spis1,[4,5,6,7]]
+>>> spis2[0][1]
+    (5-9j)
+>>> spis2[0][1]=78
+>>> spis2
+    [[111, 78, 'New item', 'Меня зовут: \n Зеленкина Ксения'], [4, 5, 6, 7]]
+>>> spis1
+[111, 78, 'New item', 'Меня зовут: \n Зеленкина Ксения']
+```
+Spis2[0] не является копией списка spis1 - это ссылка на тот же самый объект в памяти. Когда мы изменяем элемент через spis2[0][1], мы фактически изменяем исходный список spis1.
+
+```py
+>>> my_list = [100, "Привет", True, [1, 2, 3]]
+>>> print(my_list)
+    [100, 'Привет', True, [1, 2, 3]]
+>>> print(type(my_list[0]))
+    <class 'int'>
+>>> print( type(my_list[1]))
+    <class 'str'>
+>>> print(my_list[3][0])
+    1
+>>> print(my_list[3][-1])
+    3
+>>> my_list[0] = 200    
+>>> my_list[1] = "Мир"
+>>> my_list[3][1] = 99 
+>>> print(my_list)
+    [200, 'Мир', True, [1, 99, 3]]
+```
+
+#### п. 8.2. Кортеж 
+Примеры операций с кортежами: создание кортежа:
+```py
+>>> kort1=(222,'Kortezh',77+8j)
+    (222, 'Kortezh', (77+8j))
+```
+Изменить кортеж нельзя, но можно его переопределить:
+```py
+>>> kort1= kort1+(1,2)
+>>> kort1= kort1+(ss1b,)
+    (222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Зеленкина Ксения')
+```
+Теперь переопределим кортеж с удалением комплексного элемента:
+```py
+>>> kort2=kort1[:2]+kort1[3:]
+    (222, 'Kortezh', 1, 2, 'Меня зовут: \n Зеленкина Ксения')
+```
+Два важных метода кортежа (они есть также и у списков):
+- Определение индекса заданного элемента:
+```py
+>>> kort1.index(2)
+    4
+```
+- Подсчет числа вхождений заданного элемента в кортеже:
+```py
+>>>  kort1.count(222) 
+    1
+```
+Попробуем операцию замены элемента кортежа:
+```diff
+>>> kort1[2] = 90
+- Traceback (most recent call last):
+-   File "<pyshell#142>", line 1, <module>
+-     kort1[2] = 90
+- TypeError: 'tuple' object does not support item assignment
+```
+Создание кортежа.
+```py
+>>> my_tuple = (42, "Hello, World!", [1, 2, 3, 4, 5], (9, 8, 7))
+```
+
+#### п. 8.2. Словарь
+Его содержанием является совокупность пар: «ключ (key)»:«значение (value)».
+Пример создания словаря:
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> dic1['Orel']
+    56
+```
+
+Пополнение словаря (добавление элемента, изменение словаря):
+```py
+>>>  dic1['Pskov']=78
+    'Saratov': 120, 'Vologda': 45, 'Pskov': 78, 'Orel': 56}
+```
+Функция sorted:
+```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)])
+    {1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Зеленкина Ксения'}
+>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+    {'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Зеленкина Ксения'}
+```
+Создание объект-кортежа с 7 элементами и объект-список с 5 элементами.
+```py
+>>> keys_tuple = ('name', 'age', 'city', 'country', 'hobby', 'language', 'score')
+>>> values_list = ['Anna', 25, 'Moscow', 'Russia', 'programming']
+>>> my_dict = dict(zip(keys_tuple, values_list))
+>>> my_dict
+    {'name': 'Anna', 'age': 25, 'city': 'Moscow', 'country': 'Russia', 'hobby': 'programming'}
+```
+
+В получившемся словаре 5 элементов. Функция zip() создает пары "ключ-значение" до тех пор, пока не закончится самая короткая из последовательностей
+У нас кортеж имеет 7 элементов, а список - 5 элементов
+zip() создаст только 5 пар, потому что после 5-го элемента в списке значений больше нет
+Лишние ключи из кортежа отбрасываются - они остаются без соответствующих значений/
+
+#### п. 8.2. Множество
+Объект-множество – это неупорядоченная совокупность неповторяющихся элементов.
+Пример создания множества:
+```py
+>>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+>>> mnoz1
+    {'линия связи', 'датчик', 'двигатель', 'микропроцессор'}
+```
+Некоторые операции с множеством:
+- определение числа элементов
+- проверка наличия элемента во множестве
+- добавление элемента
+- удаление элемента
+
+```py
+>>> len(mnoz1)
+    4
+>>> 'датчик' in mnoz1
+    True
+>>> mnoz1.add('реле')
+>>> mnoz1
+    {'двигатель', 'реле', 'датчик', 'линия связи', 'микропроцессор'}
+>>> mnoz1.remove('линия связи')
+>>> mnoz1
+    {'двигатель', 'реле', 'датчик', 'микропроцессор'}
+```
+
+Моё множество:
+```py
+>>> my_set = {1, "apple", 3.14, True, (1, 2, 3)}
+>>> my_set.add("banana")
+>>> my_set.add(42)
+>>> my_set
+    {1, 3.14, 'apple', 42, (1, 2, 3), 'banana'}
+>>> my_set.remove("apple")
+    {1, 3.14, 42, (1, 2, 3), 'banana'}
+```
+## Завершение работы

TEMA2/Решение.py

@@ -0,0 +1,5 @@
+# Решение
+nm=(12,23,34,14,-7,-34)
+a = sum(nm[:3])
+b = sum(nm[3:])
+print(a - b)

TEMA3/GeneralControlTask.md

@@ -0,0 +1,133 @@
+# Общее контрольное задание
+Зеленкина Ксения, А-02-23
+## 1.
+Преобразовать восьмеричное значение 45 в целое число.
+_Код:_
+```py
+res = int('45', 8)
+print(res)
+```
+_Вывод:_
+```py
+37
+```
+
+## 2.
+Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
+_Код:_
+```py
+dir = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+key = dir.keys()
+val = dir.values()
+lk = list(key)
+lv = list(val)
+kort = tuple(lk + lv)
+print(kort)
+print(type(kort))
+```
+
+_Вывод:_
+```py
+('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
+```
+
+__Список:__ Изменяемый (mutable).
+	    Может использоваться в качестве ключа в словаре, так как он неизменяемый.
+	    Позиции элементов фиксированы.
+	    
+__Кортеж:__ Неизменяемый (immutable). 
+	    Не может использоваться в качестве ключа в словаре, так как он изменяемый.
+	    Позиции элементов фиксированы.
+
+## 3.
+Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
+
+_Код:_
+```py
+print(pow(((1768 // 24.8) % 3), 2.4))
+```
+
+_Вывод:_
+```py
+5.278031643091577
+```
+
+## 4.
+Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
+
+_Код:_
+```py
+print(((~(13 & 27)) ^ 14) << 2)
+```
+
+_Вывод:_
+```py
+-32
+```
+
+## 5.
+Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
+
+_Код:_
+```py
+spis = ['колебат'] * 4
+cs = spis[1] + spis[2]
+if 'аткол' in cs:
+    print("Комбинация 'аткол' найдена в конкатенации.")
+else:
+    print("Комбинация 'аткол' не найдена в конкатенации.")
+```
+
+_Вывод:_
+```py
+Комбинация 'аткол' найдена в конкатенации.
+```
+
+## 6.
+Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
+
+_Код:_
+```py
+D = {'a': 1, 'b': 2, 'c': 3}
+#print(dir(D))
+k = D.keys()
+print(k)
+print(type(k))
+print(list(k))
+
+v = D.values()
+print(v)
+print(type(v))
+print(list(v))
+```
+
+_Вывод:_
+```py
+['__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']
+dict_keys(['a', 'b', 'c'])
+<class 'dict_keys'>
+['a', 'b', 'c']
+dict_values([1, 2, 3])
+<class 'dict_values'>
+[1, 2, 3]
+```
+
+## 7.
+Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
+_Код:_
+```py
+stroka = 'Создать объект - символьную строку с текстом данного предложения'
+l = stroka.split(' ')
+print(l)
+a = l.index('-')
+l[a] = ','
+l.remove('данного')
+print(l)
+```
+
+_Вывод:_
+```py
+['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
+2
+['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
+```

TEMA3/Pr1.py

@@ -0,0 +1,444 @@
+#Тема 3 <Зеленкина Ксения Михайловна>
+print('2.1. Функция bool')
+logiz1=bool(56)
+print(type(logiz1))
+logiz2=bool(0)
+print(type(logiz2))
+logiz3=bool("Beta")
+print(type(logiz3))
+logiz4=bool("")
+print(type(logiz4))
+print('\n')
+
+print('2.2 Функция int')
+tt1=int(198.6) #Отбрасывается дробная часть
+print(tt1)
+tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+print(tt2)
+tt3=int("B",16)
+print(tt3)
+tt4=int("71",8)
+print(tt4)
+#tt5=int("98.76")  #Код с ошибкой
+#print(tt5)
+tt5i = int(float("98.76"))   #Исправленный вариант
+print(tt5i)
+print('\n')
+
+print('#Функция float')
+flt1=float(789)
+print(flt1)
+flt2=float(-6.78e2)
+print(flt2)
+flt3=float("Infinity")
+print(flt3)
+flt4=float("-inf")
+print(flt4)
+print('\n')
+
+print('2.3. Системы считсления')
+hh=123
+print(hh)
+print('Двоичная система счисления')
+dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+print(dv1)
+print('Восьмеричная система счисления')
+vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+print(vos1)
+print('Шестнадцатеричная система счисления')
+shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+print(shs1)
+print('\n')
+
+print('3.1 Функция str.')
+strk1=str(23.6)
+print(strk1)
+strk2=str(logiz3)
+print(strk2)
+strk3=str(["A","B","C"])  #Преобразуем список
+print(strk3)
+strk4=str(("A","B","C"))  #Преобразуем кортеж
+print(strk4)
+strk5=str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+print(strk5)
+print('\n')
+
+print('3.2 Функция list.')
+spis1=list("Строка символов")  #Заданная строка разделяется на символы
+print(spis1)
+spis2=list((124,236,-15,908))   #Кортеж превращается в список
+print(spis2)
+spis3=list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+print(spis3)
+print('\n')
+
+print('3.3 Функция tuple.')
+kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+print(kort7)
+kort8=tuple(spis2)   #Преобразование списка в кортеж
+print(kort8)
+kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+print(kort9)
+print('\n')
+
+print('3.4 Функция del.')
+del strk5, kort8
+print('strk5' in globals()) 
+print('kort8' in globals())  
+print('\n')
+
+print('#Преобразование ФИО ')
+FIO = "Зеленкина Кс. М."
+print(FIO)
+listFIO = list(FIO)
+print(listFIO)
+kortFIO = tuple(listFIO)
+print(kortFIO)
+strFIO = str(kortFIO)
+print(strFIO)
+print('\n')
+
+print('4.1 Сложение и вычитание')
+print(12+7+90)  # Сложение целых чисел
+print(5.689e-1 - 0.456)  #Вычитание вещественных чисел
+print(23.6+54)   #Сложение вещественного и целого чисел
+print(14-56.7+89) # Сложение и вычитание целых и вещественных чисел
+print('\n')
+
+print('4.2 Умножение')
+print(-6.7*12)   #Умножение вещественного числа на целое число
+print('\n')
+
+print('4.3 Деление')
+print( -234.5/6)   #Деление вещественного числа на целое
+a=(178/45)  #Деление двух целых чисел – проверьте тип объекта a!
+print(a, type(a))
+print('\n')
+ 
+print('4.4 Округление')
+b=178//45   #Деление двух целых чисел
+c=-24.6//12.1  #Деление двух вещественных чисел
+print(b, c)
+print('\n')
+
+print('#Смешанные комбинации')
+# Целое // Вещественное
+d = 100 // 2.5
+e = -50 // 3.2
+print(type(d), type(e))
+print(d, e)
+# Вещественное // Целое  
+f = 15.8 // 4     
+g = -7.5 // 2
+print(type(f), type(g))
+print(f, g)
+# Отрицательные числа
+h = -100 // 3 
+i = 100 // -3      
+print(type(h), type(i))
+print(h, i)
+print('\n')
+
+print('4.5 Остаток от деления')
+print(148%33)   #Остаток от деления двух целых чисел
+print(12.6%3.8)  #Остаток от деления двух вещественных чисел
+print('\n')
+
+print('#Смешанные комбинации')
+c = 100 % 2.5 
+d = 17 % 3.2
+print(type(c), type(d))
+print(c, d)
+# Вещественное % Целое  
+e = 15.8 % 4     
+f = 7.5 % 2   
+print(type(e), type(f))
+print(e, f)
+# Отрицательные числа
+g = -100 % 3 
+h = 100 % -3    
+i = -12.6 % 3.8
+print(type(g), type(h), type(i))
+print(g, h, i)
+print('\n')
+
+print('4.6 Возведение в степень')
+print(14**3)  #Целое число возводится в целую степень
+e=2.7**3.6  #Вещественное число возводится в вещественную степень
+print(e)
+print('\n')
+
+print('#Операции с комплексными числами')
+print((3+4j) + (2-1j)) 
+print((5+2j) - (1+3j))
+print((2+3j) * (1-2j))
+print((4+0j) * 2.5)
+print((6+8j) / (2+0j))
+print((10+5j) / 2)
+print((1+1j)**2 )
+#print((5+3j) // (2+1j))
+#print((8+4j) % (3+1j))
+print('\n')
+
+print('5.1 Двоичная инверсия')
+dv1=9
+dv2=~dv1
+print(dv1, dv2)
+print('\n')
+
+print('5.2 Двоичное "И"')
+print(7&9)    # 111 и 1001 = 0001
+print(7&8)    # 111 и 1000 = 0000
+print('\n')
+
+print('5.3 Двоичное "ИЛИ"')
+print(7|9)     # 111 или 1001 = 1111
+print(7|8)     # 111 или 1000 = 1111
+print(14|5)   # 1110 или 0101 = 1111
+print('\n')
+
+print('5.4  Двоичное "исключающее  ИЛИ"')
+print(14^5)  # 1110 исключающее или 0101 = 1011
+print('\n')
+
+print('5.5 Сдвиг двоичного представления')
+h =14   #Двоичное представление = 1110
+print(h)
+g=h<<2  # Новое двоичное представление = 111000
+print(g)
+g1=h>>1  # Новое двоичное представление = 0111
+print(g1)
+g2=h>>2  # Новое двоичное представление = 0011
+print(g2)
+print('\n')
+
+print('#Пример с 7 - ми битными числами')
+a = 0b1101010  # 106 (десятичное
+b = 0b1011011  # 91 (десятичное)
+print(a & b)   
+print(a | b)    
+print(a ^ b)   
+print(a << 2) 
+print(b >> 1) 
+print(~a)
+print('\n')
+
+print('6.1 Объединение последовательностей (конкатенация)(+)')
+print('Система '+'регулирования')  #Соединение двух строк символов
+print(['abc','de','fg']+['hi','jkl'])  # Объединение двух списков
+print(('abc','de','fg')+('hi','jkl'))  # Объединение двух кортежей
+print('\n')
+
+print('6.2 Повторение (*)')
+print('ля-'*5)   #Повторение строки 5 раз
+print(['ку','-']*3) #Повторение списка 3 раза
+print(('кис','-')*4)  #Повторение кортежа 4 раза
+signal1=[0]*3+[1]*99
+print(signal1)
+signal2=(0,)*3+(1,)*5+(0,)*7
+print(signal2)
+print('\n')
+      
+print('6.3 in')
+stroka='Система автоматического управления'
+print(stroka)
+print('автомат' in stroka)  #Наличие подстроки в строке
+print('ку' in ['ку','-']*3)  #Наличие контекста в списке
+print('ля-' in ('abc', 'de', 'fg', 'hi', 'jkl'))  #Наличие контекста в кортеже
+print('\n')
+
+print('6.4 Подстановка значений в строку с помощью оператора «%»')
+print('Пример 1')
+stroka='Температура = %g %s  %g'
+print(stroka)
+print(stroka % (16,' меньше ',25))
+print('Пример 2')
+stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+print(stroka)
+print(stroka % {'zn1':16,'sravn':' меньше ','zn2':25})
+print('\n')
+
+print('7.1 Обычное присваивание значения переменной (=)')
+zz=-12
+print('zz = ', zz)
+print('\n')
+
+print('7.2 Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)')
+zz+=5   # Значение zz увеличивается на 5
+print('zz + 5 = ', zz)
+zz-=3  # Значение уменьшается на 3
+print('zz - 3 = ', zz)
+stroka='Система'
+print(stroka)
+stroka+=' регулирования'
+print(stroka)
+print('\n')
+
+print('7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)')
+zz/=2
+print(zz)
+zz*=5
+print(zz)
+stroka *= 2
+print('stroka * 2 = ', stroka)
+print('\n')
+
+print('7.4 Операции //=, %=, **=')
+zz = zz1 =zz2 = 17
+zz //= 5
+print(zz)
+zz1 %= 5
+print(zz1)
+zz2 **= 4
+print(zz2)
+print('\n')
+
+print('7.5 Множественное присваивание')
+w = v = 10  # Переменным присваивается одно и то же значение
+print(w, v)
+n1,n2,n3 = (11,-3,'all')  #Значения переменных берутся из кортежа
+print(n1, n2, n3)
+
+n1, n2, n3 = "11-"
+print(n1, n2, n3)
+n1, n2, n3 = [11, -3, 'all']
+print(n1, n2, n3)
+n1, n2, n3 = {11, -3, 'all'}
+print(n1, n2, n3)
+n1, n2, n3 = {11: 'a', -3: 'b', 'all': 'c'}
+print(n1, n2, n3)
+print('\n')
+
+print('8.1 Операции сравнение')
+print(w == v)
+print(w != v)
+print(w < v)
+print(w > v)
+print(w <= v)
+print( w >= v)
+print('\n')
+
+print('8.2 Операции со множеством')
+mnoz1={'pen','book','pen','iPhone','table','book'}
+print('book' in mnoz1)
+print('cap' in mnoz1)
+print('Операции со словарем')
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+print('Vologda' in dic1)
+print('Pskov' in dic1)
+print(56 in dic1.values())
+print('Ещё пример работы со словарем:')
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+print('UII' in dct1['Depart'])
+dct1['Depart'][1] == 'MM'
+print(dct1)
+print('\n')
+
+print('8.3 Логические "И", "ИЛИ", "НЕ"')
+a=17
+b=-6
+print((a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1))
+print('\n')
+
+print('#Сложные примеры')
+x = 10
+y = 20
+z = 30
+result = (x < y) and (y < z) or (x == 10) and not (z == 40)
+print(result)
+a = 5
+b = 12
+c = 8
+d = 20
+result = (a < b) and (b < d) or (c == 8) and not (d == 15)
+print(result)
+print('\n')
+
+print('8.4 Проверка ссылок переменных на один и тот же объект (is)')
+w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+print(w is v)
+w1=['A','B']
+v1=['A','B']
+print(w1 is v1)
+print('\n')
+
+print('9 dir')
+stroka='Микропроцессорная система управления'
+print(dir(stroka))
+print('\n')
+
+print('9.1 Методы для работы со строками')
+print(stroka.find('пр'))   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+print(stroka.count("с")) #Подсчет числа вхождений строки “с” в stroka
+print(stroka.replace(' у',' автоматического у'))
+spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+print(spis22)
+print(stroka.upper())   #Возвращает строку со всеми заглавными буквами
+stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+print(stroka3)
+print(stroka3.partition("с"))  #Возвращает кортеж с результатами поиска «с» слева
+print(stroka3.rpartition("с")) #Возвращает кортеж с результатами поиска «с» справа
+print('\n')
+
+print('#format')
+strk1 = 'Момент времени {}, значение = {}'
+result1 = strk1.format(1, 89.7)
+print(result1)
+print()
+
+strk2 = 'Момент времени {1}, значение = {0}:{2}'
+result2 = strk2.format(36.7, 2, 'норма!')
+print(result2)
+print()
+
+strk3 = 'Момент времени {num}, значение = {znch}'
+result3 = strk3.format(znch=89.7, num=2)
+print(result3)
+print()
+
+print('9.2 Методы для работы со списками. ')
+spsk = [10, 'apple', 3.14, 'banana', 42]
+print(spsk)
+print("Атрибуты списка:", dir(spsk))
+print(spsk.pop(2))
+spsk.append('c')
+print(spsk)
+spsk.insert(2,'a')
+print(spsk)
+print(spsk.count('a'))
+print()
+
+print('9.3 Изучение применение методов кортежа')
+kort = (1, 2, 3, 2, 4, 2, 5)
+print(kort)
+print(dir(kort))
+print(kort.count(2))
+print(kort.index(3)) # 2 (число 3 на позиции 2
+print(kort.index(2, 3)) # 5 (число 2 начиная с позиции 3)
+print()
+
+print('9.4 Изучение применение методов словарей и множеств')
+print('#Словарь')
+d = {'a': 1, 'b': 2, 'c': 3}
+print(d)
+print(dir(d))
+print(d.keys())
+print(d.values())
+d.update({'d': 4}) # Добавляет/обновляет элементы
+print(d)
+removed = d.pop('b')  # Удаляет ключ и возвращает значение
+print(removed)
+print()
+print('#Множество')
+s1 = {1, 2, 3, 4}
+s2 = {3, 4, 5, 6}
+print(dir(s1))
+print("Множество 1:", s1)
+print("Множество 2:", s2)
+print(s1.union(s2)) #Объединение
+print(s1.intersection(s2)) # {3, 4} - пересечение
+print(s1.difference(s2)) #разность
+s1.add(5)
+print(s1)
+s1.remove(1)
+print(s1)

TEMA3/Test.md

@@ -0,0 +1,100 @@
+# Индивидуальное контрольное задание по модулю 1
+
+Зеленкина Ксения А-02-23
+## Задание
+1)	Как установить рабочий (текущий) каталог в среде? Какую пользу можно получить от такой установки?
+2)	Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении. Отобразите результат с использованием формата по шаблону: " в предложении ХХ букв".
+3)	Создайте числовой объект со значением 2345. Поочередно представьте и отобразите на экране это число в двоичном, восьмеричном и шестнадцатеричном виде. Определите класс созданного объекта и отобразите список его атрибутов. Напишите инструкцию определения числа разрядов в двоичном представлении числа.
+4)	Создайте объект со значением {-45,78,90,-3,56}. Определите класс этого объекта. Атрибуты объекта запишите в объект-кортеж. Напишите инструкцию, позволяющую проверить наличие метода clear у этого кортежа.
+5)	Подсчитайте сумму элементов в объекте, созданном в п.4. Отобразите результат по шаблону: "Сумма элементов=ХХХ".
+
+## Решение
+#### 1.
+В командном окне после символов приглашения к диалогу нужно ввести инструкции настройки рабочего каталога среды по следующему образцу:
+```py
+>>> import os
+>>> os.chdir('C:\\Users\\user\\OneDrive\\Documents\\KseniaZelenkina\\python-labs\\TEMA1\\Отчет')
+```
+__Важно!__ В строке, задающей путь к рабочему каталогу, имена папок разделены двойными слешамию.
+__Польза:__
+- Можно открывать файлы просто по имени: open('data.txt')
+- Не нужно писать полные пути к файлам
+- Импорт модулей из той же папки работает без настройки путей
+
+Чтобы проверить текущий каталог, можно написать следующую инструкцию:
+```py
+>>> import os
+>>> print(os.getcwd())
+```
+
+#### 2.
+_Код:_
+```py
+s = "Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении."
+s = s.replace(',', '')
+s = s.replace('(', '')
+s  = s.replace(')', '')
+s  = s.replace(' ', '')
+lc = len(s)
+e = 'В предложении %d букв'
+kol = 82
+print(e % kol)
+```
+
+_Вывод:_
+```py
+В предложении 82 букв
+```
+
+#### 3.
+
+_Код:_
+```py
+num = 2345
+print('Двочиное представление: ', bin(num))
+print('Восьмеричное: представление: ', oct(num))
+print('Шестнадцатеричное: представление: ', hex(num))
+print(type(num))
+print(dir(num))
+kol_raz = len(bin(num)) - 2 
+print('Число разрядов в двоичном представлении: ', kol_raz)
+```
+
+_Вывод:_
+```py
+Двочиное представление:  0b100100101001
+Восьмеричное: представление:  0o4451
+Шестнадцатеричное: представление:  0x929
+<class 'int'>
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+Число разрядов в двоичном представлении:  12
+```
+_В строке "kol_raz = len(bin(num)) - 2" мы вычитаем 2, так как в двоичном представлениии перед 0 и 1 стоит '0b', которую нам учитывать не надо._
+
+#### 4.
+
+_Код:_
+```py
+d = {-45, 78, 90, -3, 56}
+print(type(d))
+attrib =  tuple(dir(d))
+print('Атрибуты: ', attrib)
+pr = 'clear' in dir(attrib)
+print(pr)
+```
+
+_Вывод:_
+```py
+<class 'set'>
+Атрибуты:  ('__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update')
+False
+```
+
+#### 5.
+_Код:_
+```py
+print('Сумма элементов= ', sum(d))
+```
+```py
+Сумма элементов=  176
+```

TEMA3/Test.py

@@ -0,0 +1,35 @@
+# Индивидуальное контрольное задание
+
+## 1
+
+## 2
+s = "Напишите инструкции, обеспечивающие подсчет числа букв (без запятой, скобок и пробелов) в данном предложении."
+s = s.replace(',', '')
+s = s.replace('(', '')
+s  = s.replace(')', '')
+s  = s.replace(' ', '')
+lc = len(s)
+e = 'В предложении %d букв'
+kol = 82
+print(e % kol)
+
+## 3
+num = 2345
+print('Двочиное представление: ', bin(num))
+print('Восьмеричное: представление: ', oct(num))
+print('Шестнадцатеричное: представление: ', hex(num))
+print(type(num))
+print(dir(num))
+kol_raz = len(bin(num)) - 2 
+print('Число разрядов в двоичном представлении: ', kol_raz)
+
+## 4
+d = {-45, 78, 90, -3, 56}
+print(type(d))
+attrib =  tuple(dir(d))
+print('Атрибуты: ', attrib)
+pr = 'clear' in dir(attrib)
+print(pr)
+
+## 5
+print('Сумма элементов= ', sum(d))

TEMA3/gct.py

@@ -0,0 +1,52 @@
+# Тема 3 "Зеленкина Ксения Михайловна"
+# Общее контрольное задание
+
+## 1.
+res = int('45', 8)
+print(res)
+
+## 2.
+dir = {"усиление":23, "запаздывание":12, "постоянная времени":78}
+key = dir.keys()
+val = dir.values()
+lk = list(key)
+lv = list(val)
+kort = tuple(lk + lv)
+print(kort)
+print(type(kort))
+
+## 3.
+print(pow(((1768 // 24.8) % 3), 2.4))
+
+## 4.
+print(((~(13 & 27)) ^ 14) << 2)
+
+## 5.
+spis = ['колебат'] * 4
+cs = spis[1] + spis[2]
+if 'аткол' in cs:
+    print("Комбинация 'аткол' найдена в конкатенации.")
+else:
+    print("Комбинация 'аткол' не найдена в конкатенации.")
+
+## 6.
+D = {'a': 1, 'b': 2, 'c': 3}
+#print(dir(D))
+k = D.keys()
+print(k)
+print(type(k))
+print(list(k))
+
+v = D.values()
+print(v)
+print(type(v))
+print(list(v))
+
+## 7.
+stroka = 'Создать объект - символьную строку с текстом данного предложения'
+l = stroka.split(' ')
+print(l)
+a = l.index('-')
+l[a] = ','
+l.remove('данного')
+print(l)

TEMA3/Отчет3.md

@@ -0,0 +1,717 @@
+# Отчет по Теме 3
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Преобразование простых базовых типов объектов.
+#### п. 2.1
+Преобразование в логический тип с помощью функции __bool(<Объект>)__.
+```py
+>>> logiz1=bool(56)
+>>> print(type(logiz1))
+    <class 'bool'>
+>>> logiz2=bool(0)
+>>> print(type(logiz2))
+    <class 'bool'>
+>>> logiz3=bool("Beta")
+>>> print(type(logiz3))
+    <class 'bool'>
+>>> logiz4=bool("")
+>>> print(type(logiz4))
+    <class 'bool'>  
+```
+
+#### п. 2.2
+Преобразуем в целое десятичное число объект с заданной системой счисления с помощью функции __int(<Объект>[,<Система счисления, в которой определен объект>])__.
+```diff
+>>> tt1=int(198.6) #Отбрасывается дробная часть
+>>> print(tt1)
+    198
+>>> tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+>>> print(tt2)
+    -76
+>>> tt3=int("B",16)
+>>> print(tt3)
+    11
+>>> tt4=int("71",8)
+>>> print(tt4)
+    57
+>>> tt5=int("98.76")
+>>> print(tt5)
+-   Traceback (most recent call last):
+-     File "C:/Users/user/OneDrive/Documents/ZelenkinaKs/python-labs/TEMA3/Pr1.py", line 19, - in <module>
+-           tt5=int("98.76")
+-   ValueError: invalid literal for int() with base 10: '98.76'
+```
+В последнее функции ошибка возникает потому, что функция int() не может преобразовывать строки с десятичной точкой (дробные числа) напрямую.
+Исправленный вариант:
+```py
+>>> tt5 = int(float("98.76"))
+    98
+```
+Функция int() со строковым аргументом требует, чтобы строка содержала только:
+- Цифры (0-9)
+- Знак минус (для отрицательных чисел)
+- Буквы A-F (только для систем счисления выше 10)
+- Без десятичных точек, запятых или других нечисловых символов
+
+Преобразуем целые чисела или строки символов в вещественное число – с помощью функции __float(<Объект>)__.
+```py
+>>> flt1=float(789)
+>> print(flt1)
+    789.0
+>>> flt2=float(-6.78e2)
+>>> print(flt2)
+    -678.0
+>>> flt3=float("Infinity")
+>>> print(flt3)
+    inf
+>>> flt4=float("-inf")
+>>> print(flt4)
+    -inf
+```
+
+#### п. 2.3 
+Преобразование десятичных чисел в другие системы счисления:
+```py
+>> hh=123
+>> print(hh)
+    123
+>>> dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+>>> print(dv1)
+    0b1111011
+>>> vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+>>> print(vos1)
+    0o173
+>>> shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+>>> print(shs1)
+    0x7b
+```
+## 3. Преобразования более сложных базовых типов объектов.
+#### п. 3.1
+Преобразование в строку символов с помощью функции __str(<Объект>)__.
+```py
+>>> strk1=str(23.6)
+>>> print(strk1)
+    23.6
+>>> strk2=str(logiz3)
+>>> print(strk2)
+    True
+>>> strk3=str(["A","B","C"])  #Преобразуем список
+>>> print(strk3)
+    ['A', 'B', 'C']
+>>> strk4=str(("A","B","C"))  #Преобразуем кортеж
+>>> print(strk4)
+    ('A', 'B', 'C')
+>>> strk5=str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+>>> print(strk5)
+    {'A': 1, 'B': 2, 'C': 9}
+```
+
+#### п. 3.2
+Преобразование элементов объекта в список с помощью функции __list(<Объект>)__.
+```py
+>>> spis1=list("Строка символов")  #Заданная строка разделяется на символы
+>>> print(spis1)
+    ['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>> spis2=list((124,236,-15,908))   #Кортеж превращается в список
+>>> print(spis2)
+    [124, 236, -15, 908]
+>>> spis3=list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+>>> print(spis3)
+    ['A', 'B', 'C']
+```
+
+#### п. 3.3
+Преобразование элементов объектов в кортеж с помощью функции __tuple(<Объект>)__.
+```py
+>>> kort7=tuple('Строка символов')  #Преобразование строки символов в кортеж
+>>> print(kort7)
+    ('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2)   #Преобразование списка в кортеж
+>>> print(kort8)
+    (124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9})   #Преобразование словаря в кортеж
+>>> print(kort9)
+    ('A', 'B', 'C')
+```
+
+#### п. 3.4
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции __del__.
+ ```py
+ >>> del strk5, kort8
+>>> print('strk5' in globals()) 
+    False
+>>> print('kort8' in globals())
+    False
+ ```
+ Данные переменные были удалены.
+ __Преобрращование ФИО:__
+ ```py
+>> FIO = "Зеленкина Кс. М."
+>>> print(FIO)
+    Зеленкина Кс. М.
+>>> listFIO = list(FIO)
+>>> print(listFIO)
+    ['З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.']
+>>> kortFIO = tuple(listFIO)
+>>> print(kortFIO)
+    ('З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.')
+>>> strFIO = str(kortFIO)
+>>> print(strFIO)
+    ('З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.')
+ ```
+ ## 4. Арифметические операции.
+ #### п. 4.1
+ Сложение и вычитание (+ и -):
+ ```py
+>>> print(12+7+90)  # Сложение целых чисел
+    109
+>>> print(5.689e-1 - 0.456)  #Вычитание вещественных чисел
+    0.11289999999999994
+>>> print(23.6+54)   #Сложение вещественного и целого чисел
+    77.6
+>>> print(14-56.7+89) # Сложение и вычитание целых и вещественных чисел
+    46.3
+ ```
+ 
+#### п. 4.2
+ Умножение (*):
+ ```py
+ >>> print(-6.7*12)   #Умножение вещественного числа на целое число
+    -80.4
+ ```
+#### п. 4.3
+Деление (/):
+```py
+>>> print( -234.5/6)   #Деление вещественного числа на целое
+    -39.083333333333336
+>>> a = (178/45)  #Деление двух целых чисел – проверьте тип объекта a!
+>>> print(a, type(a))
+    3.9555555555555557 <class 'float'>
+```
+
+#### п. 4.4
+Деление с округлением вниз (//):
+```py
+>>> b=178//45   #Деление двух целых чисел
+>>> c=-24.6//12.1  #Деление двух вещественных чисел
+>>> print(b, c)
+    3 -3.0
+```
+__Смешанные комбинации__
+```py
+# Целое // Вещественное
+d = 100 // 2.5
+e = -50 // 3.2
+print(type(d), type(e))
+print(d, e)
+# Вещественное // Целое  
+f = 15.8 // 4     
+g = -7.5 // 2
+print(type(f), type(g))
+print(f, g)
+# Отрицательные числа
+h = -100 // 3 
+i = 100 // -3      
+print(type(h), type(i))
+print(h, i)
+print('\n')
+```
+
+#### п. 4.5
+Получение остатка от деления (%):
+```py
+>>> print(148 % 33)   #Остаток от деления двух целых чисел
+    16
+>>> print(12.6 % 3.8)  #Остаток от деления двух вещественных чисел
+    1.2000000000000002
+```
+Попробовала смешанные комбинации с данной операцией.
+
+#### п. 4.6
+Возведение в степень (**):
+```py
+>>> print(14**3)  #Целое число возводится в целую степень
+    2744
+>>> e = 2.7**3.6  #Вещественное число возводится в вещественную степень
+>>> print(e)
+    35.719843790663525
+```
+Попробовала смешанные комбинации с данной операцией.
+```py
+>>> print((3+4j) + (2-1j)) 
+>>> print((5+2j) - (1+3j))
+>>> print((2+3j) * (1-2j))
+>>> print((4+0j) * 2.5)
+>>> print((6+8j) / (2+0j))
+>>> print((10+5j) / 2)
+>>> print((1+1j)**2 )
+    (5+3j)
+    (4-1j)
+    (8-1j)
+    (10+0j)
+    (3+4j)
+    (5+2.5j)
+    2j
+```
+```diff
+>>> print((5+3j) // (2+1j))
+-    unsupported operand type(s) for //: 'complex' and 'complex'
+>>> print((8+4j) % (3+1j))
+-   TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+```
+Для комплексных чисел __допустимы__ следующие операции: +, -, *, /, **
+__Не допустимы:__ //, % 
+
+## 5. Операции с двоичными представлениями целых чисел.
+#### 5.1.
+Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+```py
+>>> dv1=9
+>>> dv2=~dv1
+>>> print(dv1, dv2)
+    9 -10
+```
+
+#### 5.2.
+Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```py
+>>> print(7&9)    # 111 и 1001 = 0001
+    1
+>>> print(7&8)    # 111 и 1000 = 0000
+    0
+```
+
+#### 5.3.
+Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0.
+```py
+>>> print(7|9)     # 111 или 1001 = 1111
+    15
+>>> print(7|8)     # 111 или 1000 = 1111
+    15
+>>> print(14|5)   # 1110 или 0101 = 1111
+    15
+```
+
+#### 5.4.
+Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+```py
+>>> print(14^5)  # 1110 исключающее или 0101 = 1011
+    11
+```
+
+#### 5.5.
+Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
+```py
+>>> h =14   #Двоичное представление = 1110
+>>> print(h)
+    14
+>>> g=h<<2  # Новое двоичное представление = 111000
+>>> print(g)
+    56
+>>> g1=h>>1  # Новое двоичное представление = 0111
+>>> print(g1)
+    7
+>>> g2=h>>2  # Новое двоичное представление = 0011
+>>> print(g2)
+    3
+```
+Пример с 7-ми битными числами:
+```py
+>>> a = 0b1101010  # 106 (десятичное
+>>> b = 0b1011011  # 91 (десятичное)
+>>> print(a & b)   
+    74
+>>> print(a | b)   
+    123
+>>> print(a ^ b)
+    49
+>>> print(a << 2) 
+    424
+>>> print(b >> 1) 
+    45
+>>> print(~a)
+    -107
+```
+## 6. Операции при работе с последовательностями (строками, списками, кортежами).
+#### п. 6.1
+Объединение последовательностей (конкатенация)(+)
+```py
+>>> print('Система '+'регулирования')  #Соединение двух строк символов
+    Система регулирования
+>>> print(['abc','de','fg']+['hi','jkl'])  # Объединение двух списков
+    ['abc', 'de', 'fg', 'hi', 'jkl']
+>>> print(('abc','de','fg')+('hi','jkl'))  # Объединение двух кортежей
+    ('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+#### п. 6.2
+Повторение (*)
+```py
+>>> print('ля-'*5)   #Повторение строки 5 раз
+    ля-ля-ля-ля-ля-
+>>> print(['ку','-']*3) #Повторение списка 3 раза
+    ['ку', '-', 'ку', '-', 'ку', '-']
+>>> print(('кис','-')*4)  #Повторение кортежа 4 раза
+    ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+>>> signal1=[0]*3+[1]*99
+>>> print(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
+>>> print(signal2)
+    (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+#### п. 6.3
+Проверка наличия заданного элемента в последовательности (in):
+```py
+>>> stroka='Система автоматического управления'
+    Система автоматического управления
+>>> print(stroka)
+>>> print('автомат' in stroka)  #Наличие подстроки в строке
+    True
+>>> print('ку' in ['ку','-']*3)  #Наличие контекста в списке
+    True
+>>> print('ля-' in ('abc', 'de', 'fg', 'hi', 'jkl'))  #Наличие контекста в кортеже
+    False
+```
+
+#### п. 6.4
+Подстановка значений в строку с помощью оператора «%»
+_Пример 1_
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> print(stroka)
+    Температура = %g %s  %g
+>>> print(stroka % (16,' меньше ',25))
+    Температура = 16  меньше   25
+```
+_Пример 2_
+```py
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> print(stroka)
+    Температура = %(zn1)g %(sravn)s  %(zn2)g
+>>> print(stroka % {'zn1':16,'sravn':' меньше ','zn2':25})
+    Температура = 16  меньше   25
+```
+## 7. Оператор присваивания
+#### п. 7.1
+Обычное присваивание значения переменной (=):
+```py
+>>> zz=-12
+>>> print('zz = ' zz)
+    zz =  -12
+```
+
+#### п. 7.2
+Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```py
+>>> zz+=5   # Значение zz увеличивается на 5
+>>> print('zz + 5 = ', zz)
+    zz + 5 =  -7
+>>> zz-=3  # Значение уменьшается на 3
+>>> print('zz - 3 = ', zz)
+    zz - 3 =  -10
+>>> stroka='Система'
+>>> print(stroka)
+    Система
+>>> stroka+=' регулирования'
+>>> print(stroka)
+    Система регулирования
+```
+
+#### п. 7.3
+Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+>>> zz/=2
+>>> print(zz)
+    -5.0
+>>> zz*=5
+>>> print(zz)
+    -25.0
+>>> stroka *= 2
+>>> print('stroka * 2 = ', stroka)
+    stroka * 2 =  Система регулированияСистема регулирования
+```
+
+#### п. 7.4
+Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) изучите самостоятельно.
+```py
+>>> zz = zz1 =zz2 = 17
+>>> zz //= 5
+>>> print(zz)
+    3
+>>> zz1 %= 5
+>>> print(zz1)
+    2
+>>> zz2 **= 4
+>>> print(zz2)
+    83521
+```
+Данные операции не применимы к строкам!!!
+
+#### п. 7.5
+Множественное присваивание:
+```py
+>>> w = v = 10  # Переменным присваивается одно и то же значение
+>>> print(w, v)
+    10 10
+>>> n1,n2,n3 = (11,-3,'all')  #Значения переменных берутся из кортежа
+>>> print(n1, n2, n3)
+    11 -3 all
+```
+Вместо кортежа справа используем строку, список, словарь, множество.
+__Строка:__
+```py
+>>> n1, n2, n3 = "11-"
+>>> print(n1, n2, n3)
+    1 1 -
+```
+__Cписок:__
+```py
+>>> n1, n2, n3 = [11, -3, 'all']
+>>> print(n1, n2, n3)
+    11 -3 all
+```
+
+__Множество:__
+```py
+>>> n1, n2, n3 = {11, -3, 'all'}
+>>> print(n1, n2, n3)
+    11 all -3
+```
+
+__Словарь:__
+```py
+>>> n1, n2, n3 = {11: 'a', -3: 'b', 'all': 'c'}
+>>> print(n1, n2, n3)
+    11 -3 all
+```
+У __словаря__ распаковываются только ключи!
+
+## 8. Логические операции.
+#### п. 8.1 
+__Операции сравнение:__ равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) – придумайте примеры этих операций. 
+```py
+>>> print(w == v)
+>>> print(w != v)
+>>> print(w < v)
+>>> print(w > v)
+>>> print(w <= v)
+>>> print( w >= v)
+    True
+    False
+    False
+    False
+    True
+    True
+```
+
+#### п. 8.2
+Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in).
+__Операции с множеством:__
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> print('book' in mnoz1)
+    True
+>>> print('cap' in mnoz1)
+    False
+```
+__Операции со словарём:__
+```py
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> print('Vologda' in dic1)
+    True
+>>> print('Pskov' in dic1)
+    False
+>>> print(56 in dic1.values())
+    True
+__Ещё примеры работ со словарём:__
+```py
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> print('UII' in dct1['Depart'])
+    True
+>>> dct1['Depart'][1] == 'MM'
+>>> print(dct1)
+    {'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+```
+
+#### п. 8.3
+Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). 
+```py
+>>> a=17
+>>> b=-6
+>>> print((a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1))
+    True
+```
+
+__Придуманные сложные примеры:__
+_Пример 1:_
+```py
+>>> x = 10
+>>> y = 20
+>>> z = 30
+>>> result = (x < y) and (y < z) or (x == 10) and not (z == 40)
+>>> print(result)
+    True
+```
+_Пример 2:_
+```py
+>>> a = 5
+>>> b = 12
+>>> c = 8
+>>> d = 20
+>>> result = (a < b) and (b < d) or (c == 8) and not (d == 15)
+>>> print(result)
+    True
+```
+
+#### п. 8.4
+Проверка ссылок переменных на один и тот же объект (is).
+```py
+>>> w=v=10 
+>>> print(w is v)
+    True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> print(w1 is v1)
+    False
+```
+__is__ проверяет идентичность объектов, а не равенство значений!
+
+## 9. Операции с объектами, выполняемые с помощью методов.
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например:
+```py
+>>> stroka='Микропроцессорная система управления'
+>>> dir(stroka)
+    ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+#### п. 9.1
+Методы для работы со строками. Рассмотрим несколько примеров таких методов:
+```py
+>>> print(stroka.find('пр')) 
+    5
+>>> print(stroka.count("с")) 
+    4
+>>> print(stroka.replace(' у',' автоматического у'))
+    Микропроцессорная система автоматического управления
+>>> spis22=stroka.split(' ')
+>>> print(spis22)
+    ['Микропроцессорная', 'система', 'управления']
+>>> print(stroka.upper()) 
+    МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ
+>>> stroka3=" ".join(spis22) 
+>>> print(stroka3)
+    Микропроцессорная система управления
+>>> print(stroka3.partition("с"))
+    ('Микропроце', 'с', 'сорная система управления')
+>>> print(stroka3.rpartition("с"))
+    ('Микропроцессорная си', 'с', 'тема управления')
+```
+Изучила метод __format__:
+```py
+>>> strk1 = 'Момент времени {}, значение = {}'
+>>> result1 = strk1.format(1, 89.7)
+>>> print(result1)
+    Момент времени 1, значение = 89.7
+>>> strk2 = 'Момент времени {1}, значение = {0}:{2}'
+>>> result2 = strk2.format(36.7, 2, 'норма!')
+>>> print(result2)
+    Момент времени 2, значение = 36.7:норма!
+>>> strk3 = 'Момент времени {num}, значение = {znch}'
+>>> result3 = strk3.format(znch=89.7, num=2)
+>>> print(result3)
+    Момент времени 2, значение = 89.7
+```
+
+#### п. 9.2
+Методы для работы со списками: 
+Создадим произвольный список spsk, не менее чем с 5 элементами и отобразите его атрибуты.
+Последовательно обратимся к методам этого списка с отображением каждый раз полученного списка:
+
+```py
+>>> spsk = [10, 'apple', 3.14, 'banana', 42]
+>>> print(spsk)
+    [10, 'apple', 3.14, 'banana', 42]
+>>> print("Атрибуты списка:", dir(spsk))
+    Атрибуты списка: ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+>>> print(spsk.pop(2))
+    3.14
+>>> spsk.append('c')
+>>> print(spsk)
+    [10, 'apple', 'banana', 42, 'c']
+>>> spsk.insert(2,'a')
+>>> print(spsk)
+    [10, 'apple', 'a', 'banana', 42, 'c']
+>>> print(spsk.count('a'))
+    1
+```
+Смысл выполненных операций:
+- __pop()__ - убирает элемент
+- __append()__ - добавляет в конец
+- __insert()__ - Вставляет элемент на указанную позицию
+- __count()__ - считает элементы
+
+#### п. 9.3
+Изучение применения основных методов кортежа:
+```py
+>>> kort = (1, 2, 3, 2, 4, 2, 5)
+>>> print(kort)
+    (1, 2, 3, 2, 4, 2, 5)
+>>> print(dir(kort))
+    ['__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']
+>>> print(kort.count(2))
+    3
+>>> print(kort.index(3)) # 2 (число 3 на позиции 2)
+    2
+>>> print(kort.index(2, 3)) # 5 (число 2 начиная с позиции 3)
+    3
+```
+
+#### п. 9.4
+Изучение применения основных методов словарей и множеств:
+__Словарь:__
+```py
+>>> d = {'a': 1, 'b': 2, 'c': 3}
+>>> print(d)
+    {'a': 1, 'b': 2, 'c': 3}
+>>> print(dir(d))
+    ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+>>> print(d.keys())
+    dict_keys(['a', 'b', 'c'])
+>>> print(d.values())
+    dict_values([1, 2, 3])
+>>> d.update({'d': 4}) # Добавляет/обновляет элементы
+>>> print(d)
+    {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+>>> removed = d.pop('b')  # Удаляет ключ и возвращает значение
+>>> print(removed)
+    2
+```
+
+__Множество:__
+```py
+>>> s1 = {1, 2, 3, 4}
+>>> s2 = {3, 4, 5, 6}
+>>> print(dir(s1))
+    ['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
+>>> print("Множество 1:", s1)
+    Множество 1: {1, 2, 3, 4}
+>>> print("Множество 2:", s2)
+    Множество 2: {3, 4, 5, 6}
+>>> print(s1.union(s2)) #Объединение
+    {1, 2, 3, 4, 5, 6}
+>>> print(s1.intersection(s2)) # {3, 4} - пересечение
+    {3, 4}
+>>> print(s1.difference(s2)) #разность
+    {1, 2}
+>>> s1.add(5)
+>>> print(s1)
+    {1, 2, 3, 4, 5}
+>>> s1.remove(1)
+>>> print(s1)
+    {2, 3, 4, 5}
+```
+## Завершение работы

TEMA4/Task.md

@@ -0,0 +1,22 @@
+# Индивидуальные контрольные задания по теме 4
+Зеленкина Ксения А-02-23
+
+## Задача
+'''Создайте список с элементами, значения которых находятся в диапазоне от 4 до 53 с шагом 7. Определите число элементов в получившемся списке. Случайно выберите один из элементов списка.
+Рассчитайте его логарифм и отобразите в виде строки: «Результат = <значение>».'''
+
+## Решение
+_Код:_
+```py
+import random
+import math
+l = list(range(4, 53, 7))
+print(len(l))
+print(math.log(random.choice(l)))
+```
+
+_Вывод:_
+```py
+7
+3.4657359027997265
+```

TEMA4/Task.py

@@ -0,0 +1,6 @@
+# Индивидуальные контрольные задания по теме 4
+import random
+import math
+l = list(range(4, 53, 7))
+print(len(l))
+print(math.log(random.choice(l)))

TEMA4/gct.md

@@ -0,0 +1,104 @@
+#Общее контрольное задание по ТЕМЕ 4 "Зеленкина Ксения Михайловна"
+
+## 1.
+Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+
+_Код:_
+```py
+import cmath
+n = ((round(cmath.phase(0.2+0.8j),2)) * 20)
+a, b = divmod(n, 3)
+print(a,b)
+```
+
+_Вывод:_
+```py
+(8.0, 2.6000000000000014)
+```
+
+## 2.
+Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+_Код:_
+```py
+import time
+Mtime = time.gmtime(time.time() + 3 * 3600)
+print(f'{Mtime.tm_hour}:{Mtime.tm_min}')
+start_time = time.time()
+```
+
+_Вывод:_
+```py
+12:5
+```
+
+## 3.
+Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
+
+_Код:_
+```py
+import random
+spis = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+l = random.sample(spis, 3)
+print(l)
+``` 
+
+_Вывод:_
+```py
+['Понедельник', 'Суббота', 'Вторник']
+```
+
+## 4.
+Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+_Код:_
+```py
+import random
+num = list(range(14, 32, 3))
+res = random.choice(num)
+print(res)
+``` 
+
+_Вывод:_
+```py
+20
+```
+
+## 5.
+Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+_Код:_
+```py
+import random
+import string
+N = round(random.gauss(15, 4))
+l = string.ascii_uppercase
+c = random.sample(l, N)
+print(c)
+print(N)
+print(f'Длина массива: {len(c)}')
+``` 
+
+_Вывод:_
+```py
+['M', 'Z', 'V', 'Q', 'G', 'O', 'N', 'J', 'X', 'R', 'C', 'S', 'H', 'B', 'T', 'F', 'U', 'E', 'K', 'W']
+20
+Длина массива: 20
+```
+
+## 6.
+Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+_Код:_
+```py
+import random
+import time
+NewMtime = time.time() + 3*3600  # Обновляем текущее московское время
+inter_minutes = (NewMtime - start_time) / 60
+print(inter_minutes)
+``` 
+
+_Вывод:_
+```py
+180.00013352632521
+```

TEMA4/genct4.py

@@ -0,0 +1,42 @@
+# Тема 3 "Зеленкина Ксения Михайловна"
+# Общее контрольное задание
+
+## 1.
+import cmath
+n = ((round(cmath.phase(0.2+0.8j),2)) * 20)
+a, b = divmod(n, 3)
+print(a,b)
+
+## 2.
+import time
+Mtime = time.gmtime(time.time() + 3 * 3600)
+print(f'{Mtime.tm_hour}:{Mtime.tm_min}')
+start_time = time.time()
+
+## 3.
+import random
+spis = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+l = random.sample(spis, 3)
+print(l)
+
+## 4.
+import random
+num = list(range(14, 32, 3))
+res = random.choice(num)
+print(res)
+
+## 5.
+import random
+import string
+N = round(random.gauss(15, 4))
+l = string.ascii_uppercase
+c = random.sample(l, N)
+print(c)
+print(N)
+print(f'Длина массива: {len(c)}')
+
+## 6.
+import time
+NewMtime = time.time() + 3*3600  # Обновляем текущее московское время
+inter_minutes = (NewMtime - start_time) / 60
+print(inter_minutes)

TEMA4/protocol.py

@@ -0,0 +1,210 @@
+# ТЕМА 4 "Зеленкина Ксения Михайловна"
+# 2.1
+print(round(123.456,1))
+print(round(123.456,0))
+
+print(round(123.456))
+
+# 2.2.
+gg=range(76,123,9)
+print(gg)
+
+print(list(gg))
+
+print(list(range(23)))
+
+# 2.3.
+qq = ['Зеленкина', 'Криви', 'Цветкова', 'Капитонов']
+print(qq)  
+ff = zip(gg, qq)
+print(ff) 
+
+result_tuple = tuple(ff)
+print(result_tuple)
+print(result_tuple[0]) 
+print(result_tuple[2])
+
+# 2.4.
+#fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+#print(fff, dan)
+
+# 2.5
+#exec(input('введите инструкции:'))
+
+# 2.6   
+print(abs(-7.5)) 
+print(pow(3, 4))
+
+numbers = [5, 2, 8, 1]
+print(max(numbers))  
+print(min(numbers)) 
+
+print(sum(numbers))
+
+a, b = divmod(17, 5)
+print(a, b)
+
+text = "Hello"
+print(len(text))  
+
+numbers = [1, 2, 3, 4]
+text_numbers = list(map(str, numbers))
+print(text_numbers)
+
+#3
+import math
+print(dir(math))
+help(math.factorial)
+print(math.factorial(5))
+
+import math
+
+print(dir(math))
+help(math.factorial)
+
+print(math.factorial(5))
+print(math.sin(math.pi/2))
+print(math.acos(0.5))
+print(math.degrees(math.pi))
+print(math.radians(180))
+print(math.exp(1))
+print(math.log(100))
+print(math.log10(100))
+print(math.sqrt(25))
+print(math.ceil(4.2))
+print(math.floor(4.9))
+print(math.pi)
+
+result = math.sin(2 * math.pi / 7 + math.exp(0.23))
+print(result)
+
+#4
+import cmath
+print(dir(cmath))
+print(cmath.sqrt(1.2-0.5j))
+print(cmath.phase(1-0.5j))
+
+#5
+import random
+print(dir(random))
+help(random.seed)
+print(random.seed())
+
+import random
+
+random.seed(42)
+
+print(random.random())
+print(random.uniform(10, 20))
+print(random.randint(1, 6))
+print(random.gauss(0, 1))
+
+fruits = ["яблоко", "банан", "апельсин", "киви"]
+print(random.choice(fruits))
+
+cards = ["Туз", "Король", "Дама", "Валет"]
+random.shuffle(cards)
+print(cards)
+
+numbers = list(range(1, 51))
+print(random.sample(numbers, 5))
+
+print(random.betavariate(2, 5))
+print(random.gammavariate(2, 1))
+print(random.randint(100, 999))
+print(random.uniform(-5, 5))
+
+random_values = [random.uniform(0, 1), random.gauss(0, 1), random.betavariate(2, 5), random.gammavariate(2, 1)]
+print(random_values)
+
+#6
+import time
+print(dir(time))
+c1=time.time()
+print(c1)
+c2=time.time()-c1
+print(c2)
+dat=time.gmtime()
+print(dat)
+print(dat.tm_mon)
+
+# local()
+local_time = time.localtime()
+print(local_time.tm_year)
+print(local_time.tm_mon)
+print(local_time.tm_mday)
+print(local_time.tm_hour)
+print(local_time.tm_min)
+print(local_time.tm_sec)
+
+# asctim()
+time_str = time.asctime(local_time)
+print(time_str)
+
+#ctime()
+current_seconds = time.time()
+print(current_seconds)
+time_from_seconds = time.ctime(current_seconds)
+print(time_from_seconds)
+
+#sleep()
+print("Начинаем отсчет...")
+for i in range(3, 0, -1):
+    print(f"{i}...")
+    time.sleep(1)
+print("Запуск!")
+
+#mtime
+seconds_from_struct = time.mktime(local_time)
+print(seconds_from_struct)
+
+#Обратное преобразование из секунды
+print(time.localtime(c1))
+
+# Графические функции.
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t, x)  # Создание графика в оперативной памяти
+pylab.title('Первый график')
+pylab.xlabel('время')
+pylab.ylabel('сигнал')
+pylab.show()  # Отображение графика на экране
+
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+pylab.plot(X2)
+pylab.show()
+
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+pylab.show()
+
+#hist
+import matplotlib.pyplot as plt
+assessments = [3, 4, 5, 3, 4, 5, 5, 4, 3, 2, 4, 5, 3, 4, 5, 4, 3, 5, 4, 3]
+plt.hist(assessments, bins=5, color='lightblue', edgecolor='black')
+plt.xlabel('Оценки')
+plt.ylabel('Количество студентов')
+plt.title('Распределение оценок студентов')
+plt.show()
+
+#bar
+fruits = ['Яблоки', 'Бананы', 'Апельсины', 'Груши']
+count = [25, 30, 15, 20]
+color = ['red', 'yellow', 'orange', 'green']
+plt.bar(fruits, count, color=color)
+plt.ylabel('Количество')
+plt.title('Любимые фрукты')
+plt.show()
+
+#Statistic
+import statistics
+print(dir(statistics))
+data = [1, 2, 3, 4, 5, 5, 6]
+print("Mean:", statistics.mean(data))
+print("Median:", statistics.median(data))
+print("Mode:", statistics.mode(data))
+print("Stdev:", statistics.stdev(data))

TEMA4/Отчет4.md

@@ -0,0 +1,424 @@
+# Отчет по Теме 4
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Стандартные функции.
+Они находятся в модуле __builtins__, который становится доступным без импорта при запуске среды IDLE.
+#### п. 2.1.
+Функция __round__ – округление числа с заданной точностью. Попробую данную функцию на следующих примерах.
+```py
+>>> print(round(123.456,1))
+    123.5
+>>> print(round(123.456,0))
+    123.0
+```
+Данные результаты имеют тип float. Первое выражение округляет до одного знака после запятой, второе — до целого числа.
+Попробуем выполнить следующую инструкцию:
+```py
+>>> print(round(123.456))
+    123
+```
+Полученный результат имеет тип int.
+
+#### п. 2.2.
+Функция __range__ – создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1.
+```py
+>>> gg=range(76,123,9)
+>>> print(gg)
+    range(76, 123, 9)
+```
+Обратим внимание, что эта инструкция создает, так называемый, _«итерируемый объект»_ класса __range__. Чтобы увидеть получившуюся преобразуем его в список.
+```py
+>>> print(list(gg))
+    [76, 85, 94, 103, 112, 121]
+```
+Также возможно вызвать функцию __range__ с одним аргументом.
+```py
+>>> print(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]
+```
+Мы получили объект, который содержит последовательность целых чисел от 0 до 22(включительно) с шагом 1.
+
+#### п. 2.3.
+Функция __zip__ – создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей. 
+```py
+>>> qq = ['Зеленкина', 'Криви', 'Цветкова', 'Капитонов']
+>>> print(qq)  
+    ['Зеленкина', 'Криви', 'Цветкова', 'Капитонов']
+>>> ff = zip(gg, qq)
+>>> print(ff) 
+    <zip object at 0x00000170234FAF40>
+>>> result_tuple = tuple(ff)
+>>> print(result_tuple)
+    ((76, 'Зеленкина'), (85, 'Криви'), (94, 'Цветкова'), (103, 'Капитонов'))
+```
+Количество элементов в ff равно минимальной длине из исходных списков gg и qq, то есть длине списка qq.
+Проверим, можно ли к объекту ff обращаться с указанием индекса.
+
+```py
+>>> print(result_tuple[0]) 
+    (76, 'Зеленкина')
+>>> print(result_tuple[2]) 
+    (94, 'Цветкова')
+```
+К объекту ff  можно обращаться с указанием индекса.
+
+#### п. 2.4.
+Функция __eval__ – вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки.
+```py
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+>>> print(fff, dan)
+    коэффициент усиления=3
+    3.0 -141.0
+```
+
+#### п. 2.5.
+Похожая на __eval__ функция __exec__ – чтение и выполнение объекта-аргумента функции. Напишем и выполним код по инструкции:
+```py
+>>> exec(input('введите инструкции:'))
+    введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+```
+Убедимся, что появился числовой объект с именем gg и со значением 221.456.
+```py
+>>> gg
+    221.456
+>>> perem
+    -123.456
+```
+
+#### п. 2.6.
+Самостоятельно изучим и попробуем применить функции abs, pow, max, min, sum, divmod, len, map. 
+```py
+>>> print(abs(-7.5)) 
+    7.5
+>>> print(pow(3, 4))
+    81
+>>> numbers = [5, 2, 8, 1]
+>>> print(max(numbers))  
+    8
+>>> print(min(numbers)) 
+    1
+>>> print(sum(numbers))
+    16
+>>> a, b = divmod(17, 5)
+>>> print(a, b)
+    3 2
+>>> text = "Hello"
+>>> print('len("Hello") =', len(text))
+    5
+numbers = [1, 2, 3, 4]
+text_numbers = list(map(str, numbers))
+print(text_numbers)
+    ['1', '2', '3', '4']
+```
+
+## 3. Модуль math.
+Функции из стандартного модуля __math__ – совокупность разнообразных математических функций. Загрум модуль math с помощью инструкции. Затем узнаем содержание модуля с помощью
+функции _dir_. Изучим функцию расчета факториала __factorial__ с помощью функции __help__ и попробуем использовать эту функцию.
+_Обращение к функциям из импортированного модуля осуществляется с указанием имени модуля, по образцу:  <имя модуля>.<имя функции>(<аргументы функции>)_
+```py
+>>> import math
+>>> print(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', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+    Help on built-in function factorial in module math:
+        factorial(n, /)
+        Find n!.
+    Raise a ValueError if x is negative or non-integral.
+>>> print(math.factorial(5))
+    120
+```
+Аналогичным образом изучим и попробуем применить некоторые другие функции из этого модуля: _sin, acos, degrees, radians, exp, log, log10, sqrt, ceil, floor, pi._
+```py
+>>> import math
+>>> print(math.factorial(5))
+    120
+>>> print(math.sin(math.pi/2))
+    1.0
+>>> print(math.acos(0.5))
+    1.0471975511965979
+>>> print(math.degrees(math.pi))
+    180.0
+>>> print(math.radians(180))
+    3.141592653589793
+>>> print(math.exp(1))
+    2.718281828459045
+>>> print(math.log(100))
+    4.605170185988092
+>>> print(math.log10(100))
+    2.0
+>>> print(math.sqrt(25))
+    5.0
+>>> print(math.ceil(4.2))
+    5
+>>> print(math.floor(4.9))
+    4
+>>> print(math.pi)
+    3.141592653589793
+```
+Решение примера sin(2π/7+e0.23 ):
+```py
+>>> result = math.sin(2 * math.pi / 7 + math.exp(0.23))
+>>> print(result)
+    0.8334902641414562
+```
+
+## 4. Модуль cmath. 
+Функции из модуля __cmath__ – совокупность функций для работы с комплексными числами.
+Начнём с импорта модуля, затем отобразим его атрибуты и изучим функцию для извлечения квадратного корня из комплексного числа и и функцию расчета фазы.
+```py
+>>> import cmath
+>>> print(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']
+>>> print(cmath.sqrt(1.2-0.5j))
+    (1.118033988749895-0.22360679774997896j)
+>>> print(cmath.phase(1-0.5j))
+    -0.4636476090008061
+```
+
+## 5. Модуль random.
+Стандартный модуль __random__ – совокупность функций для выполнения операций с псевдослучайными числами и выборками.
+```py
+>>> import random
+>>> print(dir(random))
+    ['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'binomialvariate', '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.
+>>> print(random.seed())
+    None
+```
+
+Далее самостоятельно изучим и попробуем применить следующие функции:
+```py
+>>> import random
+>>> random.seed(42)
+>>> print(random.random())
+    0.6394267984578837
+>>> print(random.uniform(10, 20))
+    10.25010755222667
+>>> print(random.randint(1, 6))
+    3
+>>> print(random.gauss(0, 1))
+    0.017593105583573694
+
+>>> fruits = ["яблоко", "банан", "апельсин", "киви"]
+>>> print(random.choice(fruits))
+    яблоко
+>>> cards = ["Туз", "Король", "Дама", "Валет"]
+>>> random.shuffle(cards)
+>>> print(cards)
+    ['Валет', 'Король', 'Дама', 'Туз']
+>>> numbers = list(range(1, 51))
+>>> print(random.sample(numbers, 5))
+    [3, 2, 6, 14, 15]
+>>> print(random.betavariate(2, 5))
+    0.3918844780644009
+>>> print(random.gammavariate(2, 1))
+    2.219353519271194
+>>> print(random.randint(100, 999))
+    703
+>>> print(random.uniform(-5, 5))
+    -2.218092917693373
+```
+
+Создадим список с 4 случайными значениями, подчиняющимися, соответственно, равномерному, нормальному, бета и гамма:
+```py
+random_values = [random.uniform(0, 1), random.gauss(0, 1), random.betavariate(2, 5), random.gammavariate(2, 1)]
+print(random_values)
+    [0.869300320792934, 0.5479616463399781, 0.33952976689383546, 0.5704217216825608]
+```
+
+## 6. Модуль time.
+Функции из модуля __time__ – работа с календарем и со временем.
+```py
+>>> import time
+>>> print(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()
+>>> print(c1)
+    1757970835.4250033
+```
+Изучим функцию __time__, возвращающую время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г.
+```py
+>>> c2=time.time()-c1
+>>> print(c2)
+    0.022925376892089844
+```
+Теперь изучим функцию __gmtime__.
+```py
+>>> dat=time.gmtime()
+>>> print(dat)
+    time.struct_time(tm_year=2025, tm_mon=9, tm_mday=15, tm_hour=21, tm_min=16, tm_sec=35, tm_wday=0, tm_yday=258, tm_isdst=0)
+>>> print(dat.tm_mon)
+    9
+```
+__ Функция localtime()__ - местное время:
+```py
+>>> local_time = time.localtime()
+>>> print(local_time.tm_year)
+    2025
+>>> print(local_time.tm_mon)
+    9
+>>> print(local_time.tm_mday)
+    18
+>>> print(local_time.tm_hour)
+    10
+>>> print(local_time.tm_min)
+    11
+>>> print(local_time.tm_sec)
+    12
+```
+__Функция asctime()__ - ппреобразование представления времени из кортежа в строку:
+```py
+time_str = time.asctime(local_time)
+print(time_str)
+    Thu Sep 18 10:22:12 2025
+```
+__Функция ctime()__ - преобразование времени в секундах, прошедшего с начала эпохи, в строку:
+```py
+>>> current_seconds = time.time()
+>>> print(current_seconds)
+    1758180132.4304066
+>>> time_from_seconds = time.ctime(current_seconds)
+>>> print(time_from_seconds)
+    Thu Sep 18 10:22:12 2025
+```
+
+__Функция sleep()__ - прерывание работы программы на заданное время:
+```py
+>>> print("Начинаем отсчет...")
+>>> for i in range(3, 0, -1):
+>>>    print(f"{i}...")
+>>>    time.sleep(2)
+>>> print("Запуск!")
+```
+Вывод программы:
+```py
+Начинаем отсчет...
+3...
+2...
+1...
+Запуск!
+```
+Числа выводлись через 2 секунды.
+
+__Функция mktime()__ - преобразование времени из типа кортежа или struct_time в число секунд с начала эпохи.
+```py
+>>> seconds_from_struct = time.mktime(local_time)
+>>> print(seconds_from_struct)
+    1758180480.0
+```
+Обратное преобразование из секунд в местное время осуществляется той же функцией localtime():
+```py
+>>> print(time.localtime(c1))
+    time.struct_time(tm_year=2025, tm_mon=9, tm_mday=18, tm_hour=10, tm_min=29, tm_sec=52, tm_wday=3, tm_yday=261, tm_isdst=0)
+```
+
+## 7. Графические функции.
+Импортируем модуль с инструкцией. Создадим два списка, один из которых будет содержать значения сигнала x, а другой – моменты времени измерения значений сигнала t. После этого введем инструкции создания и отображения графика x(t):
+```py
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+pylab.plot(t, x) 
+pylab.title('Первый график')
+pylab.xlabel('время')
+pylab.ylabel('сигнал')
+pylab.show() 
+```
+
+Мы полчили:
+
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+Изучим содержание окна с появившимся графиком и сохраним график в текущем каталоге в файле с именем __Ris1__. 
+Рассмотрим способ построения нескольких графиков на одном рисунке. Для этого создадим два списка:
+
+```py
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+>>> pylab.plot(X2)
+>>> pylab.show()
+```
+<img src = "./photo2.png" width="500" height="300" align="center">
+
+
+Теперь изучим возможность построения круговой диаграммы:
+```py
+>>> region=['Центр','Урал','Сибирь','Юг']  
+>>> naselen=[65,12,23,17] 
+>>> pylab.pie(naselen,labels=region) 
+>> pylab.show() 
+```
+<img src = "./photo3.png" width="500" height="300" align="center">
+
+Самостоятельно изучим и попробуем применить функции __hist__ и __bar__ для построения гистограмм и столбиковых диаграмм. 
+
+__hist__
+
+```py
+>>>> import matplotlib.pyplot as plt
+>>> assessments = [3, 4, 5, 3, 4, 5, 5, 4, 3, 2, 4, 5, 3, 4, 5, 4, 3, 5, 4, 3]
+>>> plt.hist(assessments, bins=5, color='lightblue', edgecolor='black')
+>>> plt.xlabel('Оценки')
+>>> plt.ylabel('Количество студентов')
+>>> plt.title('Распределение оценок студентов')
+>>> plt.show()
+```
+<img src = "./photo4.png" width="500" height="300" align="center">
+
+
+__bar__
+```py
+>>> fruits = ['Яблоки', 'Бананы', 'Апельсины', 'Груши']
+>>> count = [25, 30, 15, 20]
+>>> color = ['red', 'yellow', 'orange', 'green']
+>>> plt.bar(fruits, count, color=color)
+>>> plt.ylabel('Количество')
+>>> plt.title('Любимые фрукты')
+>>> plt.show()
+```
+<img src = "./photo5.png" width="500" height="300" align="center">
+
+
+__statistics__
+Изучим состав статистического модуля __statistics__:
+```py
+>>> import statistics
+>> print(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', '_rank', '_sqrt_bit_width', '_ss', '_sum', 'bisect_left', 'bisect_right', 'correlation', 'count', 'covariance', 'defaultdict', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean', 'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'linear_regression', 'log', 'math', 'mean', 'median', 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'namedtuple', 'numbers', 'pstdev', 'pvariance', 'quantiles', 'random', 'reduce', 'repeat', 'sqrt', 'stdev', 'sumprod', 'sys', 'tau', 'variance']
+```
+Рассмотрим три функции:
+```py
+>>> data = [1, 2, 3, 4, 5, 5, 6]
+>>> print("Mean:", statistics.mean(data))
+>>> print("Median:", statistics.median(data))
+>>> print("Mode:", statistics.mode(data))
+>>> print("Stdev:", statistics.stdev(data))
+    Mean: 3.7142857142857144
+    Median: 4
+    Mode: 5
+    Stdev: 1.7994708216848747
+```
+
+## Завершение работы.

TEMA5/Task.md

@@ -0,0 +1,106 @@
+# Общее контрольное задание по теме 5
+Зеленкина Ксения, А-02-23
+
+## Задание 1
+
+Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+## Решение
+_Код:_
+```py
+text = "Create a new string object from the given object."
+sl = {}
+for x in text:
+    if x.isalpha() == True:
+        a  = x.lower()
+        pos = ord(a) - ord('a') + 1
+        sl[a] = pos
+for l in sl:
+    print(f"{l}: {sl[l]}")
+```
+
+_Вывод:_
+```py
+C: 3
+r: 18
+e: 5
+a: 1
+t: 20
+n: 14
+w: 23
+s: 19
+i: 9
+g: 7
+o: 15
+b: 2
+j: 10
+c: 3
+f: 6
+m: 13
+h: 8
+v: 22
+```
+
+## Задание 2
+
+Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+## Решение
+_Код:_
+```py
+spis = ["список", "со", "словами", "из", "задания", "данного", "пункта"]
+word1 = "список"
+word2 = "программа"
+
+if word1 in spis:
+    print(f"'{word1}' есть в списке!")
+else:
+    print(f"'{word1}' нет в списке!")
+
+if word2 in spis:
+    print(f"'{word2}' есть в списке!")
+else:
+    print(f"'{word2}' нет в списке!")
+```
+
+_Вывод:_
+```py
+'список' есть в списке!
+'программа' нет в списке!
+```
+
+## Задание 3
+Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+_Код:_
+```py
+studentsSum = ["Зеленкина", "Криви", "Капитонов", "Хатюхин"]
+gradesSum = [4.5, 3.8, 4.2, 4.9]
+studentsWin = ["Криви", "Хатюхин", "Зеленкина", "Капитонов"]
+gradesWin = [4.1, 4.7, 4.3, 4.0]
+print(f"Список студентов: {studentsSum}")
+surname = input("Введите фамилию студента из списка: ")
+if surname in studentsSum:
+    inds = studentsSum.index(surname)
+    gs = gradesSum[inds]
+    print(f"Летняя сессия: {gs}")
+else:
+    print("Такой студент не найден")
+
+if surname in studentsWin:
+    indw = studentsWin.index(surname)
+    gw = gradesWin[indw]
+    print(f"Зимняя сессия: {gw}")
+else:
+    print("Такой студент не найден")
+```
+
+_Вывод:_
+```py
+Список студентов: ['Зеленкина', 'Криви', 'Капитонов', 'Хатюхин']
+Введите фамилию студента из списка: Криви
+Летняя сессия: 3.8
+Зимняя сессия: 4.1
+```
+

TEMA5/Task.py

@@ -0,0 +1,47 @@
+#1
+text = "Create a new string object from the given object."
+sl = {}
+for x in text:
+    if x.isalpha() == True:
+        a  = x.lower()
+        pos = ord(a) - ord('a') + 1
+        sl[a] = pos
+for l in sl:
+    print(f"{l}: {sl[l]}")
+
+#2
+spis = ["список", "со", "словами", "из", "задания", "данного", "пункта"]
+word1 = "список"
+word2 = "программа"
+
+if word1 in spis:
+    print(f"'{word1}' есть в списке!")
+else:
+    print(f"'{word1}' нет в списке!")
+
+if word2 in spis:
+    print(f"'{word2}' есть в списке!")
+else:
+    print(f"'{word2}' нет в списке!")
+
+#3
+studentsSum = ["Зеленкина", "Криви", "Капитонов", "Хатюхин"]
+gradesSum = [4.5, 3.8, 4.2, 4.9]
+studentsWin = ["Криви", "Хатюхин", "Зеленкина", "Капитонов"]
+gradesWin = [4.1, 4.7, 4.3, 4.0]
+print(f"Список студентов: {studentsSum}")
+surname = input("Введите фамилию студента из списка: ")
+if surname in studentsSum:
+    inds = studentsSum.index(surname)
+    gs = gradesSum[inds]
+    print(f"Летняя сессия: {gs}")
+else:
+    print("Такой студент не найден")
+
+if surname in studentsWin:
+    indw = studentsWin.index(surname)
+    gw = gradesWin[indw]
+    print(f"Зимняя сессия: {gw}")
+else:
+    print("Такой студент не найден")
+

TEMA5/Test.md

@@ -0,0 +1,29 @@
+# Индивидуальные контрольные задания по теме 5
+Зеленкина Ксения А-02-23
+
+## Задача
+Создайте символьную строку с текстом: «я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство». Напишите инструкции, позволяющие определить, каких букв русского алфавита нет в этой строке.
+
+## Решение
+_Код:_
+```py
+stroka = 'я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство'
+RusAlph = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+HChar = set()
+for x in stroka.lower():
+    if x in RusAlph :
+        HChar.add(x)
+
+NHChar = []
+for i in RusAlph:
+    if i not in HChar:
+        NHChar.append(i)
+
+print(f'Буквы, которых нет в строке: {NHChar}')
+```
+
+_Вывод:_
+```py
+Буквы, которых нет в строке: ['ё', 'п', 'ы']
+```
+_Примечание:_ Используем множество (__HChar__), так как оно хранит только уникальные значения!

TEMA5/Test.py

@@ -0,0 +1,15 @@
+#Создайте символьную строку с текстом: «я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство». Напишите инструкции, позволяющие определить, каких букв русского алфавита нет в этой строке.
+
+stroka = 'я, великий и могучий юноша-вождь с мечом и щитом захватил и объединил эфесское царство'
+RusAlph = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'
+HChar = set()
+for x in stroka.lower():
+    if x in RusAlph :
+        HChar.add(x)
+
+NHChar = []
+for i in RusAlph:
+    if i not in HChar:
+        NHChar.append(i)
+
+print(f'Буквы, которых нет в строке: {NHChar}')

TEMA5/report.py

@@ -0,0 +1,139 @@
+# Тема 5 < Зеленкина Ксения Михайловна>
+# 2.
+# Пример 1.
+porog, rashod1, rashod2 = 3, 120, 50
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8
+print(dohod)
+
+# Пример 2.
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+print(dohod)
+
+# Пример 3
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+print(dohod)
+
+
+# В одну строчку
+# Пример 1
+dohod=2 if porog>=4 else 0
+print(dohod)
+
+# Пример 2
+porog = 10
+if porog>=5 : rashod1=6; rashod2=0
+print(rashod1, rashod2)
+
+# 3.1
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+	print(temperatura)
+
+# 3.2
+# Пример 1
+sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+
+#Пример 2
+sps=[2,15,14,8]
+for k in sps[:]:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+
+# 3.3
+import random as rn
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+# 3.4
+stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss
+print(stroka1)
+
+# 3.5.
+import math
+import matplotlib.pyplot as plt
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+x = list(range(100))
+
+plt.figure(figsize=(12, 6))
+plt.plot(x, sps2, 'b-', linewidth=1, label='sin(i*π/5 + 2)')
+plt.title('График сигнала: sin(i*π/5 + 2)')
+plt.xlabel('i (индекс)')
+plt.ylabel('Значение sin(i*π/5 + 2)')
+plt.show()
+
+
+# 4.1
+rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+# 4.2
+import math
+import matplotlib.pyplot as plt
+stroka='Расчет процесса в объекте регулирования'
+i=0
+sps2=[]
+while i<len(stroka):
+	r=1-2/(1+math.exp(0.1*i))
+	sps2.append(r)
+	print('Значение в момент',i,"=",r)
+	i+=1
+plt.figure(figsize=(12, 6))
+plt.plot(sps2, 'b-', linewidth=2, label='Выход инерционного звена')
+plt.title('Сигнал на выходе инерционного звена')
+plt.xlabel('Время (момент i)')
+plt.ylabel('Значение r')
+plt.grid(True, alpha=0.3)
+plt.legend()
+plt.show()
+
+#4.3.
+chislo=267   #Проверяемое число
+kandidat =chislo // 2 		# Для значений chislo > 1
+while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+
+# Дополненный код
+for chislo in range(250, 301):
+	kandidat = chislo // 2
+	while kandidat > 1:
+		if chislo % kandidat == 0:
+			break
+		kandidat -= 1
+	else:
+		print(chislo, 'является простым!')
+

TEMA5/report5.md

@@ -0,0 +1,263 @@
+# Отчет по Теме 5
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Условный оператор.
+Изучила ветвление по условию – управляющая инструкция __if__. 
+Задала некоторые числовые значения объектам __porog__, __rashod1__, __rashod2__. Выполните следующую операцию, определив значение __dohod__:
+
+_Пример 1:_
+ ```py
+porog, rashod1, rashod2 = 3, 120, 50
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+	 	dohod=-8
+print(dohod)
+ ```
+ 
+__Результат:__
+```py
+12
+```
+Выполним ещё одну операцию, определив значение __dohod__:
+_Пример 2:_
+ ```py
+if rashod1>=3 and rashod2==4:
+ 		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+ 			dohod=porog
+print(dohod)
+ ```
+ __Результат:__
+```py
+12
+```
+Ещё одна операция с множественным ветвлением линий потока:
+_Пример 3:_
+```py
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+print(dohod)
+```
+ __Результат:__
+```py
+1
+```
+Условные инструкции можно записываться также в одну строку в операторе присваивания. Изучим примеры:
+_Пример 1:_
+```py
+dohod=2 if porog>=4 else 0
+```
+ __Результат:__
+ ```py
+ 0
+ ```
+ 
+ _Пример 2:_
+```py
+porog = 10
+if porog>=5 : rashod1=6; rashod2=0
+print(rashod1, rashod2)
+```
+ __Результат:__
+ ```py
+ 6 0
+ ```
+ 
+## 3. Цикл по перечислению.
+ Цикл по перечислению – управляющая инструкция for. 
+#### 3.1.
+ Выполним простой цикл:
+ ```py
+ temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+	print(temperatura)
+ ```
+  __Результат:__
+ ```py
+8
+14
+23
+35
+50
+ ```
+#### 3.2.
+ Выполним более сложный цикл:
+ ```py
+ sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+ ```
+  __Результат:__
+ ```py
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+ ```
+ Выполним чуть-чуть отличающуюся совокупность операций:
+ ```py
+sps=[2,15,14,8]
+for k in sps[:]:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+print(sps)
+ ```
+   __Результат:__
+ ```py
+[2, 15, 14, 8, 2, 2, 2, 2]
+ ```
+#### 3.3.
+ Пример: создание списка с 10 целыми случайными числами из диапазона от 1 до 100. При этом, если сумма чисел не превышает 500, эта сумма должна быть отображена на экране.
+ ```py
+ import random as rn
+sps5=[]
+for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+ ```
+    __Результат:__
+ ```py
+1 раз: (пусто)
+2 раз: (пусто)
+3 раз: 316
+ ```
+ Вывод значения __ss__ бывает не всегда, потому что блок __else__ относится к циклу __for__ и выполняется только если цикл не был прерван __break__.
+ 
+ #### 3.4.
+ Пример с символьной строкой
+ ```py
+ stroka='Это – автоматизированная система'
+stroka1=""
+for ss in stroka:
+	stroka1+=" "+ss
+print(stroka1)
+ ```
+__Результат:__
+ ```py
+ Э т о   –   а в т о м а т и з и р о в а н н а я   с и с т е м а
+ ```
+ 
+#### 3.5.
+ Запись цикла в строке. Пример: создание списка с синусоидальным сигналом:
+ ```py
+ import math
+import matplotlib.pyplot as plt
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+x = list(range(100))
+plt.figure(figsize=(12, 6))
+plt.plot(x, sps2, 'b-', linewidth=1, label='sin(i*π/5 + 2)')
+plt.title('График сигнала: sin(i*π/5 + 2)')
+plt.xlabel('i (индекс)')
+plt.ylabel('Значение sin(i*π/5 + 2)')
+plt.show()
+ ```
+__График:__
+ <img src = "./photo1.png" width="500" height="400" align="center">
+ 
+ ## 4. Цикл «пока истинно условие» 
+ Цикл «пока истинно условие» – управляющая инструкция __while__.
+ #### 4.1.
+ Цикл со счетчиком:
+ ```py
+ rashod=300
+while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+ ```
+__Результат:__
+ ```py
+ Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+```
+Цикл завершился, потому что условие __while rashod__: стало ложным, когда __rashod__ достиг нуля.
+
+#### 4.2.
+ Пример с символьной строкой.
+ ```py
+ import math
+import matplotlib.pyplot as plt
+stroka='Расчет процесса в объекте регулирования'
+i=0
+sps2=[]
+while i<len(stroka):
+	r=1-2/(1+math.exp(0.1*i))
+	sps2.append(r)
+	print('Значение в момент',i,"=",r)
+	i+=1
+plt.figure(figsize=(12, 6))
+plt.plot(sps2, 'b-', linewidth=2, label='Выход инерционного звена')
+plt.title('Сигнал на выходе инерционного звена')
+plt.xlabel('Время (момент i)')
+plt.ylabel('Значение r')
+plt.grid(True, alpha=0.3)
+plt.legend()
+plt.show()
+ ```
+ 
+__График:__
+ <img src = "./photo2.png" width="500" height="400" align="center">
+
+#### 4.3.
+Определим, является ли число простым (делится только на самого себя или 1).
+```py
+chislo=267   #Проверяемое число
+kandidat =chislo // 2 		
+while kandidat > 1:
+	if chislo%kandidat == 0: 
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+```
+__Результат:__
+ ```py
+ 267  имеет множитель  89
+ ```
+ 
+ Дополним программу так, чтобы выявить все простые числа в диапазоне от 250 до 300.
+ ```py
+ for chislo in range(250, 301):
+	kandidat = chislo // 2
+	while kandidat > 1:
+		if chislo % kandidat == 0:
+			break
+		kandidat -= 1
+	else:
+		print(chislo, 'является простым!')
+ ```
+ 
+__Результат:__
+ ```py
+ 251 является простым!
+257 является простым!
+263 является простым!
+269 является простым!
+271 является простым!
+277 является простым!
+281 является простым!
+283 является простым!
+293 является простым!
+ ```
+
+## Завершение работы.

TEMA6/Stroka.txt

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

TEMA6/Task.md

@@ -0,0 +1,135 @@
+# Общее контрольное задание по теме 6
+Зеленкина Ксения, А-02-23
+
+## Задание 
+
+Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+#### Решение
+_Код:_
+```py
+import random
+num = list(range(1, 126, 1))
+tup = ()
+for i in num:
+    tup = tuple(tup + (random.randint(6, 56),))
+str_tup = tuple(map(str, tup))
+print(str_tup)
+```
+
+_Вывод:_
+```py
+('49', '46', '53', '24', '54', '8', '47', '48', '43', '43', '9', '8', '43', '14', '39', '17', '49', '47', '34', '18', '37', '39', '17', '30', '9', '19', '56', '8', '15', '36', '31', '52', '20', '26', '40', '15', '14', '29', '37', '48', '55', '16', '36', '34', '53', '10', '26', '37', '10', '53', '48', '49', '33', '38', '44', '33', '23', '18', '54', '8', '19', '42', '49', '18', '8', '22', '16', '9', '14', '54', '29', '9', '52', '55', '13', '27', '13', '46', '29', '13', '11', '37', '20', '21', '24', '27', '53', '39', '25', '40', '20', '33', '15', '24', '33', '18', '40', '35', '11', '52', '44', '10', '53', '29', '35', '42', '8', '42', '18', '19', '6', '55', '23', '34', '49', '46', '10', '20', '46', '26', '43', '25', '43', '29', '12')
+```
+
+## Задание 
+Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+#### Решение
+_Код:_
+```py
+surname = ["Зеленкина", "Криви", "Капитонов", "Хатюхин", "Шабатов"]
+print("Создан список фамилий:", surname)
+```
+_Вывод:_
+```py
+Создан список фамилий: ['Зеленкина', 'Криви', 'Капитонов', 'Хатюхин', 'Шабатов']
+```
+
+## Задание 
+Записывается кортеж в бинарный файл.
+
+#### Решение
+_Код:_
+```py
+f = open('bin.mnz', 'wb')
+```
+
+## Задание 
+Записывается в этот же файл список и закрывается файл.
+
+#### Решение
+_Код:_
+```py
+pickle.dump(str_tup, f)
+pickle.dump(surname, f)
+f.close()
+```
+
+
+## Задание 
+Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+#### Решение
+_Код:_
+```py
+f = open('bin.mnz', 'rb')
+obj1 = pickle.load(f)
+obj2_spis = pickle.load(f)
+f.close()
+print("Прочитан кортеж:", obj1)
+print("Прочитан список:", obj2_spis)
+```
+_Вывод:_
+```py
+Прочитан кортеж: ('49', '46', '53', '24', '54', '8', '47', '48', '43', '43', '9', '8', '43', '14', '39', '17', '49', '47', '34', '18', '37', '39', '17', '30', '9', '19', '56', '8', '15', '36', '31', '52', '20', '26', '40', '15', '14', '29', '37', '48', '55', '16', '36', '34', '53', '10', '26', '37', '10', '53', '48', '49', '33', '38', '44', '33', '23', '18', '54', '8', '19', '42', '49', '18', '8', '22', '16', '9', '14', '54', '29', '9', '52', '55', '13', '27', '13', '46', '29', '13', '11', '37', '20', '21', '24', '27', '53', '39', '25', '40', '20', '33', '15', '24', '33', '18', '40', '35', '11', '52', '44', '10', '53', '29', '35', '42', '8', '42', '18', '19', '6', '55', '23', '34', '49', '46', '10', '20', '46', '26', '43', '25', '43', '29', '12')
+Прочитан список: ['Зеленкина', 'Криви', 'Капитонов', 'Хатюхин', 'Шабатов']
+```
+
+## Задание 
+Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+
+#### Решение
+_Код:_
+```py
+if obj1 == str_tup and obj2_spis == surname:
+    print("Объекты совпадают с исходными!")
+else:
+    print("Объекты не совпадают с исходными!")
+```
+_Вывод:_
+```py
+Объекты совпадают с исходными!
+```
+
+## Задание 
+Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+#### Решение
+_Код:_
+```py
+l = []
+for i in range(0, 125, 5):
+    l.append(list(str_tup[i:i + 5]))
+for i in range(25):
+    list_name = f"list{i + 1}"
+    globals()[list_name] = l[i]
+    print(f"{list_name} = {l[i]}")
+```
+_Вывод:_
+```py
+list1 = ['49', '46', '53', '24', '54']
+list2 = ['8', '47', '48', '43', '43']
+list3 = ['9', '8', '43', '14', '39']
+list4 = ['17', '49', '47', '34', '18']
+list5 = ['37', '39', '17', '30', '9']
+list6 = ['19', '56', '8', '15', '36']
+list7 = ['31', '52', '20', '26', '40']
+list8 = ['15', '14', '29', '37', '48']
+list9 = ['55', '16', '36', '34', '53']
+list10 = ['10', '26', '37', '10', '53']
+list11 = ['48', '49', '33', '38', '44']
+list12 = ['33', '23', '18', '54', '8']
+list13 = ['19', '42', '49', '18', '8']
+list14 = ['22', '16', '9', '14', '54']
+list15 = ['29', '9', '52', '55', '13']
+list16 = ['27', '13', '46', '29', '13']
+list17 = ['11', '37', '20', '21', '24']
+list18 = ['27', '53', '39', '25', '40']
+list19 = ['20', '33', '15', '24', '33']
+list20 = ['18', '40', '35', '11', '52']
+list21 = ['44', '10', '53', '29', '35']
+list22 = ['42', '8', '42', '18', '19']
+list23 = ['6', '55', '23', '34', '49']
+list24 = ['46', '10', '20', '46', '26']
+list25 = ['43', '25', '43', '29', '12']
+```

TEMA6/Task.py

@@ -0,0 +1,37 @@
+import random
+import os
+import pickle
+
+num = list(range(1, 126, 1))
+tup = ()
+for i in num:
+    tup = tuple(tup + (random.randint(6, 56),))
+str_tup = tuple(map(str, tup))
+print(str_tup)
+surname = ["Зеленкина", "Криви", "Капитонов", "Хатюхин", "Шабатов"]
+print("Создан список фамилий:", surname)
+
+f = open('bin.mnz', 'wb')
+pickle.dump(str_tup, f)
+pickle.dump(surname, f)
+f.close()
+
+f = open('bin.mnz', 'rb')
+obj1 = pickle.load(f)
+obj2_spis = pickle.load(f)
+f.close()
+print("Прочитан кортеж:", obj1)
+print("Прочитан список:", obj2_spis)
+
+if obj1 == str_tup and obj2_spis == surname:
+    print("Объекты совпадают с исходными!")
+else:
+    print("Объекты не совпадают с исходными!")
+
+l = []
+for i in range(0, 125, 5):
+    l.append(list(str_tup[i:i + 5]))
+for i in range(25):
+    list_name = f"list{i + 1}"
+    globals()[list_name] = l[i]
+    print(f"{list_name} = {l[i]}")

TEMA6/report.md

@@ -0,0 +1,550 @@
+# Отчет по Теме 6
+
+Зеленкина Ксения, А-02-23
+
+## 1. Начало работы.
+Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия.
+
+## 2. Вывод данных на экран дисплея.
+#### 2.1. Вывод в командной строке.
+Cодержимое любого объекта можно увидеть простым упоминанием его в командной строке (как это много раз делалось раньше), например:
+```py
+>> stroka='Автоматизированная система управления'
+>> stroka
+```
+_Вывод:_
+```py
+'Автоматизированная система управления'
+```
+Этот способ называется __«эхо-выводом»__.
+
+
+#### 2.2. Вывод с использованием функции  __print__.
+Пример вывода:
+```py
+>> fff=234.5;gg='Значение температуры = '
+>> print(gg, fff)
+```
+
+_Вывод:_
+```py
+Значение температуры =  234.5
+```
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе _sep_, например:
+
+```py
+print(gg, fff, sep='/')
+```
+ _Вывод:_
+```py
+Значение температуры = /234.5
+
+```
+После вывода автоматически осуществляется переход на другую строку. Если курсор надо оставить в той же строке, то следует использовать еще один аргумент, например:
+
+```py
+print(gg, fff,sep='/',end='***'); print('____')
+```
+
+ _Вывод:_
+```py
+Значение температуры = /234.5***____
+```
+После end= надо указать какими символами должна закончиться выводимая строка или указать пустую строку. Наоборот, если в какой-то момент требуется просто перейти на новую строку, можно использовать такое обращение к функции:
+
+```py
+print()
+```
+
+Оператор вывода может располагаться на нескольких строках с использованием тройных кавычек:
+```py
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+```
+_Вывод:_
+```py
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+```
+Или
+
+```py
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+```
+
+_Вывод:_
+```py
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+#### 2.3. Вывод с использованием метода __write__  объекта __sys.stdout__.
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы выводят символьное представление данных. Обычно это – экран дисплея. Объект находится в модуле sys, который надо импортировать. Например:
+```py
+import sys
+sys.stdout.write('Функция write')
+```
+_Вывод:_
+```py
+Функция write
+```
+
+Этот метод после вывода строки не осуществляет переход на новую строку. Если это требуется, то следует в конце строки добавить один или несколько символов “\n”:
+
+```py
+sys.stdout.write('Функция write\n')
+```
+_Вывод:_
+```py
+Функция write
+
+```
+
+## 3. Ввод данных с клавиатуры.
+Для ввода используйте уже знакомую функцию _input__. Например:
+
+```py
+psw=input('Введите пароль:')
+```
+
+_Вывод:_
+```py
+Введите пароль:12345
+
+```
+Посмотрим тип данной переменной:
+```py
+print(type(psw))
+```
+
+_Вывод:_
+```py
+<class 'str'>
+```
+
+_Пример 1._ Ввод с контролем значения. Пусть вводится число, которое должно находиться в интервале значений от 17.5 до 23.8.
+```py
+while True:
+	znach=float(input('Задайте коэф.усиления = '))
+	if znach<17.5 or znach>23.8:
+		print('Ошибка!')
+	else:
+		break
+```
+
+_Вывод:_
+```py
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+_Пример 2_. Ввод и обработка выражения, подлежащего расчету.
+```py
+import math
+print(eval(input('введите выражение для расчета = ')))
+```
+
+_Вывод:_
+```py
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4. Ввод-вывод при работе с файлами.
+#### 4.1. Функции для работы с путем к файлу.
+
+Как и в других системах, в среде __Python__ в любой момент времени подразумевается некоторый рабочий каталог. Какой рабочий каталог установлен в текущий момент времени? Это  можно узнать с помощью функцииos.getcwd (cwd = current working directory):
+```py
+import os
+os.getcwd()
+```
+
+_Вывод:_
+'C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6'
+```
+
+Сохраним этот путь в переменной с именем, совпадающим с моей фамилией в латинской транскрипции. Отобразите её значение с помощью функции __print__.
+
+```py
+import os
+ZelenkinaKs = os.getcwd()
+print(ZelenkinaKs)
+```
+
+_Вывод:_
+```py
+'C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6'
+```
+
+Изменить расположение рабочего каталога можно обращением к уже многократно применявшейся функции __os.chdir__, аргументом которой будет символьная строка с указанием пути к каталогу, назначаемому в качестве рабочего, например:
+
+```py
+os.chdir('C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA5')
+print(os.getcwd())
+```
+_Вывод:_
+```py
+'C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA5'
+```
+
+Самостоятельно изучим и попробуем использовать следующие функции из модуля __os__: _mkdir, rmdir, listdir и функцию isdir из вложенного в os модуля os.path_.
+```py
+import os
+from os.path import isdir
+# Создание папки
+os.mkdir("test_folder")
+# Проверка существования папки
+print(isdir("test_folder"))
+# Просмотр содержимого текущей директории
+print(os.listdir())
+# Просмотр содержимого конкретной папки
+print(os.listdir("test_folder"))
+# Удаление папки (должна быть пустой)
+os.rmdir("test_folder")
+# Проверка после удаления
+print(isdir("test_folder"))
+```
+_Вывод:_
+```py
+True
+['.gitkeep', 'protocol6.py', 'test_folder']
+[]
+False
+```
+
+Изучили и выяснили, что:
+__mkdir()__ - создает одну папку
+__rmdir()__ - удаляет только пустые папки
+__listdir()__ - возвращает список содержимого
+__isdir()__ - проверяет, является ли путь папкой
+
+Пусть в рабочем каталоге находится файл Отчет6.md. С помощью функции __os.path.abspath__ получим символьную строку, содержащую имя файла вместе с полным  путем доступа к нему:
+
+```py
+fil=os.path.abspath("Отчет6.md")
+print(fil)
+```
+_Вывод:_
+```py
+C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA6\Отчет6.md
+```
+Выделим путь доступа к файлу из строки, содержащей и этот путь, и имя файла  с помощью функции __os.path.dirname__:
+```py
+drkt=os.path.dirname(fil)
+print(drkt))
+```
+_Вывод:_
+```py
+C:\Users\user\OneDrive\Documents\ZelenkinaKs\python-labs\TEMA6
+```
+Наоборот, выделим имя файла из этой строки с отбрасыванием пути с помощью функции __os.path.basename__. 
+```py
+nameFile = os.path.basename(fil)
+print(nameFile)
+```
+_Вывод:_
+```py
+Отчет6.md
+```
+
+Самостоятельно изучим функцию __os.path.split__:
+```py
+SplitFile = os.path.split(fil)
+print(SplitFile)
+```
+_Вывод:_
+```py
+('C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6', 'Отчет6.md')
+```
+__os.path.split(path)__ - возвращает кортеж (путь, имя_файла)
+
+С помощью функции __os.path.exists__ можно проверить существует ли путь, заданный в символьной строке – аргументе функции.
+```py
+print(os.path.exists("\\python-labs\\TEMA6"))
+print(os.path.exists("C:\\Users\\user\\"))
+print(os.path.exists("Отчет6.md"))
+print(os.path.exists("."))
+```
+_Вывод:_
+```py
+False
+True
+True
+True
+```
+__os.path.exists()__ - проверяет существование пути.
+
+Проверим наличие файла с известным расположением с помощью функции __os.path.isfile__, аргументом которой должна быть символьная строка с путем и именем интересующего файла.
+```py
+exists = os.path.isfile("C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6\\Отчет6.md")
+print(exists)
+```
+_Вывод:_
+```py
+True
+```
+
+#### 4.2. Общая схема работы с файлом.
+Для обмена данными с файлом необходимо выполнить следующие операции:
+	• Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+	• Выполнение одной или нескольких операций обмена данными с файлом;
+	• Закрытие файла.
+
+#### 4.3. Открытие файла для записи или чтения данных – функция __open__.
+При открытии файла необходимо указать имя файлы (с путем, если он не в рабочем каталоге) и цель работы с ним. Для открытия используется функция __open__. 
+Открываем файл zapis1.txt для записи разными способами:
+```py
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+print(type(fp))
+```
+_Вывод:_
+```py
+<class '_io.TextIOWrapper'>
+```
+
+Более короткая запись (без имен аргументов):
+```py
+fp = open(drkt + '\\zapis1.txt', 'w')
+```
+
+Если файл в рабочем каталоге - путь можно опустить:
+Более короткая запись (без имен аргументов):
+```py
+fp = open('zapis1.txt', 'w')
+```
+
+Разные режимы открытия файла:
+	__w__ – запись с созданием нового файла или перезапись существующего файла,
+	__w+__ - чтение и запись/перезапись файла,
+	__r__ – только чтение (это значение - по умолчанию),
+	__r+__ - чтение и/или запись в существующий файл,
+	__a__ – запись в конец существующего файла или, если его нет, запись с созданием файла,
+	__a+__ - то же, что и в «a», но с возможностью чтения из файла.
+
+Бинарные файлы:
+fp_bin = open('data.bin', 'wb+') 
+
+Символьные файлы (по умолчанию):
+fp_text = open('data.txt', 'wt')
+
+#### 4.4. Закрытие файла.
+
+Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. Это делается с помощью метода __close__, применяемого к объекту – файловой переменной. Например:
+```py
+fp.close()
+```
+
+#### 4.5 Запись информации в файл с помощью метода __write__.
+Метод __write__ относится к объекту – файловой переменной.
+_Рассмотрим его применение  на следующем примере:_ создадим список с элементами-числами от 1 до 12 и запишите их в файл по 4 числа на строке:
+```py
+sps=list(range(1,13))
+fp2=open('zapis3.txt','w')
+fp2.write(str(sps[:4])+'\n')
+fp2.write(str(sps[4:8])+'\n')
+fp2.write(str(sps[8:])+'\n')
+fp2.close()
+```
+В файле появилась следующая запись:
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+Ещё один пример. Создадим список с элементами-списками:
+```py
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+```
+Пусть его элементы требуется построчно записать в файл zapis4.txt.
+Первая попытка:
+```py
+fp3=open('zapis4.txt','w')
+for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+fp3.close()
+```
+В файле появилась следующая запись:
+<img src = "./photo1.png" width="500" height="300" align="center">
+
+Тогда попробуйте  сделать так:
+```py
+gh = open('zapis5.txt', 'w')
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+gh.close()
+```
+
+_Вывод:_
+
+<img src = "./photo2.png" width="500" height="300" align="center">
+
+#### 4.6. Первый способ чтения информации из текстового файла.
+Прочитаем информацию из ранее созданного файла zapis3.txt.
+```py
+sps1=[]
+fp=open('zapis3.txt')
+for stroka in fp:
+	stroka=stroka.rstrip('\n')
+	stroka=stroka.replace('[','')
+	stroka=stroka.replace(']','')
+	sps1=sps1+stroka.split(',')
+fp.close()
+print(sps1)
+```
+_Вывод:_
+```py
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+```
+Обратим внимание, что в функции открытия файла использован только один аргумент, остальные – со значениями «по умолчанию».
+Здесь, перед занесением строки в список с помощью метода __rstrip__, из неё удаляется символ конца строки, а с помощью метода __replace__ – скобки.
+
+Список sps1 отличается от записи в файле тем, что:
+sps1 - это список строк, а содержимое zapis3.txt - это вывод нескольких списков целых чисел. Такде в sps1 каждый элемент это _строка_, а в содержимом zapis3.txt - это целые числа.
+ Подумаем, как сделать так, чтобы список, полученный при чтении из файла, совпал с исходным:
+```py
+sps1 = []
+fp = open('zapis3.txt')
+for stroka in fp:
+    stroka = stroka.rstrip('\n')
+    stroka = stroka.replace('[','')
+    stroka = stroka.replace(']','')
+    chisla_str = stroka.split(',')
+    chisla = [int(x) for x in chisla_str if x]
+    sps1.append(chisla)
+fp.close()
+for podspisok in sps1:
+    print(f"[{', '.join(map(str, podspisok))}]")
+```
+_Вывод:_
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+#### 4.7. Чтение информации из файла с помощью метода __read__.
+Метод __read()__ читает данные из файла (текстового или бинарного) и возвращает строку или байтовую последовательность. Можно указать, сколько символов/байт прочитать; если не указать - прочитает всё до конца файла. Например:
+```py
+fp=open('zapis3.txt')
+stroka1=fp.read(12)
+stroka2=fp.read()
+fp.close()
+print(stroka1)
+print(stroka2)
+```
+_Вывод:_
+```py
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+#### 4.8. Чтение информации с помощью методов __readline__ и __readlines__.
+__readline()__ читает одну строку из файла, начиная с текущей позиции. 
+__readlines()__ читает все строки, возвращая их в виде списка.
+```py
+fp=open('zapis3.txt')
+stroka3=fp.readline(5)
+stroka4=fp.readlines()
+print(stroka3)
+print(stroka4)
+```
+_Вывод:_
+```py
+[1, 2
+[', 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+```
+
+#### 4.9. Ввод-вывод объектов с использованием функций из модуля __pickle__.
+В модуле __pickle__ содержатся функции для работы с бинарными файлами, в которые могут последовательно записываться или считываться целиком один или несколько объектов из оперативной памяти. Рассмотрите этот способ работы с файлами на следующем примере:
+```py
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+fp.close()
+```
+_Вывод:_
+<img src = "./photo3.png" width="500" height="300" align="center">
+
+Теперь прочитаем данные из файла в объект __mnoz2__:
+```py
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+fp.close()
+print(mnoz2)
+```
+_Вывод:_
+```py
+{'book', 'pen', 'iPhone', 'table'}
+```
+Данные переменные имеют тип данных set, что является неупорядоченной коллекцией.
+__mnoz1__ и __mnoz2__ — это одно и то же множество, просто при его выводе на экран элементы могут быть показаны в разном порядке.
+
+А теперь с использованием тех же функций запишим в файл, а затем прочитаем два объекта разных типов: то же множество mnoz1 и ранее созданный список sps3. При считывании объекты извлекаются из файла в той же последовательности, в которой они в него записывались.
+```py
+fp = open('zapis7.2ob', 'wb')
+pickle.dump(mnoz1, fp)
+pickle.dump(sps3, fp)
+fp.close()
+fp = open('zapis7.2ob', 'rb')
+obj1 = pickle.load(fp)  # Первое обращение к load читает первый объект
+obj2 = pickle.load(fp)  # Второе – читает второй
+fp.close()
+print(obj1)
+print(mnoz1)
+print(obj2)
+print(sps3)
+```
+_Вывод:_
+```py
+{'book', 'table', 'iPhone', 'pen'}
+{'book', 'table', 'iPhone', 'pen'}
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+[['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+obj1 совпадает с mnoz1, а obj2 c sps3.
+
+#### 5.Перенаправление потоков ввода и вывода данных.
+```py
+import sys
+vr_out=sys.stdout  #Запоминаем текущий поток вывода
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+fc.close()
+```
+_Вывод:_
+```py
+запись строки на экран
+```
+В результате создан файл Stroka.txt в текущем каталоге с содержанием
+__'запись строки в файл'__
+Точно также можно перенаправить поток ввода – sys.stdin – вместо клавиатуры – из файла.
+```py
+import sys
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+print(sys.stdin)
+while True:
+    try:
+        line = input () #Считываем из файла строку
+        print(line)  # Отображаем считанное
+    except EOFError:
+        break
+fd.close()
+sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода
+```
+_Вывод:_
+```py
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+запись строки в файл
+```
+## Завершение работы.

TEMA6/report.py

@@ -0,0 +1,183 @@
+# ТЕМА 6 "Зеленкина Ксения Михайловна"
+
+## 2.2.
+fff=234.5;gg='Значение температуры = '
+print(gg, fff)
+print(gg, fff, sep="/")
+print(gg, fff,sep='/',end='***'); print('____')
+
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+
+## 2.3.
+import sys
+sys.stdout.write('Функция write')
+sys.stdout.write('Функция write\n')
+
+# 3.
+#psw=input('Введите пароль:')
+#print(type(psw))
+
+# Пример 1
+#while True:
+#	znach=float(input('Задайте коэф.усиления = '))
+#	if znach<17.5 or znach>23.8:
+#		print('Ошибка!')
+#	else:
+#		break
+
+#Пример 2
+#import math
+#print(eval(input('введите выражение для расчета = ')))
+
+## 4.1.
+import os
+ZelenkinaKs = os.getcwd()
+print(ZelenkinaKs)
+os.chdir('C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA5')
+print(os.getcwd())
+os.chdir('C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6')
+
+import os
+from os.path import isdir
+# Создание папки
+os.mkdir("test_folder")
+# Проверка существования папки
+print(isdir("test_folder"))
+# Просмотр содержимого текущей директории
+print(os.listdir())
+# Просмотр содержимого конкретной папки
+print(os.listdir("test_folder"))
+# Удаление папки (должна быть пустой)
+os.rmdir("test_folder")
+# Проверка после удаления
+print(isdir("test_folder"))
+
+fil=os.path.abspath("Отчет6.md")
+print(fil)
+drkt=os.path.dirname(fil)
+print(drkt)
+nameFile = os.path.basename(fil)
+print(nameFile)
+SplitFile = os.path.split(fil)
+print(SplitFile)
+print(os.path.exists("\\python-labs\\TEMA6"))
+print(os.path.exists("C:\\Users\\user\\"))
+print(os.path.exists("Отчет6.md"))
+print(os.path.exists("."))
+
+exists = os.path.isfile("C:\\Users\\user\\OneDrive\\Documents\\ZelenkinaKs\\python-labs\\TEMA6\\Отчет6.md")
+print(exists)
+
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+print(type(fp))
+fp.close()
+
+sps=list(range(1,13))
+fp2=open('zapis3.txt','w')
+fp2.write(str(sps[:4])+'\n')
+fp2.write(str(sps[4:8])+'\n')
+fp2.write(str(sps[8:])+'\n')
+fp2.close()
+
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+fp3=open('zapis4.txt','w')
+for i in range(len(sps3)):
+	stroka4=sps3[i][0]+' '+str(sps3[i][1])
+	fp3.write(stroka4)
+fp3.close()
+
+gh = open('zapis5.txt', 'w')
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+gh.close()
+
+sps1=[]
+fp=open('zapis3.txt')
+for stroka in fp:
+	stroka=stroka.rstrip('\n')
+	stroka=stroka.replace('[','')
+	stroka=stroka.replace(']','')
+	sps1=sps1+stroka.split(',')
+fp.close()
+print(sps1)
+
+sps1 = []
+fp = open('zapis3.txt')
+for stroka in fp:
+    stroka = stroka.rstrip('\n')
+    stroka = stroka.replace('[','')
+    stroka = stroka.replace(']','')
+    chisla_str = stroka.split(',')
+    chisla = [int(x) for x in chisla_str if x]
+    sps1.append(chisla)
+fp.close()
+for podspisok in sps1:
+    print(f"[{', '.join(map(str, podspisok))}]")
+
+fp=open('zapis3.txt')
+stroka1=fp.read(12)
+stroka2=fp.read()
+fp.close()
+print(stroka1)
+print(stroka2)
+
+fp=open('zapis3.txt')
+stroka3=fp.readline(5)
+stroka4=fp.readlines()
+print(stroka3)
+print(stroka4)
+
+## 4.9.
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}  #Объект типа «множество»
+fp=open('zapis6.mnz','wb')  # Бинарный файл – на запись
+pickle.dump(mnoz1,fp)  #dump – метод записи объекта в файл
+fp.close()
+
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)  #load – метод чтения объекта из бинарного файла
+fp.close()
+print(mnoz2)
+print(mnoz1)
+
+fp = open('zapis7.2ob', 'wb')
+pickle.dump(mnoz1, fp)
+pickle.dump(sps3, fp)
+fp.close()
+fp = open('zapis7.2ob', 'rb')
+obj1 = pickle.load(fp)  # Первое обращение к load читает первый объект
+obj2 = pickle.load(fp)  # Второе – читает второй
+fp.close()
+print(obj1)
+print(mnoz1)
+print(obj2)
+print(sps3)
+
+## 5.
+import sys
+vr_out=sys.stdout  #Запоминаем текущий поток вывода
+fc=open('Stroka.txt','w') #Откроем файл вывода
+sys.stdout=fc #Перенацеливаем стандартный поток вывода на файл
+print('запись строки в файл') #Вывод теперь будет не на экран, а в файл
+sys.stdout=vr_out  #Восстановление текущего потока
+print('запись строки на экран') #Убеждаемся, что вывод на экран восстановился
+fc.close()
+
+import sys
+tmp_in = sys.stdin #Запоминаем текущий поток ввода
+fd = open("Stroka.txt", "r") #Открываем файл для ввода (чтения)
+sys.stdin = fd #Перенацеливаем ввод на файл вместо клавиатуры
+print(sys.stdin)
+while True:
+    try:
+        line = input () #Считываем из файла строку
+        print(line)  # Отображаем считанное
+    except EOFError:
+        break
+fd.close()
+sys.stdin=tmp_in #Не забыть вернуть стандартное назначение для потока ввода

TEMA6/zapis2.bin

@@ -0,0 +1 @@
+Тут какое то значение

TEMA6/zapis3.txt

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

TEMA6/zapis4.txt

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

TEMA6/zapis5.txt

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