test12

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Похил Анастасия Александровна
+print('Hello')
+h=input('Your name=')
+import  os
+os.chdir('C:\\Users\\u207-04\\Desktop\\python-labs\\TEMA1\\')

TEMA1/report.md

@@ -0,0 +1,146 @@
+# Отчет по теме 1
+
+Похил Анастасия, А-02-23
+
+# Пункт 1
+Запущена на выполнение программа-интерпретатор
+
+# Пункт 2
+Изучение среды IDLE
+
+## 2.1 Настройка текущего каталога
+
+```py
+>>> import os
+>>> os.chdir('C:\Users\u207-04\Desktop\python-labs\TEMA1')
+```
+
+# Пункт 3
+Изучено содержание открывающегося диалогового окна интерпретатора и введена инструкция:
+
+```py
+>>> print('Hello')
+Hello
+```
+
+# Пункт 4
+Введена еще одна инструкция:
+```py
+>>>h=input('Your name=')
+Your name= Nasty
+```
+
+# Пункт 5
+Завершена работа интерпретатора вводом инструкции:
+```py
+>>>exit()
+```
+# Пункт 6-9
+Настройка рабочего каталога среды была произведена в пункте 2, также были изучены предложения главного и выпадающих меню. Для примера был изменен шрифт и соответствующие размеры.
+
+# Пункт 7 
+
+```py
+## Программа по Теме 1 Похил Анастасия Александровна
+print('Hello')
+h=input('Your name=')
+import  os
+os.chdir('C:\\Users\\u207-04\\Desktop\\python-labs\\TEMA1\\')
+
+========== RESTART: C:/Users/u207-04/Desktop/python-labs/TEMA1/Pr0.py ==========
+Hello
+Your name=Nasty
+```
+## другой способ запуска программы на выполнение 
+
+```py
+import Pr0
+Hello
+Your name=Nasty
+```
+
+##
+Третий способ: при активном окне редактора с программой – нажата функциональная клавиша F5.
+
+```py
+import Pr0
+Hello
+Your name=Nasty
+```
+
+# Пункт 11
+Запущена на выполнение программа, которая находится в рабочем каталоге в файле prb1.pу
+
+```py
+>>>import prb1
+Как Вас зовут? Настя
+Привет, Настя
+```
+
+# Пункт 12
+Открыли каталог __pycache__  и в текстовом редакторе открыли файл Pr0.cpython-34.pyc – результат работы компилятора среды. Результат:
+§
+
+    oиєhР   г                   уZ   —  e d ¦
  «
        
  e
d
¦
  «
        ZddlZ ej        d¦
  «
        
 dS )ЪHelloz
+Your name=й    Nz+C:\Users\u207-04\Desktop\python-labs\TEMA1\)ЪprintЪinputЪ
hЪosЪchdir© у    ъ1C:\Users/u207-04/Desktop/python-labs/TEMA1\Pr0.pyъ<module>r   
   sC   р


а ЂЂgЃ„ЂШЂ%€СФЂ
Ш 
+Ђ
+Ђ
+Ђ
+Ш Ђ„Р	<С =Ф =Р =Р =Р =r
+   
+При выполнении скрипта Python преобразует его в байт-код, который не предназначен для чтения людьми. Байт-код проще и эффективнее интерпретировать, чем исходный код. 
+# Пункт 13
+Изучена раздел помощи (Help) главного меню
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+
+help(print), help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+
+
+# Пункт 15
+Была запущена программа, а также исследованы графические возможности.
+========== RESTART: C:\Users\u207-04\Desktop\python-labs\TEMA1\prb1.py =========
+Как Вас зовут? Настя
+Привет, Настя
+
+![Chaos](figure2.PNG)
+![Clock](figure1.PNG)

TEMA1/test1.md

@@ -0,0 +1,13 @@
+# Индивидуальное контрольное задание по теме 1
+
+Похил Анастасия, А-02-23
+
+## Вопрос
+
+Если вы начали работу на новом для вас компьютере с предустановленной средой Python, на что надо обратить внимание после запуска интерактивной оболочки?
+
+## Ответ
+
+Первым делом необходимо проверить версию Python, путь к нему и убедиться, что установлены нужные пакеты и правильно настроенное окружение разработки. Потом надо настроить рабочий каталог среды по следующему образцу:
+ import os
+ os.chdir('<путь доступа к папке>\\Tema1\\') #Например, 'd:\\users\\Ivanov\\Tema1\\'

TEMA2/report.md

@@ -0,0 +1,520 @@
+# Отчет по теме 2
+
+**Похил Анастасия, А-02-23**
+
+### 1. Настройка текущего каталога
+```py
+import os
+os.chdir('C://Users//Настя//Desktop//python-labs//TEMA2//')
+```
+
+### 2.Изучение простых объектов
+```py
+f1=16;f2=3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+- Получение атрибутов и определение классовой принадлежности объекта f1
+```py
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+```
+- Удаление созданных переменных
+```py
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+### 3. Изучение правил именования объектов в Python. 
+Примеры правильных и неправильных имён:
+
+```py
+gg = 1.6
+hh1 = 'строка'
+73sr=3
+SyntaxError: invalid decimal literal
+and=7
+SyntaxError: invalid syntax
+```
+
+### 4.Вывод списка ключевых слов 
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+keywords = keyword.kwlist
+```
+
+### 5.Встроенные функции
+
+- Cписок встроенных идентификаторов
+```py
+import builtins
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+- Получение помощи по функциям и их применение
+```py
+help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+```
+В дальнейшем получение помощи не будет вставлено в отчёт.
+
+- Функции abs и len
+```py
+abs(-12)
+12
+len("Hello, World!")
+13
+list1=(12,14,63,24,32,52)
+len(list1)
+6
+```
+- Функции min и max
+```py
+max(12,14,63,24,32,52)
+63
+min(12,14,63,24,32,52)
+12
+max("Москва", "Санкт-Петербург", "Владивосток")
+'Санкт-Петербург'
+min("Москва", "Санкт-Петербург", "Владивосток")
+'Владивосток'
+```
+- Функции pow и round
+```py
+pow(12, 2)
+144
+pow(25, -2)
+0.0016
+pow(5, 2, 7)
+4
+round(3.14)
+3
+round(3.14135413, 1)
+3.1
+round(123.45, -1)
+120.0
+```
+- Функция сортировки и суммы 
+```py
+sorted({12,-32,42,11,-2,7,-42,63})
+[-42, -32, -2, 7, 11, 12, 42, 63]
+sorted({12,-32,42,11,-2,7,-42,63}, reverse=True)
+[63, 42, 12, 11, 7, -2, -32, -42]
+sorted(["Москва","Санкт-Петербург","Сочи","Владивосток","Архангельск"],key=len)
+['Сочи', 'Москва', 'Владивосток', 'Архангельск', 'Санкт-Петербург']
+sorted(["Москва","Санкт-Петербург","Сочи","Владивосток","Архангельск"])
+['Архангельск', 'Владивосток', 'Москва', 'Санкт-Петербург', 'Сочи']
+sum([10,41,11,3,8])
+73
+sum([10,41,11,3,8],12)
+85
+sum(x for x in range(3, 12))
+63
+```
+- Функция zip
+```py
+names = ["Анна", "Иван", "Мария"]
+ages = [25, 30, 28]
+cities = ["Москва", "Сочи", "Казань"]
+zip1 = list(zip(names, ages, cities))
+zip1
+[('Анна', 25, 'Москва'), ('Иван', 30, 'Сочи'), ('Мария', 28, 'Казань')]
+names.pop(1)
+'Иван'
+zip1
+[('Анна', 25, 'Москва'), ('Мария', 30, 'Сочи')]
+
+```
+
+### 6.Влияние регистра
+```py
+Gg1=45
+Gg1
+45
+gg1
+1.6
+```
+
+### 7.Простые базовые типы объектов
+#### 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
+type(dv1)
+<class 'int'>
+vsm1=0o52765
+shest1=0x7109af6
+cc1=2-3j
+a=3.67; b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j
+```
+#### 7.3 Изучение строк 
+```py
+ss1='Это - строка символов'
+ss1="Это - строка символов"
+ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+ss1b= 'Меня зовут: \n <Похил А.А>'
+print(ss1b)
+Меня зовут: 
+ <Похил А.А>
+mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+
+print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+```
+- Способы обращений к частям строк и операция «разрезания» или «создания среза»
+```py
+ss1[0]
+'Э'
+ss1[8]
+'р'
+ss1[-2]
+'о'
+ss1[6:9]
+'стр'
+ss1[13:]
+'символов'
+ss1[:13]
+'Это - строка '
+ss1[5:-8]
+' строка '
+ss1[3:17:2]
+'  тоасм'
+ss1[17:3:-2]
+'омсаот '
+ss1[-4:3:-2]
+'омсаот '
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#86>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+ss1=ss1[:4]+'='+ss1[5:]
+print(ss1)
+Это = строка символов
+```
+-Создание объектов с разными срезами 
+```py
+ss1b[0]
+'М'
+ss1b[7]
+'в'
+ss1b[-3]
+'.'
+ss1b[6:10]
+'овут'
+ss1b[12:]
+'\n <Похил А.А>'
+ss1b[:12]
+'Меня зовут: '
+ss1b[6:-2]
+'овут: \n <Похил А.'
+ss1b[2:16:2]
+'н оу:\n<'
+ss1b[16:2:-2]
+'о<\n:уо '
+ss1b[-2:4:-2]
+'ААлхП  твз'
+ss1b=ss1b[:10]+'-'+ss1b[12:]
+print(ss1b)
+Меня зовут-
+ <Похил А.А>
+```
+#### 7.4 Создание объектов и проверка их типов 
+```py
+a = 52
+type(a)
+<class 'int'>
+b = 32.947
+type(b)
+<class 'float'>
+c = 4 + 5j
+type(c)
+<class 'complex'>
+d = 'hi'
+type(d)
+<class 'str'>
+e = False
+type(e)
+<class 'bool'>
+j = None
+type(j)
+<class 'NoneType'>
+```
+
+### 8. Сложные типы объектов
+
+#### 8.1 Списки
+```py
+spis1=[111,'Spisok',5-9j]
+stup=[0,0,1,1,1,1,1,1,1]
+spis=[1,2,3,4,
+      5,6,7,
+      8,9,10]
+
+spis1[-1]
+(5-9j)
+stup[-8::2]
+[0, 1, 1, 1]
+spis1[1]='Список'
+print(spis1)
+[111, 'Список', (5-9j)]
+len(spis1)
+3
+```
+- Методы объекта находятся в списке его атрибутов
+```py
+dir()
+['Gg1', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'bb1', 'bb2', 'builtins', 'c', 'cc1', 'cc2', 'd', 'dv1', 'e', 'ff1', 'gg1', 'hh1', 'i', 'ii1', 'j', 'keyword', 'keywords', 'list1', 'mnogo', 'os', 'shest1', 'spis', 'spis1', 'ss1', 'ss1a', 'ss1b', 'stup', 'vsm1']
+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+['New item']
+[111, 'Список', (5-9j), 'New item', 'New item']
+print(spis1)
+[111, 'Список', (5-9j), 'New item']
+spis1.append(ss1b)
+print(spis1)
+[111, 'Список', (5-9j), 'New item', 'Меня зовут-\n <Похил А.А>']
+spis1.pop(1)
+'Список'
+print(spis1)
+[111, (5-9j), 'New item', 'Меня зовут-\n <Похил А.А>']
+```
+- Изучение методов insert и remove
+```py
+spis1.insert(1,"ПОАС")
+spis1.insert(3, 999)
+spis1.pop(2)
+(5-9j)
+print(spis1)
+[111, 'ПОАС', 999, 'New item', 'Меня зовут-\n <Похил А.А>']
+spis1.remove(111)
+print(spis1)
+['ПОАС', 999, 'New item', 'Меня зовут-\n <Похил А.А>']
+```
+- extend и clear
+```py
+spis1.extend([100, 200])
+spis2 =['xx', 'a', 'apple']
+spis1.extend(spis2)
+print(spis1)
+['ПОАС', 999, 'New item', 'Меня зовут-\n <Похил А.А>', 100, 200, 'xx', 'a', 'apple']
+spis2.clear()
+print(spis2)   
+[]
+```
+- Метод sort 
+```py
+spis2 = [5, 2, 8, 1, 9]
+spis2.sort()
+print(spis2)
+[1, 2, 5, 8, 9]
+spis2.sort(reverse=True)
+print(spis2)
+[9, 8, 5, 2, 1]
+spis2.clear()
+spis2 = ['a', 'b', 'C', 'd']
+spis2.sort()
+print(spis2)
+['C', 'a', 'b', 'd']
+```
+- Методы reverse, count и copy
+```py
+spis2.reverse()
+print(spis2)
+['d', 'b', 'a', 'C']
+spis1.reverse()
+print(spis1)
+['apple', 'a', 'xx', 200, 100, 'Меня зовут-\n <Похил А.А>', 'New item', 999, 'ПОАС']
+copy1 = spis1.copy()
+copy2 = spis2.copy()
+print(copy1, copy2)
+['apple', 'a', 'xx', 200, 100, 'Меня зовут-\n <Похил А.А>', 'New item', 999, 'ПОАС'] ['d', 'b', 'a', 'C']
+spis1.count('a')
+1
+spis2.count('a')
+1
+spis1.count(100)
+1
+spis2.count(100)
+0
+spis1.index('New item')
+6
+spis2.index('b')
+1
+spis1.index(100)
+4
+```
+- Вложенные списки и обращение к элементам в них
+```py
+spis2=[spis1,[4,5,6,7]]
+print(spis2)
+[['apple', 'a', 'xx', 200, 100, 'Меня зовут-\n <Похил А.А>', 'New item', 999, 'ПОАС'], [4, 5, 6, 7]]
+spis2[0][1]
+'a'
+spis2[0][1]=78
+print(spis2)
+[['apple', 78, 'xx', 200, 100, 'Меня зовут-\n <Похил А.А>', 'New item', 999, 'ПОАС'], [4, 5, 6, 7]]
+print(spis1)
+['apple', 78, 'xx', 200, 100, 'Меня зовут-\n <Похил А.А>', 'New item', 999, 'ПОАС']
+#Когда мы изменяем spis2[0][1], мы фактически изменяем второй элемент оригинального списка spis1, так как spis2[0] и spis1 - это один и тот же объект в памяти.
+my_list = [42, 3.14, "Hello", True, [1, 2, 3], (5-2j), spis1.copy()]
+my_list[2][0] = 123
+print(my_list)
+[42, 123, 'Hello', True, [1, 2, 3], (5-2j), ['apple', 78, 'xx', 200, 100, 'Меня зовут-\n <Похил А.А>', 'New item', 999, 'ПОАС']]
+
+#### 8.2 Объект-кортеж 
+- Создание кортежа, переопределение и методы
+```py
+kort1=(222,'Kortezh',77+8j)
+print(kort1)
+(222, 'Kortezh', (77+8j))
+kort1= kort1+(1,2)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2)
+kort1= kort1+(ss1b,)
+print(kort1)
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут-\n <Похил А.А>')
+kort2=kort1[:2]+kort1[3:]
+print(kort2)
+(222, 'Kortezh', 1, 2, 'Меня зовут-\n <Похил А.А>')
+kort1.index(2)
+4
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#201>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+```
+- Создание кортежа №2
+```py
+my_tuple = (42, "hello", [1, 2, 3], (4, 5, 6))
+print(my_tuple)
+(42, 'hello', [1, 2, 3], (4, 5, 6))
+my_tuple[2]
+[1, 2, 3]
+my_tuple.index(42)
+0
+```
+
+#### 8.3 Объект-словарь
+
+```py
+dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+dic1['Orel']
+56
+dic1['Pskov']=78   
+dic1        
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+
+- Сортировка словарей 
+```py
+sorted(dic1.keys())  #по ключам
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())  #по значениям 
+[45, 56, 78, 145]
+dic2={1:'mean',2:'standart deviation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+dic3['statistics'][2]
+'standart deviation'
+```
+- Создание словарей с помощью функций dict и zip
+```py
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут-\n <Похил А.А>'}
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут-\n <Похил А.А>'}
+```
+- Создание своего словаря
+```py
+kortezh = (1, 'a', 3.14, True, 12, (5,6), 'end')
+spisok = [10, 'b', 2.71, False, 'finish']
+slovar = dict(zip(kortezh, spisok))
+slovar
+{1: False, 'a': 'b', 3.14: 2.71, 12: 'finish'}
+```
+Длина словаря равна 5, потому что функция zip() создает пары только до длины более короткой коллекции (списка из 5 элементов)
+
+- Пример словаря:
+```py
+AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
+AVTI['Курс III'][5]
+15
+```
+
+#### 8.4 Объект-множество
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'датчик', 'двигатель', 'микропроцессор', 'линия связи'}
+```
+- Некоторые операции с множеством 
+```py
+len(mnoz1)
+4
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+mnoz1.remove('линия связи')
+mnoz1
+{'реле', 'датчик', 'двигатель', 'микропроцессор'}
+```
+- Создание своего объекта
+```py
+s1 = {1, 2.5, "hello", True, (1, 2)}
+len(s1)
+4
+s1
+{2.5, 1, 'hello', (1, 2)}
+1 in s1
+True
+s1.add('11')
+s1.remove(1)
+s1
+{2.5, 'hello', (1, 2), '11'}
+```

TEMA2/task.md

@@ -0,0 +1,62 @@
+# Общее контрольное задание по теме 2
+
+**Похил Анастасия, А-02-23**
+
+## Задание 
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия
+1. Создать переменную с именем familia и со значением - символьной строкой – своей фамили-ей в латинской транскрипции.
+2. Создать переменную со значением, совпадающим с первой буквой из familia.
+3. Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+4. Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+5. Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+6. Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов.
+7. Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+8. Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные перемен-ные, соответствующие этим типам. 
+## Решение
+#### 1. Создание переменной familia.  
+```py
+familia = 'Pohil'
+```
+
+#### 2. Создание переменной, которая равна первой букве familia.
+```py
+first = familia[0]
+```
+#### 3. Создание переменной с именем sp_kw.
+```py
+import keyword
+dir(keyword)
+['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'iskeyword', 'issoftkeyword', 'kwlist', 'softkwlist']
+sp_kw = keyword.kwlist
+```
+
+#### 4. Удаление из списка sp_kw значения 'nonlocal'.
+```py
+sp_kw.remove('nonlocal')
+print(sp_kw)
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+#### 5. Создание кортежа kort1.
+```py
+kort1 = ('Анастасия','Вера','Елена','Дана')
+type(kort1)
+<class 'tuple'>
+```
+#### 6. Добавление в kort1 имена двух студентов. 
+```py
+kort1 = kort1 + ('Варвара','Татьяна')
+kort1
+('Анастасия','Вера','Елена','Дана','Варвара','Татьяна')
+```
+
+#### 7. Определяю, сколько раз в кортеже присутствуют студенты с именем «Анастасия».
+```py
+kort1.count('Анастасия')
+1
+```
+#### 8. Создание словаря dict_bas.
+```py
+dict_bas = {'строка': [familia,first],'список': sp_kw,'кортеж': kort1}          
+print(dict_bas)         
+{'строка': ['Pohil', 'P'], 'список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'кортеж': ('Анастасия','Вера','Елена','Дана','Варвара','Татьяна')}
+```

TEMA2/test.md

@@ -0,0 +1,25 @@
+# Индивидуальное контрольное задание по теме 2
+
+Похил Анастасия, А-02-23
+
+## Задание
+
+Создать объект strk=' А роза упала на лапу азора '.
+К какому классу относится этот объект? Напишите инструкцию вывода этого объекта «задом -наперед».
+
+## Решение
+- Создан объект strk:
+```py
+strk=' А роза упала на лапу азора '
+```
+- Определение класса:
+```py
+type(strk)
+<class 'str'>
+```
+- Инструкция вывода этого объекта «задом -наперед»:
+```py
+strk = strk[::-1]
+print(strk)
+' ароза упал ан алапу азор А '
+```

TEMA3/report.md

@@ -0,0 +1,695 @@
+# Отчет по теме 3
+
+Похил Анастасия, А-02-23
+
+### 1. Настройка текущего каталога.
+```py
+import os
+os.chdir('C://Users//Настя//Desktop//python-labs//TEMA3//')
+```
+### 2. Преобразование простых базовых типов объектов.
+
+#### 2.1. Преобразование в логический тип с помощью функции bool(<Объект>)
+
+```py
+logiz1 = bool(56)
+logiz2 = bool(0)
+logiz3 = bool("Beta")
+logiz4 = bool("")
+logiz1
+True
+logiz2
+False
+logiz3
+True
+logiz4
+False
+type(logiz1)
+<class 'bool'>
+```
+
+#### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления
+- Примеры использования функции int:
+
+```py
+tt1 = int(198.6)
+tt1
+198
+tt2 = int("-76")
+tt2
+-76
+tt3 = int("B",16)
+tt3
+11
+tt4 = int("71",8)
+tt4
+57
+tt5 = int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#19>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+- Преобразование целых чисел или строк символов в вещественное число 
+
+```py
+flt1 = float(789)
+flt1
+789.0
+flt2 = float(-6.78e2)
+flt2
+-678.0
+flt3 = float("Infinity")
+flt3
+inf
+flt4 = float("-inf")
+flt4
+-inf
+```
+
+#### 2.3. Преобразование десятичных чисел в другие системы счисления:
+
+```py
+hh = 123
+dv1 = bin(hh)  #Преобразование в строку с двоичным представлением
+vos1 = oct(hh)  # Преобразование в строку с восьмеричным представлением
+shs1 = hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+dv1
+'0b1111011'
+vos1
+'0o173'
+shs1
+'0x7b'
+int(dv1,2)
+123
+int(vos1, 8)
+123
+int(shs1, 16)
+123
+```
+
+### 3. Преобразования более сложных базовых типов объектов.
+
+#### 3.1. Преобразование в строку символов
+
+
+```py
+strk1 = str(23.6)
+strk1
+'23.6'
+strk2 = str(logiz3)
+strk2
+'True'
+strk3 = str(["A","B","C"])  #Преобразуем список
+strk3
+"['A', 'B', 'C']"
+strk4 = str(("A","B","C"))  #Преобразуем кортеж
+strk4
+"('A', 'B', 'C')"
+strk5 = str({"A":1,"B":2,"C":9})  #Преобразуем словарь
+strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+```
+
+#### 3.2. Преобразование элементов объекта в список
+
+```py
+spis1 = list("Строка символов")  #Заданная строка разделяется на символы
+spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+spis2 = list((124,236,-15,908))  #Кортеж превращается в список
+spis2
+[124, 236, -15, 908]
+spis3 = list({"A":1,"B":2,"C":9})  #Преобразование словаря в список
+spis3
+['A', 'B', 'C']
+```
+- Методы .values(), .items()
+
+```py
+spis3 = list({"A":1,"B":2,"C":9}.values())
+spis3
+[1, 2, 9]
+spis3 = list({"A":1,"B":2,"C":9}.items())
+spis3
+[('A', 1), ('B', 2), ('C', 9)]
+```
+#### 3.3. Преобразование элементов объектов в кортеж
+
+```py
+kort7 = tuple('Строка символов')  #Преобразование строки символов в кортеж
+kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+kort8 = tuple(spis2)  #Преобразование списка в кортеж
+kort8
+(124, 236, -15, 908)
+kort9 = tuple({"A":1,"B":2,"C":9})  #Преобразование словаря в кортеж
+kort9
+('A', 'B', 'C')
+```
+
+#### 3.4. Удаление обьектов
+
+```py
+del strk5, kort8
+strk5
+Traceback (most recent call last):
+  File "<pyshell#62>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
+kort8
+Traceback (most recent call last):
+  File "<pyshell#63>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+str_A = "Похил А.А"
+spis_A = list(str_A)
+spis_A
+['П', 'о', 'х', 'и', 'л', ' ', 'А', '.', 'А']
+kort_A = tuple(spis_A)
+kort_A
+('П', 'о', 'х', 'и', 'л', ' ', 'А', '.', 'А')
+str_AA = str(kort_A)
+str_AA
+"('П', 'о', 'х', 'и', 'л', ' ', 'А', '.', 'А')"
+```
+
+### 4. Арифметические операции.
+
+#### 4.1. Сложение и вычитание
+
+```py
+12+7+90  # Сложение целых чисел
+109
+5.689e-1 - 0.456  #Вычитание вещественных чисел
+0.11289999999999994
+23.6+54  #Сложение вещественного и целого чисел
+77.6
+14-56.7+89  #Сложение и вычитание целых и вещественных чисел
+46.3
+```
+
+#### 4.2. Умножение
+
+```py
+>-6.7*12  #Умножение вещественного числа на целое число
+-80.4
+```
+
+#### 4.3. Деление
+
+```py
+-234.5/6  #Деление вещественного числа на целое
+-39.083333333333336
+a = 178/45  #Деление двух целых чисел
+a
+3.9555555555555557
+type(a)
+<class 'float'>
+```
+
+#### 4.4. Деление с округлением вниз
+
+```py
+b = 178//45   #Деление двух целых чисел
+b
+3
+type(b)
+<class 'int'>
+c = -24.6//12.1  #Деление двух вещественных чисел
+c
+-3.0
+type(c)
+<class 'float'>
+d = 23.65//12
+d
+1.0
+type(d)
+<class 'float'>
+d = 12//52.43
+d
+0.0
+type(d)
+<class 'float'>
+d = 6//2
+d
+3
+type(d)
+<class 'int'>
+
+```
+
+#### 4.5. Получение остатка от деление
+
+```py
+148%33  #Остаток от деления двух целых чисел
+16
+12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+256%2.5
+1.0
+34.2%4
+2.200000000000003
+```
+
+#### 4.6. Возведение в степень
+
+```py
+14**3  #Целое число возводится в целую степень
+2744
+e = 2.7**3.6  #Вещественное число возводится в вещественную степень
+e
+35.719843790663525
+52**1.2
+114.60511792303392
+0.3**11
+1.7714699999999993e-06
+```
+
+#### 4.7. Операции с комплексными числами
+
+```py
+z1 = 3 + 2j
+z2 = 6 - 4j
+z1 + z2
+(9-2j)
+z1 * z2
+(26+0j)
+z1 / z2
+(0.19230769230769232+0.46153846153846156j)
+z1 // z2
+Traceback (most recent call last):
+  File "<pyshell#59>", line 1, in <module>
+    z1 // z2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+z1 % z2
+Traceback (most recent call last):
+  File "<pyshell#60>", line 1, in <module>
+    z1 % z2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+z1**z2
+(-717.4651414273118-23072.00404010235j)
+```
+
+### 5. Операции с двоичными представлениями целых чисел.
+
+#### 5.1. Двоичная инверсия
+
+```py
+dv1 = 9
+dv2 = ~dv1
+dv2
+-10
+```
+
+#### 5.2. Двоичное "И"
+
+```py
+7 & 9  # 111 и 1001 = 0001
+1
+7 & 8  # 111 и 1000 = 0000
+0
+```
+
+#### 5.3. Двоичное "ИЛИ"
+
+```py
+7 | 9     # 111 или 1001 = 1111
+15
+7 | 8     # 111 или 1000 = 1111
+15
+14 | 5   # 1110 или 0101 = 1111
+15
+```
+
+#### 5.4. Двоичное «исключающее ИЛИ»
+
+```py
+14 ^ 5  # 1110 исключающее или 0101 = 1011
+11
+```
+
+Число 11 получилось при переводе 1011 из двоичной системы в десятичную.
+
+#### 5.5. Сдвиг двоичного представления на заданное число разрядов влево или вправо с дополнением нулями
+
+```py
+h = 14   #Двоичное представление = 1110
+g = h<<2  # Новое двоичное представление = 111000
+g
+56
+g1 = h>>1  # Новое двоичное представление = 0111
+g1
+7
+g2 = h>>2  # Новое двоичное представление = 0011
+g2
+3
+h0 = 127
+bin(h0)
+'0b1111111'
+g0 = h0<<1
+g0
+254
+bin(g0)
+'0b11111110'
+g0 = h0>>3
+g0
+15
+bin(g0)
+'0b1111'
+```
+Создание двух двоичных чисел с 7-ю знаками и выполнение операций над ними:
+
+
+```py
+b1 = int("1010101",2)
+b2 = int("1111001",2)
+b_2 = ~b2
+b_2
+-122
+b1 & b2
+81
+b1 | b2
+125
+b1^b2
+44
+b1 >> 1
+42
+b2 << 3
+968
+b1
+85
+b2
+121
+```
+
+### 6. Операции при работе с последовательностями (строками, списками, кортежами).
+
+#### 6.1. Объединение последовательностей (конкатенация)(+)
+
+```py
+'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+#### 6.2. Повторение(*)
+
+```py
+'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1 = [0]*3 + [1]*99
+signal2 = (0,)*3 + (1,)*5 + (0,)*7
+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, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+#### 6.3. Проверка наличия заданного элемента в последовательности (in)
+
+```py
+stroka = 'Система автоматического управления'
+'автомат' in stroka  #Наличие подстроки в строке
+True
+'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+#### 6.4.Подстановка значений в строку с помощью оператора «%»
+
+```py
+stroka = 'Температура = %g %s  %g'
+stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+stroka = 'Температура = %(zn1)g %(sravn)s  %(zn2)g'
+stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+
+### 7. Оператор присваивания
+
+#### 7.1. Обычное присваивание значения переменной (=)
+
+
+```py
+zz = -12
+zz
+-12
+```
+
+#### 7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+
+```py
+zz += 5   # Значение zz увеличивается на 5
+zz -= 3  # Значение уменьшается на 3
+zz
+-10
+stroka='Система'
+stroka+=' регулирования'
+stroka
+'Система регулирования'
+```
+
+#### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+
+```py
+zz /= 2
+zz
+-5.0
+zz *= 5
+zz
+-25.0
+stroka='Система регулирования'
+stroka *= 2
+stroka
+'Система регулированияСистема регулирования'
+```
+
+#### 7.4.Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+
+```py
+zz //= 3
+zz
+-9.0
+zz %= 2
+zz
+1.0
+zz **= 3
+zz
+1.0
+```
+
+##### 7.5. Множественное присваивание
+
+```py
+w = v = 10  # Переменным присваивается одно и то же значение
+w
+10
+v
+10
+n1,n2,n3 = (11,-3,'all')  #Значения переменных берутся из кортежа
+n1;n2;n3
+11
+-3
+'all'
+n1,n2,n3 = "11", "-3", "all"
+n1;n2;n3
+'11'
+'-3'
+'all'
+n1,n2,n3 = [11,-3,'all']
+n1;n2;n3
+11
+-3
+'all'
+n1,n2,n3 = {11: 1,-3:2,'all':3}
+n1;n2;n3
+11
+-3
+'all'
+```
+
+### 8. Логические операции.
+
+#### 8.1. Операции сравнения
+
+```py
+w = v = 10
+w == v
+True
+w != v
+False
+w < v
+False
+w > v
+False
+w >= v
+True
+w <= v
+True
+```
+
+#### 8.2. Проверка наличия заданного элемента в последовательности или в множестве
+
+```py
+mnoz1 = {'pen','book','pen','iPhone','table','book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+dic1 = {'Saratov':145, 'Orel':56, 'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1 = {'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+
+#### 8.3. Логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+
+```py
+a = 17
+b = -6
+(a >= b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(5 > 6) and ('kazan' in dic1) and not ('lozhka' in mnoz1)
+False
+(5 > 6) and (7 > 5) or ("Saratov" in dic1)
+True
+```
+
+#### 8.4. Проверка ссылок переменных на один и тот же объект (is)
+
+```py
+w = v = 10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+w is v
+True
+w1 = ['A','B']
+v1 = ['A','B']
+w1 is v1 #При раздельном создании списков с одинаковыми элементами получаются разные объекты в памяти, поэтому is возвращает False.Оператор is проверяет идентичность объектов (ссылку на один объект), а не равенство содержимого 
+False
+```
+
+### 9. Операции с объектами, выполняемые с помощью методов.
+
+```py
+stroka = 'Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+#### 9.1. Методы для работы со строками
+
+```py
+stroka.find('пр')  #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22 = stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит заданный разделитель
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()  #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3 = " ".join(spis22)  #Возвращает строку, собранную из элементов списка
+stroka3
+'Микропроцессорная система управления'
+stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+strk1 = 'Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+strk2 = 'Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3 = 'Момент времени {num}, значение = {znch}'
+strk3.format(znch = 89.7,num = 2)
+'Момент времени 2, значение = 89.7'
+```
+
+#### 9.2. Методы для работы со списками
+
+```py
+spsk = [1, 'a', 2, 'd', 4]
+dir(spsk)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+spsk.pop(2)
+2
+spsk
+[1, 'a', 'd', 4]
+spsk.append('c')
+spsk
+[1, 'a', 'd', 4, 'c']
+spsk.insert(2, 'a')
+spsk
+[1, 'a', 'a', 'd', 4, 'c']
+spsk.count('a')
+2
+```
+
+#### 9.3. Методы для работы с кортежами
+
+```py
+t = (1, 2, 3, 2, 4)
+dir(t)
+['__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']
+t.count(2)
+2
+t.index(3)
+2
+len(t)
+5
+t[1]
+2
+```
+
+#### 9.4. Методы для работы со словарями и множествами
+
+```py
+#словарь
+d = {'a': 1, 'b': 2, 'c': 3}
+dir(d)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+d.keys()
+dict_keys(['a', 'b', 'c'])
+d.values()
+dict_values([1, 2, 3])
+d.get('b')
+2
+d.update({'d': 4})
+d
+{'a': 1, 'b': 2, 'c': 3, 'd': 4}
+#множество
+s = {1, 2, 3, 2, 4}
+dir(s)
+['__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']
+s.add(5)
+s
+{1, 2, 3, 4, 5}
+s.remove(2)
+s
+{1, 3, 4, 5}
+s.intersection({1, 3}) #пересечение множеств
+{1, 3}
+```
+
+### 10. Закончен сеанс работы с IDLE.

TEMA3/task.md

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

TEMA3/test.md

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

TEMA4/report.md

@@ -0,0 +1,336 @@
+# Отчет по теме 4
+
+Похил Анастасия, А-02-23
+
+### 1. Настройка текущего каталога.
+```py
+import os
+os.chdir('C://Users//Настя//Desktop//python-labs//TEMA3//')
+```
+### 2. Стандартные функции.
+
+#### 2.1. Функция округления числа с заданной точностью
+
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+type(round(123.456,0))
+<class 'float'>
+type(round(123.456,1))
+<class 'float'>
+round(123.456)
+123
+type(round(123.456))
+<class 'int'>
+
+```
+
+#### 2.2. Функция range 
+
+```py
+gg=range(76,123,9)
+gg
+range(76, 123, 9)
+type(gg)
+<class 'range'>
+list(gg)
+[76, 85, 94, 103, 112, 121]
+range(23)
+range(0, 23)
+#range(23) создает последовательность целых чисел от 0 до 22 с шагом 1
+list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+#### 2.3. Функция zip 
+
+```py
+qq = ["Похил", "Сарайкина", "Снегура", "Шинкаренко"]
+ff=zip(gg,qq)
+ff
+<zip object at 0x00000293529A1180>
+tuple(ff)
+((76, 'Похил'), (85, 'Сарайкина'), (94, 'Снегура'), (103, 'Шинкаренко'))
+ff[0]
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+```
+
+#### 2.4. Функция eval
+```py
+fff = float(input('коэффициент усиления=')); dan = eval('5*fff-156')
+коэффициент усиления=4
+dan
+-136.0
+type(dan)
+<class 'float'>
+```
+
+#### 2.5. Функция exec
+```py
+exec(input('введите инструкции:'))
+введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+
+-eval() - для вычислений с возвратом результата, exec() - для выполнения кода без возврата значения.
+
+#### 2.6. Применение функций abs, pow, max, min, sum, divmod, len, map
+```py
+abs(-50)
+50
+abs(123)
+123
+pow(2,3)
+8
+pow(5,2)
+25
+max(1, 5, 3)
+5
+max([10, 2, 8, 4])
+10
+max("a", "A") #сравнение строк в Python происходит по ASCII кодам символов
+'a'
+max("a", "b")
+'b'
+min([10, 2, 8, 4])
+2
+sum((10, 20, 30))
+divmod(10, 3)
+(3, 1)
+divmod(3.5, 2)
+(1.0, 1.5)
+len({"a": 1, "b": 2})
+2
+len([1, 2, 3, 4, 5])
+list(map(abs, [-1, -2, 3]))
+[1, 2, 3]
+numbers = [1, 2, 3, 4, 5]
+list(map(str, numbers))
+['1', '2', '3', '4', '5']
+```
+
+### 3. Функции из стандартного модуля math. 
+
+```py
+import math
+dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+math.factorial(5)
+120
+math.sin(0)
+0.0
+math.acos(0)
+1.5707963267948966
+math.degrees(math.pi)
+180.0
+math.radians(180)
+3.141592653589793
+math.exp(1)
+2.718281828459045
+math.log(100)
+4.605170185988092
+math.log10(10)
+1.0
+math.sqrt(9)
+3.0
+math.ceil(3.7)
+4
+math.floor(3.2)
+3
+math.sin(2 * math.pi / 7 + math.exp(0.23))
+0.8334902641414562
+```
+
+### 4. Функции из модуля cmath.
+
+```py
+cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+cmath.phase(1-0.5j)
+-0.4636476090008061
+cmath.sqrt(-4)
+2j
+```
+
+### 5. Стандартный модуль random.
+
+```py
+import random
+dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log', '_log2', '_os', '_parse_args', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', 'betavariate', 'binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'main', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+
+    If *a* is an int, all bits are used.
+
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+random.seed() #нет возвращаемых значений
+random.random()
+0.6159477691885248
+random.uniform(1, 10)
+7.581530495835095
+random.randint(1, 100)
+5
+random.gauss(0, 1)
+-0.3506558234077829
+random.choice(numbers)
+1
+list1 = [1, 2, 3, 4, 5]
+random.shuffle(list1)
+list1
+[3, 5, 2, 4, 1]
+random.sample(numbers, 3)
+[3, 5, 2]
+random.betavariate(2, 5)
+0.1832859047033012
+random.gammavariate(2, 1)
+1.4911292379429324
+list2 = [
+    random.uniform(0, 1),           # Равномерное распределение
+    random.gauss(0, 1),             # Нормальное распределение  
+    random.betavariate(2, 5),       # Бета-распределение
+    random.gammavariate(2, 1)       # Гамма-распределение
+]
+list2
+[0.31800769775397375, -0.4796694435186039, 0.078752268353954, 2.8310089922616504]
+
+```
+
+### 6. Функции из модуля time.
+
+```py
+import time
+dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+c1=time.time()
+c1
+1759322889.1532655
+c2=time.time()-c1
+c2
+17.157387256622314
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=1, tm_hour=12, tm_min=48, tm_sec=51, tm_wday=2, tm_yday=274, tm_isdst=0)
+dat.tm_mon
+10
+dat.tm_year
+2025
+time.localtime()
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=1, tm_hour=15, tm_min=52, tm_sec=4, tm_wday=2, tm_yday=274, tm_isdst=0)
+time.asctime(time.localtime())
+'Wed Oct  1 15:54:51 2025'
+time.ctime(c1)
+'Wed Oct  1 15:48:09 2025'
+time.sleep(2)
+time.mktime((2025, 1, 1, 0, 0, 0, 0, 0, 0))
+1735678800.0
+time.localtime(c1)
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=1, tm_hour=15, tm_min=48, tm_sec=9, tm_wday=2, tm_yday=274, tm_isdst=0)
+```
+
+### 7. Графические функции.
+
+```py
+import pylab
+x = list(range(-3,55,4))
+t = list(range(15))
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x0000020109A13890>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+
+```
+![График 1](Ris1.png)
+
+```py
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000002010AED0550>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000002010AED0690>]
+pylab.show()
+```
+![График 2](Ris2.png)
+```py
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x0000020109A1A270>, <matplotlib.patches.Wedge object at 0x000002010D44E210>, <matplotlib.patches.Wedge object at 0x000002010D44E5D0>, <matplotlib.patches.Wedge object at 0x000002010D44E850>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+```
+![График 3](Ris3.png)
+
+```py
+rost = [170, 165, 180, 175, 160, 185, 172, 168, 178, 162]
+pylab.hist(rost)
+(array([2., 0., 1., 1., 2., 0., 1., 1., 1., 1.]), array([160. , 162.5, 165. , 167.5, 170. , 172.5, 175. , 177.5, 180. ,
+       182.5, 185. ]), <BarContainer object of 10 artists>)
+pylab.show()
+```
+![График 4](Ris4.png)
+
+```py
+predmety = ['Математика', 'Физика', 'Химия']
+otm = [5, 4, 3]
+pylab.bar(predmety, otm)
+<BarContainer object of 3 artists>
+pylab.title('Оценки по предметам')
+Text(0.5, 1.0, 'Оценки по предметам')
+pylab.show()
+```
+![График 5](Ris5.png)
+### 8. Cтатистический модуль statistics.
+
+```py
+import statistics
+statistics.mean(numbers)
+3
+statistics.median(numbers)
+3
+numbers
+[1, 2, 3, 4, 5]
+statistics.stdev(numbers)
+1.5811388300841898
+```
+
+### 9. Закончен сеанс работы с IDLE.

TEMA4/task.md

@@ -0,0 +1,29 @@
+# Общее контрольное задание по теме 4
+
+**Похил Анастасия, А-02-23**
+
+## Задание 
+• Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+• Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+• Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+• Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+• Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+• Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+
+## Решение
+```py
+import cmath
+divmod((round(cmath.phase(0.2+0.8j), 2))*20, 3)
+(8.0, 2.6000000000000014)
+import time
+a = time.localtime()
+time_str = str(a.tm_hour) + ":" + str(a.tm_min)
+time_str
+'17:55'
+N = round(random.gauss(15, 4))
+N
+17
+time.localtime().tm_min - a.tm_min
+2
+```

TEMA4/test.md

@@ -0,0 +1,35 @@
+# Индивидуальное контрольное задание
+
+Похил Анастасия, А-02-23, вариант 18
+
+## Задание
+18.Напишите инструкцию запоминания текущего Московского времени в некоторой переменной.
+Создайте кортеж с целочисленными значениями от 0 до 136 с шагом 17. 
+Подсчитайте число элементов в кортеже. 
+Создайте нормально распределенное число Z с математическим ожиданием 47 и стандартным отклонением 22.
+Нацело разделите сумму элементов кортежа на округленное до целого значения Z.
+Отобразите результат в виде символьной строки вида «Ре-зультат = ХХ» с использование формата.
+Определите время в минутах, прошедшее с начала выполнения данного задания.
+
+## Решение
+```py
+a = time.localtime()
+a
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=13, tm_hour=14, tm_min=4, tm_sec=2, tm_wday=0, tm_yday=286, tm_isdst=0)
+tup1 = tuple(range(0, 137, 17))
+tup1
+(0, 17, 34, 51, 68, 85, 102, 119, 136)
+len_t = len(tup1)
+len_t
+9
+Z = random.gauss(47, 22)
+Z
+42.599655329645195
+res = sum(tup1) // round(Z)
+res
+14
+print('Результат = ', res)
+Результат =  14
+time.localtime().tm_min - a.tm_min
+11
+```

TEMA5/report.md

@@ -0,0 +1,339 @@
+# Отчёт по Теме 5
+
+Похил Анастасия, А-02-23
+
+## 1. Запустили интерактивную оболочку IDLE.
+
+## 2.Управляющая инструкция if.
+
+```py
+porog = 4; rashod1 = 5; rashod2 = 7
+if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8
+
+dohod
+12
+```
+
+```py
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+
+dohod
+12
+```
+
+Операция с множественным ветвлением линий потока:
+
+```py
+if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+
+dohod
+2
+```
+
+Изучены примеры:
+
+```py
+dohod=2 if porog>=4 else 0
+dohod
+2
+```
+Или:
+```py
+if porog>=5 : rashod1=6; rashod2=0
+
+rashod1;rashod2
+5
+7
+```
+
+## 3.Управляющая инструкция for.
+
+### 3.1.Простой цикл.
+
+```py
+temperatura=5
+for i in range(3,18,3):
+	temperatura+=i
+
+temperatura
+50
+```
+
+### 3.2. Более сложный цикл.
+
+```py
+sps=[2,15,14,8]
+for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+```
+Отличающаяся совокупность операций:
+```py
+sps=[2,15,14,8]
+for k in sps[:]:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+sps
+[2, 15, 14, 8, 2, 2, 2, 2]
+```
+Здесь sps[:] - копия списка sps, потому кол-во элементов не увеличвается и заканчивается на последней 4-й итерации.В первом случае цикл мог бы быть бесконечным, если бы не условие else: break, а во втором - цикл гарантированно завершится после обработки 4 исходных элементов.
+
+
+### 3.3.Пример c созданием списка.
+
+```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)
+
+472
+467
+```
+вывод ss происходит только когда цикл завершился все 10 итераций без прерывания, то есть когда сумма так и не достигла 500.
+
+### 3.5. Пример с символьной строкой.
+
+```py
+stroka = 'Это - автоматизированная система'
+stroka1 = ""
+for ss in stroka:
+       stroka1 += " " + ss
+
+	
+stroka1
+' Э т о   -   а в т о м а т и з и р о в а н н а я   с и с т е м а'
+```
+
+### 3.5.Конструкция list comprehension.
+
+```py
+sps2=[math.sin(i*math.pi/5+2) for i in range(100)]
+sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+```
+
+Отображение графика:
+```py
+import pylab
+x = list(sps2)
+y = list(range(100))
+pylab.plot(y,x)
+[<matplotlib.lines.Line2D object at 0x00000228A28D7890>]
+pylab.title('График 1')
+Text(0.5, 1.0, 'График 1')
+pylab.show()
+```
+![](ris1.png)
+
+## 4.Управляющая инструкция while.
+
+### 4.1.Цикл со счетчиком.
+
+```py
+rashod = 300
+while rashod:
+	print("Расход =", rashod)
+	rashod -= 50
+
+	
+Расход = 300
+Расход = 250
+Расход = 200
+Расход = 150
+Расход = 100
+Расход = 50
+```
+Цикл останавливается, когда rashod принимает значение False, то есть rashod = 0.
+
+### 4.2.Пример с символьной строкой.
+
+```py
+import math
+stroka='Расчет процесса в объекте регулирования'
+i = 0
+sps2=[]
+while i<len(stroka):
+	r=1-2/(1+math.exp(0.1*i))
+	sps2.append(r)
+	print('Значение в момент',i,"=",r)
+	i+=1
+
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+```
+
+Отображение графика:
+```py
+x = list(range(i))                   
+y = list(sps2)                    
+pylab.plot(y,x)                    
+[<matplotlib.lines.Line2D object at 0x00000228A3ECCF50>]
+pylab.title('График 2')                  
+Text(0.5, 1.0, 'График 2')
+pylab.show()
+```
+![](ris2.png)
+
+### 4.3.Проверка на простое число
+
+```py
+chislo = 267
+kandidat = chislo//2 # 267//2 = 133 - максимально возможный делитель
+while kandidat > 1:
+	if chislo%kandidat == 0: #проверка делимости
+		print(chislo, ' имеет множитель ',kandidat)
+		break #выявляется ПЕРВЫЙ возможный множитель(кроме 1) и завершает цикл
+	kandidat -= 1 #рассматриваем остальные числа
+else:
+	print(chislo,' является простым!')
+
+	
+267  имеет множитель  89 
+```
+Программа проверка на простые числа в диапазоне от 250 до 300:
+
+```py
+for chislo in range(250,301):
+	kandidat = chislo//2
+	while kandidat > 1:
+		if chislo%kandidat == 0:
+			print(chislo, ' имеет множитель ',kandidat)
+			break
+		kandidat -= 1
+	else:
+		print(chislo,' является простым!')
+
+		
+250  имеет множитель  125
+251  является простым!
+252  имеет множитель  126
+253  имеет множитель  23
+254  имеет множитель  127
+255  имеет множитель  85
+256  имеет множитель  128
+257  является простым!
+258  имеет множитель  129
+259  имеет множитель  37
+260  имеет множитель  130
+261  имеет множитель  87
+262  имеет множитель  131
+263  является простым!
+264  имеет множитель  132
+265  имеет множитель  53
+266  имеет множитель  133
+267  имеет множитель  89
+268  имеет множитель  134
+269  является простым!
+270  имеет множитель  135
+271  является простым!
+272  имеет множитель  136
+273  имеет множитель  91
+274  имеет множитель  137
+275  имеет множитель  55
+276  имеет множитель  138
+277  является простым!
+278  имеет множитель  139
+279  имеет множитель  93
+280  имеет множитель  140
+281  является простым!
+282  имеет множитель  141
+283  является простым!
+284  имеет множитель  142
+285  имеет множитель  95
+286  имеет множитель  143
+287  имеет множитель  41
+288  имеет множитель  144
+289  имеет множитель  17
+290  имеет множитель  145
+291  имеет множитель  97
+292  имеет множитель  146
+293  является простым!
+294  имеет множитель  147
+295  имеет множитель  59
+296  имеет множитель  148
+297  имеет множитель  99
+298  имеет множитель  149
+299  имеет множитель  23
+300  имеет множитель  150
+```
+
+### 4.4.Инструкция continue.
+
+Помимо инструкции break в обоих видах циклов могут использоваться инструкции continue, которые не вызывают завершения цикла, но завершают его текущий виток и обеспе-чивают переход к следующему витку.
+
+```py
+for i in range(1, 11):
+    if i % 2 == 1:  # если число нечетное
+        continue    # пропускаем оставшийся код
+    print(i)        # этот код выполнится только для четных чисел
+
+    
+2
+4
+6
+8
+10
+```
+
+## 5.Завершение работы со средой IDLE.

TEMA5/task.md

@@ -0,0 +1,100 @@
+## Общее контрольное задание по Теме 5
+
+Похил Анастасия, А-02-23
+
+## Задание
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+•Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+•Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+•Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его сред-ние баллы по двум сессиям.
+
+## Решение
+
+### 1)Определение порядкового номера каждой буквы.
+```py
+str1 = "really love programming"
+alfavit = "abcdefghijklmnopqrstuvwxyz"
+for i in str1:
+	if i in alfavit:
+		num = alfavit.index(i) + 1
+		print('В алфавите буква ',i,' под номером ',num)
+	else: continue
+
+	
+В алфавите буква  r  под номером  18
+В алфавите буква  e  под номером  5
+В алфавите буква  a  под номером  1
+В алфавите буква  l  под номером  12
+В алфавите буква  l  под номером  12
+В алфавите буква  y  под номером  25
+В алфавите буква  l  под номером  12
+В алфавите буква  o  под номером  15
+В алфавите буква  v  под номером  22
+В алфавите буква  e  под номером  5
+В алфавите буква  p  под номером  16
+В алфавите буква  r  под номером  18
+В алфавите буква  o  под номером  15
+В алфавите буква  g  под номером  7
+В алфавите буква  r  под номером  18
+В алфавите буква  a  под номером  1
+В алфавите буква  m  под номером  13
+В алфавите буква  m  под номером  13
+В алфавите буква  i  под номером  9
+В алфавите буква  n  под номером  14
+В алфавите буква  g  под номером  7
+```
+
+### 2)Наличие и отсутствие элемента в списке.
+
+```py
+str2 = """Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом)."""
+spis2 = str2.split()
+print(spis2)
+words = ["список","слово"]
+i = 0
+while i < len(words): #i - слово 1 и 2
+	word = words[i]
+	j = 0
+	while j < len(spis2):
+		if spis2[j] == word:
+			print('В списке нашелся элемент \"',word,'\"')
+			break
+		j += 1
+	else:
+		print('В списке элемент \"',word,'\" отсутствует')
+	i += 1 #переход ко второму слову в  words
+	
+В списке нашелся элемент " словами "
+В списке элемент " значения " отсутствует
+```
+
+### 3)Инструкция вывода среднего балла по заданной фамилии.
+
+```py
+studs = ['Похил','Криви','Сарайкина','Беженарь']
+ball = [4.8, 4.5, 4.7, 4.9]
+studs1 = ['Похил','Беженарь','Криви','Сарайкина']
+ball1 = [4.8, 5.0, 4.7, 4.7]
+ch = input('Фамилия студента: ')
+ball0 = 0
+for i in range(len(studs)):
+    if studs[i] == ch:
+        ball0 = ball[i]
+        break
+
+print('Средний балл летней сессии: ',ball0)
+
+ch1 = input('Фамилия студента: ')
+ball3 = 0
+for j in range(len(studs1)):
+    if studs1[i] == ch1:
+        ball3 = ball1[i]
+        break
+
+print('Средний балл зимней сессии: ',ball3)
+
+Фамилия студента: Похил
+Средний балл летней сессии:  4.8
+Фамилия студента: Сарайкина
+Средний балл зимней сессии:  4.7
+```

TEMA5/test.md

@@ -0,0 +1,28 @@
+# Индивидуальное контрольное задание
+
+Похил Анастасия, А-02-23, вариант 7
+
+## Задание
+# Индивидуальное контрольное задание
+
+Похил Анастасия, А-02-23, вариант 18
+
+## Задание
+Создайте символьную строку с номером вашего мобильного телефона, записанного по шаблону (ХХХ)ХХХ-ХХ-ХХ. Напишите инструкции, которые создадут другую символьную строку по шаблону ХХХ-ХХХ-ХХХХ. Обеспечить вывод сообщения на экран: если первые 3 цифры 916 или 902, то «Оператор МТС», иначе: «Неизвестный оператор».
+
+## Решение
+```py
+number = '(920)928-13-31'
+str1 = ''
+for i in number:
+    if i in '012346789':
+        str1 += i
+
+new_number = str1[:3]+'-'+str1[3:6]+'-'+str1[6:]
+if str1[:3] == '916' or str1[:3] == '902':
+    print("Оператор МТС")
+else: print("Неизвестный оператор")
+
+print(new_number)        
+```
+

TEMA6/report.md

@@ -0,0 +1,474 @@
+# Отчет по Теме 6
+
+Похил Анастасия, А-02-23
+
+## 1. Запущена интерактивная оболочка IDLE. 
+
+## 2. Вывод данных на экран дисплея.
+
+### 2.1. Вывод в командной строке
+
+"Эхо-вывод"
+
+```py
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+### 2.2. Вывод с использованием функции print
+
+Пример вывода:
+
+```py
+fff=234.5;gg='Значение температуры = '
+print(gg, fff)   #Можно вывести несколько объектов за одно обращение к функции
+
+Значение температуры =  234.5
+```
+По умолчанию выводимые объекты разделяются одним пробелом. Если нужен другой разделитель его можно указать в отдельном аргументе sep:
+
+```py
+fff=234.5;gg='Значение температуры = '
+print(gg, fff, sep='/')
+Значение температуры = /234.5
+```
+Если курсор надо оставить в той же строке, то следует использовать еще один аргумент. После end= надо указать какими символами должна закончиться выводимая строка или указать пустую строку. 
+
+```py
+print(gg, fff,sep='/',end='***'); print('____')
+Значение температуры = /234.5***____
+```
+Наконец, оператор вывода может располагаться на нескольких строках с использованием тройных кавычек.
+
+```py
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+Тройные кавычки сохраняют переносы строк, выводя текст в несколько строк, а несколько аргументов в print() разделяются пробелами и выводятся в одну строку.
+
+### 2.3. Вывод с использованием метода write объекта sys.stdout.
+
+Объект stdout представляет собой поток стандартного вывода – объект, в который программы вы-водят символьное представление данных.
+
+```py
+import sys
+sys.stdout.write('Функция write')
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+Этот метод после вывода строки не осуществляет переход на новую строку. Если это требуется, то следует в конце строки добавить один или несколько символов “\n”. Функция write() возвращает число — количество успешно записанных символов. 
+
+## 3. Ввод данных с клавиатуры
+
+Для ввода с клавиатуры используется функция input. Полученный объект имеет строковый тип данных.
+
+```py
+psw=input('Введите пароль:')
+Введите пароль:12345
+psw
+'12345'
+type(psw)
+<class 'str'>
+```
+
+Пример 1. Ввод с контролем значения.
+
+```py
+while True:
+    znach=float(input('Задайте коэф.усиления = '))
+    if znach<17.5 or znach>23.8:
+        print('Ошибка!')
+    else:
+        break
+
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+```
+
+Пример 2. Ввод и обработка выражения.
+
+```py
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4. Ввод-вывод при работе с файлами.
+
+### 4.1 Функции для работы с путем к файлу.
+
+Используя функцию os.getcwd(), можно получить путь к текущему рабочему каталогу.
+При обычном эхо-выводе отображаются двойные обратные слэши, при использовании print() - одинарные.
+
+```py
+import os
+os.getcwd()
+'C:\\Users\\Настя\\AppData\\Local\\Programs\\Python\\Python313'
+Pohil=os.getcwd(); print(Pohil)
+C:\Users\Настя\AppData\Local\Programs\Python\Python313
+```
+
+Была использована функция os.chdir() для смены рабочего каталога.
+
+```py
+os.chdir('C:\\Users\\Настя\\Desktop\\python-labs\\TEMA6')
+os.getcwd()
+'C:\\Users\\Настя\\Desktop\\python-labs\\TEMA6'
+```
+
+Функция os.mkdir() создаёт новый каталог.
+
+```py
+os.mkdir('katalog1')
+os.chdir('katalog1')
+os.getcwd()
+'C:\\Users\\Настя\\Desktop\\python-labs\\TEMA6\\katalog1'
+```
+
+Функция os.listdir() возвращает список каталогов и файлов, находящихся внутри данного каталога.
+
+```py
+os.chdir('../')
+os.listdir()
+['.gitkeep', '123.py', 'katalog1', 'report.md']
+```
+
+Удаление каталога через os.rmdir().
+
+```py
+os.rmdir('katalog1')       
+os.listdir()
+['.gitkeep', '123.py', 'report.md']
+```
+os.path.isdir() позволяет проверить наличие каталога. Для несуществующих каталогов, ровно как и для любых файлов, которые не являются в свою очередь каталогами - возвращает False.
+
+```py 
+os.path.isdir('report.md')        
+False
+os.chdir('../')    
+os.path.isdir('TEMA6')
+True
+```
+
+Был получен путь до файла, имя которого передаётся в качестве аргумента в os.path.abspath(). Затем из абсолютного пути был извлечен путь до каталога, в котором находится файл, затем имя самого файла, после чего был получен кортеж с путём до каталога и именем файла, находящегося внутри него.
+
+```py
+fil=os.path.abspath('report.md'); print(fil)        
+C:\Users\Настя\Desktop\python-labs\report.md
+fil = os.path.abspath("oplata.dbf")
+drkt=os.path.dirname(fil); print(drkt)
+C:\Users\Настя\Desktop\python-labs
+bsn=os.path.basename(fil); print(bsn)
+oplata.dbf
+os.path.split(fil)
+('C:\\Users\\Настя\\Desktop\\python-labs', 'oplata.dbf')
+```
+
+Проверено наличие файла с известным расположением с помощью функции os.path.exists. Возвращаемое значение: True или False. 
+
+```py
+os.path.exists(fil)       
+True
+fil1=drkt+'\\katalog1'; print(fil1)        
+C:\Users\Настя\Desktop\python-labs\TEMA6\katalog1
+os.path.exists(fil1)       
+False
+```
+
+Проверка на наличие файла с известным расположением.
+
+```
+os.path.isfile(fil)         
+True
+os.path.isfile(os.path.dirname(fil)+'fil1.txt')         
+False
+```
+dirname() возвращает путь, то os.path.basename() возвращает имя файла
+
+### 4.2. Общая схема работы с файлом
+
+Для обмена данными с файлом необходимо выполнить следующие операции:
+1. Открытие файла с указанием его имени и цели (чтение, запись, добавление данных);
+2. Выполнение одной или нескольких операций обмена данными с файлом;
+3. Закрытие файла.
+
+### 4.3. Открытие файла для записи или чтения данных – функция open
+
+Был создан файловый объект fp класса _io.TextIOWrapper для работы с текстовыми данными.
+В аргументе функции с именем file указывается путь и имя открываемого файла, а в аргументе с именем mode – предполагаемая цель его использования.
+Файл по такой инструкции открывается только для записи в файл. Если требуются другие операции с открываемым файлом, то для второго аргумента mode могут  быть заданы следующие значения:
+w – запись с созданием нового файла или перезапись существующего файла,
+w+ - чтение и запись/перезапись файла,
+r – только чтение (это значение - по умолчанию),
+r+ - чтение и/или запись в существующий файл,
+a – запись в конец существующего файла или, если его нет, запись с созданием файла,
+a+ - то же, но с возможностью чтения из файла.
+
+```py
+fp=open(file=drkt+'\\zapis1.txt',mode='w')       
+type(fp); dir(fp)        
+<class '_io.TextIOWrapper'>
+['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'reconfigure', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'write_through', 'writelines']
+```
+
+Вообще говоря, аргументы функции при указании их имен могут располагаться в любом порядке. 
+Если же имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать, а вводить в соответствующем порядке.
+Также если путь в переменной drkt совпадает с рабочим каталогом, то его можно опустить, оставив только имя открываемого файла.
+
+```py
+fp=open(drkt+'\\zapis1.txt','w')        
+fp=open('zapis1.txt','w')
+```
+
+Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели надо добавить символ b. 
+
+```
+fp1=open(drkt+'\\zapis2.bin',mode='wb+')
+```
+
+### 4.4. Закрытие файла.
+Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. 
+
+```py
+fp.close()
+```
+
+### 4.5. Запись информации в файл с помощью метода write
+
+Метод write относится к объекту – файловой переменной. Пример:
+
+```py
+sps=list(range(1,13))        
+fp2=open('zapis3.txt','w')         
+fp2.write(str(sps[:4])+'\n')         
+13
+fp2.write(str(sps[4:8])+'\n')         
+13
+fp2.write(str(sps[8:])+'\n')        
+16
+fp2.close()
+```
+
+Содержимое файла zapis3.txt:
+
+```py
+[1, 2, 3, 4]
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+Пример со списком, содержащим внутри себя списки. Первая попытка:
+
+```
+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)
+
+11
+11
+12
+fp3.close()
+```
+Содержимое файла zapis4.txt:
+
+```py
+Иванов И. 1Петров П. 2Сидоров С. 3
+```
+
+Добавляем '\n':
+
+```py
+gh=open('zapis5.txt','w')         
+for r in sps3:
+    gh.write(r[0]+' '+str(r[1])+'\n')
+
+12
+12
+13
+gh.close()
+```
+Новое одержимое файла zapis4.txt:
+
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+С представлением цикла в одной строке:
+
+```py
+gh=open('zapis5.txt','w')         
+for r in sps3: gh.write(r[0]+' '+str(r[1])+'\n')
+        
+12
+12
+13
+gh.close()
+```
+
+```py
+Иванов И. 1
+Петров П. 2
+Сидоров С. 3
+```
+
+### 4.6. Первый способ чтения информации из текстового файла.
+
+```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()         
+sps1         
+['1', ' 2', ' 3', ' 4', '5', ' 6', ' 7', ' 8', '9', ' 10', ' 11', ' 12']
+sps         
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+Полученный при чтении файла список sps1 содержит элементы строкового типа (необходим целочисленный, как в sps). Преобразуем элементы списка:
+
+```py
+sps3=list(map(int, sps1))        
+sps3       
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+```
+
+### 4.7. Чтение информации из файла с помощью метода read
+
+В качестве аргумента этого метода может задаваться целое число – количество символов или, ес-ли открыт бинарный файл, - количество байт, которое должно быть прочитано, соответственно, из текстового или бинарного файла, начиная с текущего положения маркера. Если указанное число превышает количество оставшихся символов (байт) в файле, то считываются все оставши-еся символы (байты). Если это число не указано, то считываются вся информация от маркера до конца файла. Метод возвращает строку с символами или совокупность байт, прочитанных из файла. Например,
+
+```py
+fp=open('zapis3.txt')        
+stroka1=fp.read(12)         
+stroka2=fp.read()         
+fp.close()         
+stroka1; stroka2       
+'[1, 2, 3, 4]'
+'\n[5, 6, 7, 8]\n[9, 10, 11, 12]\n'
+```
+
+### 4.8. Чтение информации с помощью методов readline и readlines.
+
+```py
+fp=open('zapis3.txt')        
+s1=fp.readline()        
+s2=fp.readlines()       
+fp.close()      
+s1; s2
+'[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)
+fp.close()
+```
+
+Содержимое файла zapis6.mnz:
+
+```py
+Ђ•#       Џ”(Њpen”Њtable”Њbook”ЊiPhone”ђ.
+```
+
+При прочтении данных из файла было получено то же самое множество, что и созданное ранее.
+
+```py
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)
+fp.close()
+mnoz2
+{'book', 'table', 'pen', 'iPhone'}
+mnoz1 == mnoz2
+True
+```
+
+При считывании объекты извлекаются из файла в той же последовательности, в которой они в него записывались.
+
+```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)
+obj2=pickle.load(fp)
+fp.close()
+obj1; obj2
+{'book', 'table', 'pen', 'iPhone'}
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
+obj1 == mnoz1; obj2 == sps3
+True
+True
+```
+
+## 5. Перенаправление потоков ввода и вывода данных
+
+```py
+import sys
+vr_out=sys.stdout
+fc=open('Stroka.txt','w')
+sys.stdout=fc
+print('запись строки в файл')
+sys.stdout=vr_out
+print('запись строки в файл')
+запись строки в файл
+fc.close()
+```
+
+Содержимое файла Stroka.txt:
+
+```py
+запись строки в файл
+```
+
+Подобным образом можно перенаправить и поток ввода.
+
+```py
+tmp_in = sys.stdin
+fd = open("Stroka.txt", "r")
+sys.stdin = fd
+sys.stdin
+<_io.TextIOWrapper name='Stroka.txt' mode='r' encoding='cp1251'>
+while True:
+    try:
+        line = input ()
+        print(line) 
+    except EOFError:
+        break
+
+запись строки в файл
+fd.close()
+sys.stdin=tmp_in
+```
+
+## 6. Закончен сеанс работы с IDLE.

TEMA6/task.md

@@ -0,0 +1,63 @@
+# Общее контрольное задание по теме 6
+
+Похил Анастасия, А-02-23
+
+## Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+3. Записывается кортеж в бинарный файл.
+4. Записывается в этот же файл список и закрывается файл.
+5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+7. Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
+
+## Выполнение
+
+1. Создание кортежа
+```py
+import random
+tup1=[]           
+for i in range(125): tup1.append(str(random.randint(6, 56)))
+tup1=tuple(tup1); tup1
+('46', '21', '28', '45', '35', '15', '42', '20', '20', '31', '32', '23', '25', '56', '16', '42', '11', '44', '15', '7', '41', '27', '27', '54', '51', '15', '20', '48', '52', '15', '38', '17', '19', '56', '22', '33', '16', '53', '19', '11', '31', '10', '7', '6', '15', '16', '20', '28', '44', '26', '24', '51', '16', '17', '38', '31', '28', '26', '25', '43', '16', '23', '34', '48', '33', '53', '26', '33', '38', '29', '8', '36', '49', '53', '49', '13', '51', '13', '49', '46', '35', '13', '12', '48', '25', '56', '50', '30', '6', '56', '9', '11', '16', '38', '33', '7', '16', '10', '47', '32', '43', '38', '10', '7', '12', '35', '22', '35', '12', '39', '15', '32', '27', '42', '52', '20', '51', '10', '22', '49', '26', '6', '12', '49', '22')        
+```
+
+2-4. Создание списка, запись кортежа и списка в бинарный файл, чтение обоих объектов из файла
+
+```py
+sps1=['Похил', 'Сарайкина', 'Цветкова', 'Шинкаренко', 'Снегура']
+import pickle
+fp=open('fil.mnz', 'wb')
+pickle.dump(tup1, fp)
+pickle.dump(sps1, fp)
+fp.close()
+fp=open('fil.mnz', 'rb')
+tup2=pickle.load(fp)
+sps2=pickle.load(fp)
+fp.close()
+```
+
+5. Проверка на совпадение объектов 
+
+```py
+print('Кортежи совпадают') if tup1 == tup2 else print('Кортежи не совпадают')
+Кортежи совпадают
+print('Списки совпадают') if sps1 == sps2 else print('Списки не совпадают')
+Списки совпадают
+```
+
+6. Разделение кортежа на списки по 5 чисел, представленных в строковом виде.
+
+```py
+for i in range(0, len(tup1), 5):
+    exec('spisk' + str(i//5+1) + '=' + str(list(tup1[i:i+5])))
+
+spisk1
+['46', '21', '28', '45', '35']
+spisk2
+['15', '42', '20', '20', '31']
+spisk3
+['32', '23', '25', '56', '16']
+```

TEMA6/test.md

@@ -0,0 +1,45 @@
+# Тест модуля 2
+
+Похил Анастасия, А-02-23, вариант 22
+
+## Задание
+1)Создайте список с вашей фамилией и 3 фамилиями других студентов вашей группы и список с 4 элементами - средними баллами этих студентов.
+
+2)Запросите у пользователя и введите имя словаря. Удалите из этого имени возможные пробелы.
+
+3)Создайте словарь, в котором ключами будут фамилии студентов из первого списка, а значениями - их средние баллы.
+
+4)Выведите словарь в бинарный файл с некоторым именем.
+
+5)Рассчитайте общий средний балл по группе из 4-х указанных студентов. Отобразите рассчитанное значение по шаблону "Общее среднее =<рассчитанное значение>". Выводимое значение округлить до 1 цифры после точки.
+
+
+
+## Решение
+```py
+import pickle
+names = ['Похил', 'Сарайкина', 'Шинкаренко', 'Цветкова']
+ball = [5.0, 5.0, 5.0, 5.0]
+name_sl = input("Имя словаря: ").replace(' ', '')
+sl = dict(zip(names, ball))
+print(sl)
+fp = open('test.bin','wb')
+pickle.dump(sl, fp)
+fp.close()
+sr_ball = sum(sl.values())/len(sl)
+print("Общее среднее =", sr_ball)
+fp=open('test.bin','rb')
+sl2=pickle.load(fp)
+fp.close()
+print(sl2)
+print(sl == sl2)     
+```
+
+## Результат программы 
+```py
+Имя словаря: top
+{'Похил': 5.0, 'Сарайкина': 5.0, 'Шинкаренко': 5.0, 'Цветкова': 5.0}
+Общее среднее = 5.0
+{'Похил': 5.0, 'Сарайкина': 5.0, 'Шинкаренко': 5.0, 'Цветкова': 5.0}
+True
+```

TEMA7/report.md

@@ -0,0 +1,599 @@
+# Отчёт по Теме 7
+
+Похил Анастасия, А-02-23
+
+# 1. Запуск интерактивной оболочки IDLE
+
+# 2. Создание пользовательской функции
+
+Создание функции предполагает выполнение трех операций: формирование функции, ее сохра-нение и использование. 
+В общем виде функция в языке Python представляется так:
+def  <Имя функции>([<Список аргументов >]):
+[<отступы>"""<Комментарий по назначению функции>"""]
+<отступы><Блок инструкций – тело функции>
+[<отступы>return <Значение или вычисляемое выражение>]
+
+# 2.1 Функция без аргументов
+```py
+ef uspeh():
+	"""Подтверждение успеха операции"""
+	print('Выполнено успешно!')
+
+uspeh()
+Выполнено успешно!
+dir(uspeh)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+type(uspeh)
+<class 'function'>
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+
+## 2.2 Функция с аргументами
+```py
+def sravnenie(a,b):
+	"""Сравнение a и b"""
+	if a>b:
+		print(a,' больше ',b)
+	elif a<b:
+		print(a, ' меньше ',b)
+	else:
+		print(a, ' равно ',b)
+
+n,m=16,5;sravnenie(n,m)
+16  больше  5
+sravnenie("abc", "abcd")
+abc  меньше  abcd
+```
+Функция универсальна и будет работать с любыми типами данных, для которых определены операторы сравнения >, <, == (числа, строки, списки, кортежи и др.)Сравнение строк происходит по алфавиту, так же значение имеет регистр букв (заглавные меньше строчных), более короткая строка считается меньшей.
+
+
+## 2.3 Пример функции, содержащей return.
+
+```py
+def logistfun(b,a):
+	"""Вычисление логистической функции"""
+	import math
+	return a/(1+math.exp(-b))
+
+    
+v,w=1,0.7;z=logistfun(w,v)
+z
+0.6681877721681662
+```
+
+## 2.4 Сложение для разных типов аргументов
+
+```py
+def slozh(a1,a2,a3,a4):
+	""" Сложение значений четырех аргументов"""
+	return a1+a2+a3+a4
+slozh(1,2,3,4)
+10
+slozh('1','2','3','4')
+'1234'
+b1=[1,2];b2=[-1,-2];b3=[0,2];b4=[-1,-1]
+q=slozh(b1,b2,b3,b4)
+q
+[1, 2, -1, -2, 0, 2, -1, -1]
+t1 = (1, 2); t2 = (3, 4); t3 = (5,); t4 = (6, 7, 8)
+slozh(t1, t2, t3, t4)
+(1, 2, 3, 4, 5, 6, 7, 8)
+d1 = {'a': 1}; d2 = {'b': 2}
+slozh(d1, d2, {}, {})
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+s1 = {1, 2}; s2 = {2, 3}
+slozh(s1, s2, set(), set())
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+Как видно сложение для множеств и словарей не применимо. ункция slozh работает только для тех типов данных, которые поддерживают оператор +.
+
+## 2.5 Функция, реализующая модель некоторого устройства, на вход которого в текущий момент поступает сигнал х, на выходе получается сигнал y:
+
+```py
+def inerz(x,T,ypred):
+	""" Модель устройства с памятью:
+x- текущее значение вх.сигнала,
+	T -постоянная времени,
+	ypred - предыдущее значение выхода устройства"""
+	y=(x+T*ypred)/(T+1)
+	return y
+
+sps=[0]+[1]*100
+spsy=[] #Заготовили список для значений выхода
+TT=20 #Постоянная времени
+yy=0  #Нулевое начальное условие
+for xx in sps:
+	yy=inerz(xx,TT,yy)
+	spsy.append(yy)
+
+import matplotlib.pyplot as plt
+plt.plot(sps, 'r-', label='Вход')
+[<matplotlib.lines.Line2D object at 0x000001B544DC4E10>]
+plt.plot(spsy, 'b-', label='Выход')
+[<matplotlib.lines.Line2D object at 0x000001B544DF5090>]
+plt.grid(True)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B544DD1E80>
+plt.show()
+```
+
+![График](Figure_1.png)
+
+
+# 3. Функции как объекты
+
+## 3.1 Получение списка атрибутов объекта-функции
+
+```py
+dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+inerz.__doc__
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\n        T -постоянная времени,\n        ypred - предыдущее значение выхода устройства'
+help(inerz)
+Help on function inerz in module __main__:
+
+inerz(x, T, ypred)
+    Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+            T -постоянная времени,
+            ypred - предыдущее значение выхода устройства
+```
+Атрибут __doc__ содержит значение docstring, если при инициализации функции он был задан. Если не был, то inerz.__doc__ будет иметь значение None.
+
+## 3.2 Сохранение ссылки на объект-функции в другой переменной
+
+```py
+fnkt=sravnenie
+v=16
+fnkt(v,23)
+16  меньше  23
+```
+
+Функции можно передавать в переменные, как и любые другие объекты. После этого переменная fnkt ссылается на ту же самую функцию, что и sravnenie.
+
+## 3.3 Возможность альтернативного определения функции в программе
+
+```py
+typ_fun=8
+if typ_fun==1:
+	def func():
+		print('Функция 1')
+else:
+	def func():
+		print('Функция 2')
+
+func()
+Функция 2
+```
+
+Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и
+выполняется блок else, в котором функция func определена как выводящая "Функция 2". 
+
+# 4. Аргументы функции
+
+## 4.1 Возможность использования функции в качестве аргумента другой функции
+
+```py
+def fun_arg(fff,a,b,c):
+	"""fff-имя функции, используемой 
+	в качестве аргумента функции fun_arg"""
+	return a+fff(c,b)
+
+zz=fun_arg(logistfun,-3,1,0.7)
+zz
+-2.3318122278318336
+```
+
+Python передаёт ссылку на объект функции logistfun в переменную fff.
+
+## 4.2 Обязательные и необязательные аргументы
+
+```py
+def logistfun(a,b=1):   #Аргумент b – необязательный; значение по умолчанию=1
+	"""Вычисление логистической функции"""
+	import math
+	return b/(1+math.exp(-a))
+
+logistfun(0.7)     #Вычисление со значением b по умолчанию
+0.6681877721681662
+logistfun(0.7,2)  #Вычисление с заданным значением b
+1.3363755443363323
+```
+
+## 4.3 Возможность обращения к функции с произвольным (непозиционным) расположением аргументов.
+При этом надо в обращении к функции указывать имена аргументов.
+
+```py
+logistfun(b=0.5,a=0.8)  # Ссылки на аргументы поменялись местами
+0.34498724056380625
+```
+
+## 4.4 Пример со значениями аргументов функции, содержащимися в списке или кортеже
+
+```py
+b1234=[b1,b2,b3,b4]  # Список списков из п.2.4
+qq=slozh(*b1234)  #Перед ссылкой на список или кортеж надо ставить звездочку
+qq
+[1, 2, -1, -2, 0, 2, -1, -1]
+```
+Количество элементов в списке должно совпадать с количеством параметров функции. Оператор * выполняет распаковку списка в аргументы функции.
+
+## 4.5 Пример со значениями аргументов функции, содержащимися в словаре
+
+```py
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq=slozh(**dic4)  #Перед ссылкой на словарь надо ставить две звездочки
+qqq
+10
+slozh(*dic4)
+'a1a2a3a4'
+``` 
+Для ** распаковки имена ключей должны точно совпадать с именами параметров функции
+
+## 4.6 Смешанные ссылки
+
+```py
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+17
+```
+
+## 4.7 Переменное число аргументов у функции
+
+```py
+def func4(*kort7):
+	"""Произвольное число аргументов в составе кортежа"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return smm
+
+func4(-1,2)  #Обращение к функции с 2 аргументами
+1
+func4(-1,2,0,3,6)  #Обращение к функции с 5 аргументами
+10
+```
+Функция принимает любое количество аргументов
+
+## 4.8 Комбинация аргументов
+
+```py
+def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
+	"""Кортеж - сборка аргументов - должен быть последним!"""
+	smm=0
+	for elt in kort7:
+		smm+=elt
+	return a*smm+b
+
+func4(-1,2,0,3,6)
+-7
+```
+a = -1 (первый позиционный)
+b = 2 (второй позиционный, переопределил значение по умолчанию 7)
+*kort7 = (0, 3, 6) (все остальные аргументы в кортеж)
+Если мы не хотим передавать b, придется переопределить функцию так, чтобы именованный параметр b был в конце, а позиционный кортеж - перед ним.
+
+Подобным же образом в списке аргументов функции также можно использовать словарь.
+
+```py
+def func5(a, b=7, *args, **kwargs):
+    """a-позиционный, b-по умолчанию, *args-кортеж, **kwargs-словарь"""
+    print("a=" + str(a) + ", b=" + str(b))
+    print("args=" + str(args))
+    print("kwargs=" + str(kwargs))
+    
+    total = a + b + sum(args)
+    for value in kwargs.values():
+        total += value
+    return total
+
+result = func5(1, 2, 3, 4, x=5, y=6)
+a=1, b=2
+args=(3, 4)
+kwargs={'x': 5, 'y': 6}
+result
+21
+```
+*args и **kwargs - способы передать не уточненное заранее число элементов:
+*args — переменное количество позиционных аргументов. Переданные с одной звездочкой аргументы собираются в кортеж.
+**kwargs — переменное количество именованных аргументов. Все переданные аргументы, которые указываются по имени, собираются в словарь.
+*args всегда должно идти перед **kwargs.
+
+## 4.9 Изменение значений объектов, используемых в качестве аргументов функции.
+Такое изменение возможно только у объектов изменяемого типа
+
+```py
+a=90    # Числовой объект – не изменяемый тип
+def func3(b):
+	b=5*b+67
+
+func3(a)
+a
+90
+```
+Локальная b меняется, но внешняя a нет
+
+Пример со списком:
+
+```py
+sps1=[1,2,3,4]  #Список – изменяемый тип объекта
+def func2(sps):
+	sps[1]=99
+
+func2(sps1)
+sps1
+[1, 99, 3, 4]
+```
+Изменяемые типы (списки, словари, множества) передаются по ссылке
+
+Пример с кортежем:
+
+```py
+kort=(1,2,3,4)   #Кортеж – неизменяемый тип объекта
+func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#78>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#74>", line 2, in func2
+    sps[1]=99
+TypeError: 'tuple' object does not support item assignment
+```
+
+Кортеж - неизменяемый тип данных, так что переназначение в таком виде не работает.
+
+# 5. Специальные типы  пользовательских функций
+
+## 5.1 Анонимные функции
+
+Анонимные функции или по-другому их называют лямбда-функциями – это функции без имени, определяемые по следующей схеме:
+lambda [<Аргумент1>[,<Аргумент2>,…]]:<Возвращаемое значение или выражение>
+Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
+
+```py
+mport math
+anfun1=lambda: 1.5+math.log10(17.23)  #Анонимная функция без аргументов
+anfun1()   # Обращение к объекту-функции
+2.7362852774480286
+anfun2=lambda a,b : a+math.log10(b)  #Анонимная функция с 2 аргументами
+anfun2(17,234)
+19.369215857410143
+anfun3=lambda a,b=234: a+math.log10(b) #Функция с необязательным вторым аргументом
+anfun3(100)
+102.36921585741014
+```
+Вызов лямбда-функции создает объект класса "функция". Внутри лямбда-функции не могут использоваться многострочные выражения, нельзя использовать if-else.
+
+## 5.2 Функции-генераторы
+
+Это – такие функции, которые используются в итерационных процессах, позволяя на каждой итерации получать одно из значений. Для этого в функцию включают инструкцию yield приостанавливающую её выполнение и возвращающую очередное значение.
+Данный оператор в отличие от return не останавливает полностью выполнение программы. Когда выполнение функции возобновляется после yield, оно продолжается с того места, где было
+приостановлено, до следующего оператора yield (или до конца функции).
+
+```py
+def func5(diap,shag):
+	""" Итератор, возвращающий значения
+	из диапазона от 1 до diap с шагом shag"""
+	for j in range(1,diap+1,shag):
+		yield j
+
+for mm in func5(7,3):
+	print(mm)
+
+1
+4
+7
+alp=func5(7,3)
+print(alp.__next__())
+1
+print(alp.__next__())
+4
+print(alp.__next__())
+7
+print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#92>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+Здесь при каждом обращении к функции будет генерироваться только одно очередное значение.
+При программировании задач у таких функций часто используют метод __next__, активирующий очередную итерацию выполнения функции.
+__next__ помогает вывести значение, которое yield передает на каждой итерации цикла. Если функция отработала последнюю итерацию, но мы попытаемся сделать вызов, вернется ошибка.
+В отличии от функций, которые возвращают список со значениями итераций, функции - генераторы генерируют значения по одному, не храня всё в памяти; а функция, возвращающая список создаёт весь список в памяти. Также генератор можно использовать только один раз - после прохождения всех значений он "опустошается" и больше не производит элементов.
+
+# 6. Локализация объектов в функциях
+
+По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Глобальные – это те объекты, значения которых заданы вне функции.
+Локализация может быть переопределена путем прямого объявления объектов как глобальных с помощью дескриптора global.
+
+## 6.1 Примеры на локализацию объектов
+
+Пример 1. Одноименные локальный и глобальный объекты:
+
+```py
+glb=10
+def func7(arg):
+	loc1=15
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+res
+150
+glb
+10
+```
+Если внутри функции есть присваивание glb = ..., то создается локальная переменная, даже если есть глобальная с таким же именем.
+Для изменения глобальной переменной нужно использовать global glb
+
+Пример 2. Ошибка в использовании локального объекта.
+
+```py
+def func8(arg):
+	loc1=15
+	print(glb)  
+	glb=8
+	return loc1*arg
+
+res=func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#100>", line 1, in <module>
+    res=func8(glb)
+  File "<pyshell#99>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+Нельзя обращаться к переменной до ее присваивания, если она считается локальной в функции.
+
+Пример 3. Переопределение локализации объекта.
+
+```py
+glb=11
+def func7(arg):
+	loc1=15
+	global glb
+	print(glb)
+	glb=8
+	return loc1*arg
+
+res=func7(glb)
+11
+```
+
+Здесь мы явно указали, что в функции используем глобальную переменную, поэтому она изменилась.
+
+## 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins
+
+Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
+
+```py
+globals().keys()  #Перечень глобальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+locals().keys()  #Перечень локальных объектов
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+Различий нет, потому что команды выполнены в глобальной области видимости, где globals() и locals() ссылаются на один и тот же словарь. Различия появляются только при вызове locals() внутри функций или методов.
+
+```py
+def func8(arg):
+	loc1=15
+	glb=8
+	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
+	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
+	return loc1*arg
+
+hh=func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'loc1', 'glb'])
+'glb' in globals().keys()
+True
+```
+locals() внутри функции показывает только её внутренние переменные, а globals() показывает все объекты модуля.
+
+## 6.3 Локализация объектов при использовании вложенных функций
+
+```py
+def func9(arg2,arg3):
+	def func9_1(arg1):
+		loc1=15
+		glb1=8
+		print('glob_func9_1:',globals().keys())
+		print('locl_func9_1:',locals().keys())
+		return loc1*arg1
+	loc1=5
+	glb=func9_1(loc1)
+	print('loc_func9:',locals().keys())
+	print('glob_func9:',globals().keys())
+	return arg2+arg3*glb
+
+kk=func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ_fun', 'func', 'fun_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'func5', 'result', 'a', 'func3', 'sps1', 'func2', 'kort', 'math', 'anfun1', 'anfun2', 'anfun3', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9'])
+```
+аждая функция имеет свою локальную область видимости, причем вложенные функции не видят локальные переменные внешних функций
+## 6.4 Моделирование системы
+
+Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа «зона нечувствительности», при подаче на неё синусоидального входного сигнала.
+Реальный двигатель: последовательное соединение усилителя с коэффициентом усиления k1,интегратора: y(t)=x(t)+y(t-1), и инерционного звена: y(t)=(x(t)+T*y(t-1)) / (T+1) с постоянной времени Т.
+Тахогенератор: последовательное соединение усилителя с коэффициентом усиления k2 и интегратора: y(t)=x(t)+y(t-1).
+Нелинейное звено типа «зона нечувствительности»: y=0 при -xm≤ x ≤xm, y=x-xm при x>xm, y=x+xm при x<-xm.
+Таким образом, система характеризуется параметрами: k1, T, k2, xm. Входной сигнал характеризуется параметрами: A (амплитуда синусоиды) и F (период синусоиды).
+Еще один параметр задачи : N – время (число тактов) подачи сигнала.
+
+```py
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=2,5,0.5,0.3,1,10,50
+k1=float(znach[0])
+k1
+2.0
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+import math
+vhod=[]
+for i in range(N):
+		vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import matplotlib.pyplot as plt
+plt.figure(figsize=(10, 4))
+<Figure size 1000x400 with 0 Axes>
+plt.plot(vhod, 'b-', marker='o', markersize=3, label='Входной сигнал')
+[<matplotlib.lines.Line2D object at 0x000001B544E58E10>]
+plt.grid(True)
+plt.legend()
+<matplotlib.legend.Legend object at 0x000001B544E58CD0>
+plt.show()
+```
+![График2](Figure_2.png)
+
+Создание функций реализующие компоненты системы
+
+```py
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+		#Модель реального двигателя
+		yp=kk1*xtt  #усилитель
+		yti1=yp+yti1  #Интегратор
+		ytin1=(yti1+TT*ytin1)/(TT+1)
+		return [yti1,ytin1]
+
+def tahogen(xtt,kk2,yti2):
+		#Модель тахогенератора
+		yp=kk2*xtt   #усилитель
+		yti2=yp+yti2 #интегратор
+		return yti2
+
+def nechus(xtt,gran):
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt
+```
+Реализуем соединение компонент в соответствии с заданием
+
+```py
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+		xt1=xt-yi2   #отрицательная обратная связь
+		[yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1)
+		yi2=tahogen(yin1,k2,yi2)
+		yt=nechus(yin1,Xm)
+		vyhod.append(yt)
+
+print('y=',vyhod)
+y= [0, 0, 0.3435662011497584, 0.8937007565838242, 1.2092087410156356, 0.8817313753454714, 0, -1.9132355035817665, -4.418649831257506, -6.322056754188363, -6.424186296702933, -3.708625221989286, 1.5442059920803182, 9.704061323599833, 17.99800277772674, 23.15808712030786, 21.60101426578536, 10.675050948044715, -9.28749624705183, -36.1615235441021, -62.02226858466596, -76.45563856328266, -68.45249914172874, -30.293518696411148, 37.373158630110446, 124.2547951685195, 205.6938367713173, 248.14398604455204, 216.69606070239215, 87.62148681833895, -136.666280236251, -418.37473314281556, -677.5335449808889, -804.9287317650713, -688.4371994648337, -254.1131297675378, 486.67764763779877, 1402.6733164388684, 2230.344175329904, 2612.7580871622617, 2188.8107903361088, 728.2399496559426, -1716.8860787572244, -4697.377083821688, -7340.680479213284, -8479.693381759376, -6951.99457172508, -2043.4413296742846, 6022.5141606693105, 15717.056921566687]
+```
+ # 7. Завершение сеанса работы с IDLE

TEMA7/str1.txt

@@ -0,0 +1 @@
+Hello!

TEMA7/str2.txt

@@ -0,0 +1,3 @@
+1
+2
+3

TEMA7/task.md

@@ -0,0 +1,83 @@
+# Общее контрольное задание по теме 7
+
+Похил Анастасия, А-02-23
+
+# Задание:
+
+1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+# Решение
+
+## 1.
+
+```py
+>>> def delay_signal (signal, T):
+...           """"Расчёт выхода y(t) для устройства задержки"""
+...           output=[]
+...           for i in range(len(signal)): 
+                  if i < T:
+ 	            output.append(0)
+	          else:
+	            output.append(signal[i-T]) 
+	      return output
+	        
+>>> x=[1,0.5,3.6,4.5,1,2,0.5] # Входной сигнал
+>>> y= delay_signal (x, 2)
+>>> y
+[0, 0, 1, 0.5, 3.6, 4.5, 1]
+```
+
+## 2.
+```py
+>>> import random
+>>> import matplotlib.pyplot as plt
+>>> def histogram (sample, number):
+...     min_1=min(sample)
+...     max_1=max(sample)
+...     bins=(max_1-min_1)/number # Ширина одного интервала
+...     rows = [0]*number # Создание списка для подсчёта элементов в каждом интервале
+...     intervals = [] # Список для хранения границ интервалов
+...     for i in range(number):
+...         lower = min_1 + i * bins
+...         upper = min_1 + (i+1) * bins
+...         intervals.append((lower, upper))
+... 
+...     for x in sample:
+...         i = int((x-min_1)/bins) # Вычисление номера интервала для текущего элемента
+...         if i == number:
+...          i=number-1
+...         rows [i] +=1
+...    print("Границы интервала | Число элементов")
+...    for i in range(number):
+...        lower, upper = intervals[i]
+...        print(lower, "-", upper, "  |", rows[i])
+...    plt.hist(sample, number)
+...    plt.xlabel('Значения выборки')
+...    plt.ylabel('Число элементов')
+...    plt.title('Гистограмма выборки')
+...    plt.show()
+...    return rows
+...
+>>> data = [random.gauss(1, 20) for _ in range(10)]
+>>> histogram (data, 3)
+Границы интервала | Число элементов
+-23.534334630492655 - -11.561019750784087   | 3
+-11.561019750784087 - 0.4122951289244803   | 2
+0.4122951289244803 - 12.385610008633048   | 5
+[3, 2, 5]
+```
+![График](Figure_3.png)
+
+## 3. 
+```py
+>>> linear_regression = lambda b1, b2, x: b1+b2 * x
+>>> result = linear_regression (2,3,5)
+>>> result
+17
+```
+
+

TEMA7/test.md

@@ -0,0 +1,24 @@
+# Индивидуальное задание по теме 7
+
+Похил Анастасия, А-02-23, вариант 18
+
+## Задание
+Разработайте функцию с двумя аргументами: имя некоторого объекта-последовательности и имя текстового файла вывода. Функция должна осуществлять запись указанного объекта в заданный файл вывода, причем если объект – это символьная строка, то его надо записать в файл на одной строке, если объект – список или кортеж, то каждый элемент должен записы-ваться на одной строке файла. Проверить функцию с объектами разных классов.
+
+##Решение
+```py
+os.chdir('C:\\Users\\u206-04\\Desktop\\python-labs\\TEMA7')
+def write_1(x,y):
+    file = open(y,'w')
+    if type(x) == str:
+        file.write(x)
+    else:
+        for i in x:
+            file.write(str(i)+'\n')
+    file.close()
+
+    
+write_1("Hello!", "str1.txt")
+write_1([1,2,3], "str2.txt")
+
+```

TEMA8/MM0.py

@@ -0,0 +1,2 @@
+import MM2
+print('y=',MM2.vyhod)

TEMA8/MM1.py

@@ -0,0 +1,19 @@
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+    yp=kk1*xtt
+    yti1=yp+yti1
+    ytin1=(yti1+TT*ytin1)/(TT+1)
+    return [yti1,ytin1]
+
+def tahogen(xtt,kk2,yti2):
+    yp=kk2*xtt
+    yti2=yp+yti2
+    return yti2
+
+def nechus(xtt,gran):
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt

TEMA8/MM2.py

@@ -0,0 +1,23 @@
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+	vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+	xt1=xt-yi2   
+	[yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+	yi2=mod.tahogen(yin1,k2,yi2)
+	yt=mod.nechus(yin1,Xm)
+	vyhod.append(yt)

TEMA8/report.md

@@ -0,0 +1,306 @@
+# Отчет по Теме 8
+
+Похил Анастасия, А-02-23
+
+## 1 Запуск IDLE 
+
+## 2 Создание и использование модулей в среде Python
+
+### 2.1. Запуск модуля на выполнение путем его импорта.
+
+В данном пункте используется модуль Mod1, находящийся в рабочем каталоге.
+
+```py
+perm1=input('Mod1:Введите значение = ')
+Mod1:Введите значение = 12
+print('Mod1:Значение perm1=',perm1)
+Mod1:Значение perm1= 12
+import Mod1
+Mod1:Введите значение = 12
+Mod1:Значение perm1= 12
+import Mod1
+type(Mod1)
+<class 'module'>
+dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+Mod1.perm1
+'12'
+import Mod1
+importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\Настя\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+Mod1.perm1
+'3'
+```
+
+### 2.2 Значение атрибута sys.modules
+
+```py
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Настя\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+import Mod1
+Mod1:Введите значение = 10
+Mod1:Значение perm1= 10
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Настя\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+```
+
+### 2.3. Запуск модуля на выполнение с помощью функции exec().
+
+```py
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 12
+Mod1:Значение perm1= 12
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 11
+Mod1:Значение perm1= 11
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1
+'3'
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 4
+Mod1:Значение perm1= 4
+perm1
+'4'
+```
+
+### 2.4. Использование инструкции from … import …
+
+Пример 1
+
+```py
+from Mod1 import perm1
+Mod1:Введите значение = 9
+Mod1:Значение perm1= 9
+perm1
+'9'
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'importlib', 'os', 'perm1', 'sys']
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+Как видно, в памяти объекта Mod1 нет, но в sys.modules.keys() появился. Кроме того, в рабочем пространстве появился объект perm1, импортированный из модуля, поэтому к нему можно обращаться по имени perm1.
+
+Пример 2 
+
+```py
+from Mod2 import beta
+g=beta(2)
+****BETA****
+g
+535.4916555247646
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'beta', 'g', 'importlib', 'os', 'perm1', 'sys']
+print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+alpha()
+Traceback (most recent call last):
+  File "<pyshell#30>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+from Mod2 import alpha as al
+al()
+****ALPHA****
+Значение t=2
+'2'
+del al,beta
+from Mod2 import alpha as al, beta as bt
+del al,bt
+from Mod2 import *
+tt=alpha()
+****ALPHA****
+Значение t=0.12
+uu=beta(float(tt))
+****BETA****
+uu
+1.4578913609506803
+```
+
+## 3. Создание многомодульных программ.
+
+### 3.1. Простая многомодульная программа.
+
+```py
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Настя\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Настя\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+import Mod0
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=23
+tt= 23
+****BETA****
+qq= 2.402459849485247e+31
+Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
+'23'
+2.402459849485247e+31
+'5'
+```
+
+### 3.2. Еще один пример.
+
+```py
+import MM0
+k1,T,k2,Xm,A,F,N=10,5,20,0.2,4,0.002,45
+y= [0, 0, 0, 0, 0, 0, 0, 0, 0, -1.319802644385577, 46.01934525453105, -1405.3955775891707, 42745.94702692066, -1299970.5133264635, 39533945.50140401, -1202283133.3347626, 36563128408.478745, -1111936383153.658, 33815556107824.71, -1028378828326575.4, 3.1274452834020396e+16, -9.511002882653281e+17, 2.892430326884485e+19, -8.796289202203655e+20, 2.675075800776401e+22, -8.135283385301572e+23, 2.474054594638224e+25, -7.523949501635715e+26, 2.288139325051647e+28, -6.958554904853609e+29, 2.1161948415343663e+31, -6.435647441989787e+32, 1.9571712956052526e+34, -5.952034375513921e+35, 1.810097730681449e+37, -5.504762889302416e+38, 1.6740761536689568e+40, -5.091102059507955e+41, 1.548276052049398e+43, -4.708526180245838e+44, 1.4319293229856865e+46, -4.354699342288017e+47, 1.3243255834850482e+49, -4.02746117060638e+50, 1.2248078329844667e+52]
+```
+
+### 3.3. Области дейтсвия объектов в модулях.
+
+Попробуйте вставить в функции alpha обращение к функции beta и, наоборот, из beta – к alpha.
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(t)
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+
+```py
+Mod1:Введите значение = 8
+Mod1:Значение perm1= 8
+perm1= 8
+****ALPHA****
+Значение t=6
+tt= 6
+****BETA****
+qq= 153552935.39544657
+```
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=alpha()*math.pi
+    return math.exp(expi)
+```
+
+```py
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=8
+tt= 8
+****BETA****
+qq= 82226315585.59491
+```
+
+Попробуйте отобразить на экране в модуле Mod0 значения объектов t и expi.
+Из-за того, что функция alpha() возвращает t, проблем с её отображением нет. 
+А вот expi напрямую вывести нельзя, потому что это локальная переменная функции beta() и она не возвращается данной функцией.
+Т.к. возвращаемая переменная qq содержит expi в показателе степени экспоненты, то один из путей решения - проделать обратную операцию (взять натуральный логарифм от qq)
+
+```py
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=1
+t= 1
+****BETA****
+Traceback (most recent call last):
+  File "C:/Users/Настя/Desktop/python-labs/TEMA8/Mod0_copy.py", line 9, in <module>
+    print('expi=', Mod2.expi)
+NameError: name 'Mod2' is not defined. Did you mean: 'Mod1'?
+```
+
+```py
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('t=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('expi=', math.log(qq))
+```
+
+```py
+Mod1:Введите значение = 6
+Mod1:Значение perm1= 6
+perm1= 6
+****ALPHA****
+Значение t=1
+t= 1
+****BETA****
+expi= 3.141592653589793
+```
+
+Попробуйте в модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
+Т.к. perm1 имеет строковый тип, то без приведения к целочисленному типу при умножении будет повторение введённого значения 3 раза.
+
+```py
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+print('3*perm1=', 3*Mod1.perm1)
+```
+
+```py
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+3*perm1= 333
+```
+
+```py
+#Модуль Mod0
+import Mod1, math
+print('perm1=',Mod1.perm1)
+print('3*perm1=', 3*int(Mod1.perm1))
+```
+
+```py
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+3*perm1= 9
+```
+
+Попробуйте в командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq.
+Из-за того, что perm1 и tt представлены изначально в строковом виде, то ситуация будет такой же, как и ранее. При необходимости их можно предварительно перевести в целочисленный тип
+
+```py
+import Mod0
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+perm1= 1
+****ALPHA****
+Значение t=1
+tt= 1
+****BETA****
+qq= 23.140692632779267
+Mod0.Mod1.perm1*2
+'11'
+Mod0.tt*2
+'11'
+Mod0.qq*2
+46.281385265558534
+```

TEMA8/task.md

@@ -0,0 +1,114 @@
+# Общее контрольное задание по теме 8
+
+Похил Анастасия, А-02-23
+
+## Задание
+
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+## Решение
+
+```py
+
+#okz1.py
+
+def read_numbers_from_file(filename):
+    numbers = []
+    file = open(filename, 'r')
+    lines = file.readlines()
+    file.close()
+    
+    for line in lines:
+        line = line.strip()
+        if line:
+            parts = line.split()
+            for part in parts:
+                numbers.append(float(part))
+    
+    return numbers
+
+#okz2.py
+
+def correlation_coefficient(list1, list2):
+    length1 = len(list1)
+    length2 = len(list2)
+    min_length = min(length1, length2)
+    
+    if min_length < 2:
+        return 0.0
+    
+    x = list1[:min_length]
+    y = list2[:min_length]
+    
+    sum_x = 0.0
+    sum_y = 0.0
+    for i in range(min_length):
+        sum_x += x[i]
+        sum_y += y[i]
+    
+    average_x = sum_x / min_length
+    average_y = sum_y / min_length
+    
+    top = 0.0
+    sum_sq_x = 0.0
+    sum_sq_y = 0.0
+    
+    for i in range(min_length):
+        diff_x = x[i] - average_x
+        diff_y = y[i] - average_y
+        top += diff_x * diff_y
+        sum_sq_x += diff_x * diff_x
+        sum_sq_y += diff_y * diff_y
+    
+    if sum_sq_x == 0.0 or sum_sq_y == 0.0:
+        return 0.0
+    
+    bottom = (sum_sq_x * sum_sq_y) ** 0.5
+    result = top / bottom
+    
+    return result
+
+#okz3.py
+
+import okz1
+import okz2
+
+def main():
+    print("Введите имя первого файла:")
+    file_name1 = input()
+    
+    print("Введите имя второго файла:")
+    file_name2 = input()
+
+    numbers1 = module1.read_numbers_from_file(file_name1)
+    numbers2 = module1.read_numbers_from_file(file_name2)
+    
+    correlation = module2.correlation_coefficient(numbers1, numbers2)
+    
+    correlation = round(correlation, 3)
+    
+    print("Коэффициент корреляции:", correlation)
+
+#Проверка
+
+data1.txt
+1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0
+
+data2.txt
+10.0 9.0 9.5 8.0 7.0 5.0 4.0 2.0 1.0 7.5
+
+
+Введите имя первого файла: data1.txt
+Введите имя второго файла: data2.txt
+Коэффициент корреляции: -0.76
+Process finished with exit code 0
+```
+

TEMA8/test.md

@@ -0,0 +1,26 @@
+# ИКЗ 
+
+Похил Анасстасия, А-02-23
+
+## Задание
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+## Решение
+```py
+#M1
+def write_1(x,y):
+    file = open(y,'w')
+    if type(x) == str:
+        file.write(x)
+    else:
+        for i in x:
+            file.write(str(i)+'\n')
+    file.close()
+```
+
+```py
+#M2
+from M1 import write_1
+write_1("Hello!", "str1.txt")
+write_1([1,2,3], "str2.txt")
+```

TEMA8/test_mod.md

@@ -0,0 +1,207 @@
+# Тест модуля 3
+
+Похил Анастасия, А-02-23, вариант 22
+
+## Задание
+1) Создайте модуль Мm1, содержащий две функции:
+
+- функция 1: аргументы - имя текстового файла с числовыми данными (может быть разное число значений на каждой строке) и пороговое значение КК; считываются значения из указанного файла и записываются в два новых текстовых файла, имена которых совпадают с именем входного файла с добавлением 1 и 2 - в первый файл записываются значения, превышающие заданный порог, а во второй - не превышающие его. Исходные данные в виде списка возвращаются в вызывающую программу;
+
+- функция 2: аргумент - имя текстового файла с исходными данными; считываются значения из указанного файла, формируются в виде списка и по нему  рассчитываются: среднее, медиана, наименьшее и наибольшее значения, стандартное отклонение - это возвращаемые результаты функции.
+
+2) Создайте еще один модуль Мm2, в котором должны: 
+
+- запрашиваться имя файла с исходными данными, проверяться его наличие и при отсутствии - повторение запроса;
+
+- запрос порогового значения КК;
+
+- вызов функции 1 с указанным именем;
+
+- трижды вызвать функцию 2: с именем указанного в ответе на запрос файла, а также с каждым из файлов, созданных в функции 1; отобразить результаты расчетов.
+
+3) Создайте модуль Мm0 - главную программу, которая вызывает М2, отображает исходные данные в виде графика  и записывает их в бинарный файл RES2a.bin.
+
+4) Подготовьте 2 файла с не менее, чем с 20 числовыми значениями с разным числом элементов на разных строках и проверьте с ними разработанную программу.
+
+
+## Решение
+```py
+#Mmod1
+import statistics
+
+def funkciya1(imya_faila, KK):
+    f = open(imya_faila, 'r')
+    stroki = f.readlines()
+    f.close()
+    vse_chisla = []
+
+    
+    for stroka in stroki:
+        slova = stroka.split()
+        
+        for slovo in slova:
+            if slovo:  
+                chislo = float(slovo)
+                vse_chisla.append(chislo)
+    
+    if imya_faila.endswith('.txt'):
+        osnova = imya_faila[:-4]
+    else:
+        osnova = imya_faila
+    
+    imya1 = osnova + '1.txt'
+    imya2 = osnova + '2.txt'
+    
+    f1 = open(imya1, 'w')
+    
+    f2 = open(imya2, 'w')
+
+    
+    for chislo in vse_chisla:
+        if chislo > KK:
+            f1.write(str(chislo) + '\n')
+        else:
+            f2.write(str(chislo) + '\n')
+    
+    f1.close()
+    f2.close()
+
+    return vse_chisla
+
+
+def funkciya2(imya_faila):
+    f = open(imya_faila, 'r')
+    stroki = f.readlines()
+    f.close()
+    chisla = []
+    
+    for stroka in stroki:
+        slova = stroka.split()
+        
+        for slovo in slova:
+            if slovo:  
+                chisla.append(float(slovo))
+    
+    if len(chisla) == 0:
+        return None
+    
+
+    srednee = statistics.mean(chisla)
+    mediana = statistics.median(chisla)
+    minimum = min(chisla)
+    maximum = max(chisla)
+    std = statistics.stdev(chisla)
+    
+    return [srednee, mediana, minimum, maximum, std]
+
+```
+2)
+```py
+# Модуль Мmod2
+import Mmod1
+import os
+
+while True:
+    imya = input("Введите имя файла с данными: ")
+    if os.path.exists(imya):
+        break
+    else:
+        print(f"Ошибка: файл '{imya}' не найден!")
+
+KK_str = input("пороговое значение КК: ")
+KK = float(KK_str)
+vse_chisla = Mmod1.funkciya1(imya, KK)
+
+
+print("Для исходного файла:")
+rez1 = Mmod1.funkciya2(imya)
+if rez1:
+    print(rez1[0])
+    print({rez1[1])
+    print(rez1[2])
+    print(rez1[3])
+    print(rez1[4])
+else:
+    print(" ")
+
+
+
+if imya.endswith('.txt'):
+    osnova = imya[:-4]
+else:
+    osnova = imya
+
+imya1 = osnova + '1.txt'
+
+print(f"Для файла '{imya1}':")
+if os.path.exists(imya1):
+    rez2 = Mmod1.funkciya2(imya1)
+    if rez2:
+        print(rez2[0])
+        print(rez2[1])
+        print(rez2[2])
+        print(rez2[3])
+        print(rez2[4])
+    else:
+        print("")
+
+
+imya2 = osnova + '2.txt'
+
+print(f"Для файла '{imya2}':")
+if os.path.exists(imya2):
+    rez3 = Mmod1.funkciya2(imya2)
+    if rez3:
+        print(rez3[0])
+        print(rez3[1])
+        print(rez3[2])
+        print(rez3[3])
+        print(rez3[4])
+    else:
+        print("")
+```
+3)
+````py
+#Mmod0
+import Mmod2
+import matplotlib.pyplot as plt
+
+with open("data.txt", "r") as f:
+    d = [float(x) for line in f for x in line.split()]
+
+plt.plot(d)
+plt.show()
+
+with open("RES2a.bin", "wb") as f:
+    f.write(str(len(chisla))
+    for x in chisla:
+        f.write(str(x) + '\n')
+```
+
+
+## Результат 
+
+```py
+Введите имя файла с данными: data.txt
+пороговое значение КК: 6
+Для исходного файла:
+10.5
+10.5
+1.0
+20.0
+5.916079783099616
+Для файла 'data1.txt':
+13.5
+13.5
+7.0
+20.0
+4.183300132670378
+Для файла 'data2.txt':
+3.5
+3.5
+1.0
+6.0
+1.8708286933869707
+```
+
+![график](Fig1.png)

TEMA9/Mod3.py

@@ -0,0 +1,10 @@
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)

TEMA9/SAU.py

@@ -0,0 +1,21 @@
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])

TEMA9/report.md

@@ -0,0 +1,259 @@
+Отчет по Теме 9
+
+Похил Анастасия, А-02-23
+
+## 1. Запуск IDLE 
+
+## 2. Создание классов и их наследников
+### 2.1. Создание автономного класса
+
+```py
+class Class1:               #Объявление класса
+	def zad_zn(self,znach): #Метод 1 класса1 – задание значения data
+		self.data=znach # self - ссылка на экземпляр класса
+	def otobrazh(self):     # Метод 2 класса1
+		print(self.data)#Отображение данных экземпляра класса
+
+z1=Class1()   #Создаём 1-й экземпляр класса
+z2=Class1()   #Создаём 2-й экземпляр класса
+z1.zad_zn('экз.класса 1')  #Обращение к методу класса у 1-го экз.
+z2.zad_zn(-632.453)         #Обращение к методу класса у 2-го экз.
+z1.otobrazh()      # Обращение ко второму методу класса
+экз.класса 1
+z2.otobrazh()
+-632.453
+z1.data='Новое значение атрибута у экз.1'
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+### 2.2. Создание класса-наследника
+
+```py
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2 – переопределяет метод родителя
+		print('значение=',self.data)#Отображение данных экземпляра
+
+z3=Class2()
+dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+z3.zad_zn('Совсем новое')
+z3.otobrazh()
+значение= Совсем новое
+z1.otobrazh()
+Новое значение атрибута у экз.1
+```
+При вызове z3.otobrazh() сработал метод класса Class2, а не родительского Class1.
+
+## 3. Использование классов, содержащихся в модулях
+Mod3:
+```py
+class Class1:               #Объявление класса Class1 в модуле
+	def zad_zn(self,znach): # 1 Метод класса
+		self.data=znach # self - ссылка на экземпляр класса Class1
+	def otobrazh(self):     # 2 Метод класса
+		print(self.data)#Отображение данных экземпляра
+class Class2(Class1):  #Class2 - наследник класса Class1
+	def otobrazh(self):     # Метод  класса Class2
+		print('значение=',self.data)#Отображение данных экземпляра
+def otobrazh(objekt):  #Объявление самостоятельной функции
+    print('значение объекта=',objekt)
+```
+
+Импортировали первый класс:
+```py
+from Mod3 import Class1 #Частичный импорт содержимого модуля
+z4=Class1()
+z4.otobrazh()
+Traceback (most recent call last):
+  File "<pyshell#65>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\Настя\Desktop\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)#Отображение данных экземпляра
+AttributeError: 'Class1' object has no attribute 'data'
+```
+Ошибка возникает потому, что атрибут data еще не был создан для объекта z4.
+
+```py
+from Mod3 import Class1
+z4=Class1()
+z4.data='значение данного data у экз.4'
+z4.otobrazh()
+значение данного data у экз.4
+del z4
+import Mod3  #Полный импорт содержимого модуля
+z4=Mod3.Class2()
+z4.zad_zn('Класс из модуля')
+z4.otobrazh()
+значение= Класс из модуля
+Mod3.otobrazh('Объект')
+значение объекта= Объект
+```
+
+## 4. Использование специальных методов
+Имена специальных методов предваряются одним или двумя подчерками и имеют вид: __<имя специального метода>__
+
+```py
+class Class3(Class2):  #Наследник класса Class2, а через него – и класса Class1
+    def __init__(self,znach): #Конструктор-вызывается при создании нового экземпляра класса
+        self.data=znach
+    def __add__(self,drug_zn):  #Вызывается, когда экземпляр участвует в операции «+»
+        return Class3(self.data+drug_zn)
+    def zad_dr_zn(self,povtor):  #А это - обычный метод
+	    self.data*=povtor
+```
+Метод __add__ - это один из методов, осуществляющих так называемую «перегрузку» операторов.
+
+```py
+z5=Class3('abc') #При создании экземпляра срабатывает конструктор
+z5.otobrazh()
+значение= abc
+z6=z5+'def'
+z6.otobrazh()
+значение= abcdef
+z6.zad_dr_zn(3)
+z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+## 5. Присоединение атрибутов к классу.
+
+```py
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+z7=Class3(123)
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+dir(z7)==dir(Class3)
+False
+z7.fio
+'Иванов И.И.'
+Class3.fio
+'Иванов И.И.'
+z7.fio == Class3.fio
+True
+z7.rozden='1987'
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+Атрибут rozden не появился у класса Class3. Атрибуты экземпляра (z7.rozden) создаются в словаре z7.__dict__. Атрибуты класса (Class3.fio) создаются в словаре Class3.__dict__. Эти два словаря независимы друг от друга
+
+## 6. Выявление родительских классов
+Такое выявление делается с помощью специального атрибута __bases__
+
+```py
+Class3.__bases__
+(<class '__main__.Class2'>,)
+Class2.__bases__
+(<class '__main__.Class1'>,)
+Class1.__bases__
+(<class 'object'>,)
+```
+Для получения всей цепочки наследования используйте атрибут __mro__:
+```py
+Class3.__mro__
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+## 7. Создание свойства класса
+Свойство (property) класса – это особый атрибут класса, с которым можно производить операции чтения или задания его значения, а также удаление значения этого атрибута.
+
+```py
+class Class4:
+	def __init__(sam,znach):
+		sam.__prm=znach
+	def chten(sam):
+		return sam.__prm
+	def zapis(sam,znch):
+		sam.__prm=znch
+	def stiran(sam):
+		del sam.__prm
+	svojstvo=property(chten,zapis,stiran)
+exempl=Class4(12)
+exempl.svojstvo
+12
+exempl.svojstvo=45
+print(exempl.svojstvo)
+45
+del exempl.svojstvo
+exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#107>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#101>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+exempl.svojstvo → вызывает chten(). chten() пытается вернуть sam.__prm. Python ищет _Class4__prm (после преобразования). Атрибут удален → AttributeError
+
+## 8. Пример модели системы автоматического регулирования (САР)
+Модуль SAU.py
+```py
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+    
+    def model(self):
+        def inerz(x,T,yy):
+            return (x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3] #Обр.связь с усилителем 2
+        y1=self.param[0]*y0  #Усилитель1
+        y2=inerz(y1,self.param[1],self.ypr[0]) #Инерционное звено1
+        y3=inerz(y2,self.param[2],self.ypr[1]) #Инерционное звено2
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+
+```
+Тестирование
+
+```py
+###main_SAU
+prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
+from SAU import *
+xx=[0]+[1]*20 #Входной сигнал – «ступенька»
+SAUe=SAU(prm)   # Создаём экземпляр класса
+yt=[]
+for xt in xx:   # Прохождение входного сигнала
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+
+y= 0.0
+y= 0.2173913043478261
+y= 0.4763705103969754
+y= 0.686594887811293
+y= 0.8199324616478645
+y= 0.8837201137353929
+y= 0.8994188484874774
+y= 0.8892777072047301
+y= 0.870097963179993
+y= 0.8518346102696789
+y= 0.8387499784485772
+y= 0.8314204114211459
+y= 0.8286051955249649
+y= 0.8285656555914835
+y= 0.8297915186846528
+y= 0.8312697736438287
+y= 0.8324765218921963
+y= 0.8332456979978418
+y= 0.8336163607592184
+y= 0.8337101315489143
+y= 0.833654237067147
+import pylab
+pylab.plot(yt)
+[<matplotlib.lines.Line2D object at 0x000001C7B00DFB10>]
+pylab.show()
+```
+![](Ris1.png)