выполнение икз

график
отчет
2025-12-15 12:13:20 +03:00 · 2025-12-15 10:33:39 +03:00 · 2025-12-15 10:32:13 +03:00 · 2025-12-01 12:48:06 +03:00 · 2025-12-01 12:21:24 +03:00 · 2025-12-01 11:22:09 +03:00
--- a/TEMA3/report.md
+++ b/TEMA3/report.md
@@ -1,4 +1,4 @@
-# Отчет по теме 2
+# Отчет по теме 3
 Криви Анастасия, А-02-23
@@ -107,8 +107,8 @@ spis1=list("Строка символов"); spis1  #Заданная строк
 ['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
 spis2=list((124,236,-15,908)); spis2  #Кортеж превращается в список
 [124, 236, -15, 908]
-spis3=list({"A":1,"B":2,"C":9}); spis3  #Преобразование словаря в список
+spis3=list({"A":1,"B":2,"C":9}.items()); spis3  #Преобразование словаря в список ключи и значения
-['A', 'B', 'C']
+[('A', 1), ('B', 2), ('C', 9)]
 ```
 3.3. Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>)
@@ -436,6 +436,12 @@ w<=10
 True
 v>6
 True
 v>=10
 True
 v<10
 False
 v!=10
 False
 ```
 8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in)
 Операции с множеством 
@@ -523,11 +529,20 @@ Cтрокa со всеми заглавными буквами
 stroka.upper()
 'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
 ```
-Cтрокa, собранную из элементов списка
+Cтрокa, собранная из элементов списка
 ```py
 stroka3=" ".join(spis22); stroka3
 'Микропроцессорная система управления'
 ```
 Cтрокa, собранная из элементов кортежа
 ```py
 kort=tuple('74156')
 s=" ".join(kort); s
 '7 4 1 5 6'
 type(s)
 <class 'str'>
 ```
 Kортеж с результатами поиска «с» слева
 ```py
 stroka3.partition("с")
@@ -585,22 +600,8 @@ k.replace(' -', ' - ')
 'ele - ele - ele - ele - '
-k.append('ele')
+dir(k)
-Traceback (most recent call last):
+['__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']
  File "<pyshell#56>", line 1, in <module>
    k.append('ele')
 AttributeError: 'str' object has no attribute 'append'
 k.insert(3, 'ele')
 Traceback (most recent call last):
  File "<pyshell#57>", line 1, in <module>
    k.insert(3, 'ele')
 AttributeError: 'str' object has no attribute 'insert'
 k.pop(0)
 Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    k.pop(0)
 AttributeError: 'str' object has no attribute 'pop'
 k.count('e')
 8
@@ -613,6 +614,9 @@ k.index('ele')
 d={'сонливость':10, 'усталость':1, 'апатия':2, 'мотивация':8}; d
 {'сонливость': 10, 'усталость': 1, 'апатия': 2, 'мотивация': 8}
 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.values()
 dict_values([10, 1, 2, 8])
 d.keys()
@@ -627,6 +631,10 @@ d
 m={'сонливость', 'усталость', 'апатия', 100j}
 type(m)
 <class 'set'>
 dir(m)
 ['__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']
 m.add(1028140+2947)
 m
 {'усталость', 100j, 1031087, 'апатия', 'сонливость'}
--- a/TEMA3/test.md
+++ b/TEMA3/test.md
@@ -0,0 +1,56 @@
 # Индивидуальное задание по теме 3
 Криви Анастасия, А-02-23, вариант 10
 ## Задание
 Какова роль компилятора в среде Python? Чем отличаются файлы с расширением .pyc от файлов с расширением .py?
 ## Решение
 Кампилятор предназначен для преобразования в байт код исходного кода, написанного в рсширении .ру.
 Код с расширением .ру - код, ясный для человеческого восприятия, в отличие от файла с расширением .рус(скомпилированныйбайт-код).
 ## Задание
 Напишите инструкцию, создающую список со словами из данного предложения.  Подсчитайте и отобразите на экране число слов.
 ## Решение
 ```py
 sp = ['Напишите', 'инструкцию', 'создающую', 'список', 'со', 'словами', 'из','данного', 'предложения'];sp
 ['Напишите', 'инструкцию', 'создающую', 'список', 'со', 'словами', 'из', 'данного', 'предложения']
 len(sp)
 9
 ```
 ## Задание
 Создайте кортеж с именами 10 любых студентов вашей группы. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
 ## Решение
 ```py
 kor = ('Михаил', 'Юрий', 'Алёна', 'Катерина', 'Елена','Татьяна','Ксения','Денис','Анастасия','Андрей')
 type(kor)
 <class 'tuple'>
 dir(kor)
 ['__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']
 ```
 ## Задание
 Превратите кортеж во множество. Подсчитайте число элементов множества и отобразите на экране с помощью формата по шаблону: "Во множестве ХХ студентов".
 ## Решение
 ```py
 m = set(kor); m
 {'Татьяна', 'Андрей', 'Ксения', 'Михаил', 'Алёна', 'Анастасия', 'Катерина', 'Елена', 'Денис', 'Юрий'}
 l=len(m)
 print('Во множестве', l, 'студентов')
 Во множестве 10 студентов
 ```
 ## Задание
 Напишите инструкцию, создающую строку из элементов списка из п.2. Отобразите строку на экране.
 ## Решение
 ```py
 st=' '.join(sp); type(st); st
 <class 'str'>
 'Напишите инструкцию создающую список со словами из данного предложения'
 где
 sp
 ['Напишите', 'инструкцию', 'создающую', 'список', 'со', 'словами', 'из', 'данного', 'предложения']
 ```
--- a/TEMA4/report.md
+++ b/TEMA4/report.md
@@ -0,0 +1,368 @@
 # Отчет по теме 4
 Криви Анастасия, А-02-23
 ## 1 Запуск IDLE 
 Встроенные функции – это готовые к использованию функции, реализующие различные полезные операции, необходимость в которых часто возникает при решении прикладных задач. Часть из них имеется в виде стандартных функций – то есть они не требуют дополнительных усилий (готовы к употреблению сразу после запуска среды Python и относятся к классу 'builtin_function_or_method').
 ## 2 Стандартные функции
 ```py
 import builtins
 dir(builtins)
 ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
 ```
 ## 2.1 Функция round
 Округление числа с заданной точностью. Cправка по назначению этой функции:
 ```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.
 ```
 Использование функции на примерах
 ```py
 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
 Создание последовательности целых чисел с заданным шагом или, по умолчанию, с шагом 1
 ```py
 gg=range(76,123,9)
 gg
 range(76, 123, 9) #«итерируемый объект» класса range. Чтобы увидеть получившуюся последовательность чисел, его надо преобразовать, например, в список, обычным способом
 list(gg)
 [76, 85, 94, 103, 112, 121]
 ```
 где 76 - левая граница, 123 - правая граница, а 9 - шаг
 ```py
 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]
 ```
 по умолчанию отсчет от нуля с шагом 1 жо заданного 23(не включительно!)
 ## 2.3 Функция zip
 Создание общего объекта, элементами которого являются кортежи, составленные из  элементов двух или более объектов-последовательностей 
 (zip – застежка-«молния»)
 Длина результирующего объекта равна длине самого короткого объекта из двух аргументов функции!
 ```py
 qq = ['Криви','Заленкина', 'Капитонов', 'Киреев']; type(qq)
 <class 'list'>
 ff=zip(gg,qq)
 ff
 <zip object at 0x00000151590F1740>
 tuple(ff)
 ((76, 'Криви'), (85, 'Заленкина'), (94, 'Капитонов'), (103, 'Киреев'))
 ff[1] # нельзя обратиться по индексу
    Traceback (most recent call last):
      File "<pyshell#5>", line 1, in <module>
        ff[1]
    TypeError: 'zip' object is not subscriptable
 ```
 ## 2.4 Функция eval 
 Вычисление значения выражения, корректно записанного на языке Python и представленного в виде символьной строки
 ```py
 fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
 коэффициент усиления=1
 dan
 -151.0
 type(dan)
 <class 'float'>
 ```
 ## 2.5 Функция exec
 Чтение и выполнение объекта-аргумента функции. Этот объект должен представлять собой строку символов  с совокупностью инструкций на языке Python
 ```py
 exec(input('введите инструкции:'))
 введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
 gg
 221.456
 ```
 ## 2.6 Функции abs, pow, max, min, sum, divmod, len, map
 ```py
 abs(-10) # Модуль числа
 10
 pow(2, 2) # Возведение числа в степень
 4
 max(1426, 54312, 335, 140)
 54312
 min(0, 346, 3531, 1450)
 0
 sum([1, 12, 0, 6])
 19
 divmod(10,2) # Кортеж с двумя элементами: результатами целочисленного деления и остатком
 (5, 0) 
 len([261, 25426, 23])
 3
 list(map(abs,[-12038, -231974]))
 [12038, 231974]
 ```
 ## 3 Функции из стандартного модуля math.
 Cовокупность разнообразных математических функций
 ```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.log10(1)
 0.0
 math.acos(1)
 0.0
 math.degrees(100) #из радиан в градусы
 5729.5779513082325
 math.radians(1029) #из градусов в радианы
 17.959438003021653
 math.log(0.321846)
 -1.1336821087105013
 math.sqrt(90)
 9.486832980505138
 math.ceil(10.1) #округление вверх
 11
 math.floor(10.9) #округление вниз
 10
 ```
 Вычисление значения функции:
 ![I](ris/f1.png)
 ```py
 math.sin((2*math.pi)/7 + math.exp(0.23))
 0.8334902641414562
 ```
 ## 4 Функции из модуля cmath
 Cовокупность функций для работы с комплексными числами.
 ```py
 import cmath
 dir(cmath)
 ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
 cmath.sqrt(1.2-0.5j) #извление квадратного корня из комплексного числа
 (1.118033988749895-0.22360679774997896j)
 cmath.phase(1-0.5j) #расчет фазы
 -0.4636476090008061
 ```
 ## 5 Стандартный модуль random
 Cовокупность функций для выполнения операций с псевдослу-чайными числами и выборками
 ```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.07336031762583761
 random.uniform(1,2) #равномерно распределенное случайное число
 1.137488979303296
 random.randint(1,10) #случайное целое число
 9
 random.gauss() #нормально распределенное случайное число
 0.014238556699878042
 help(random.choice)
 Help on method choice in module random:
 choice(seq) method of random.Random instance
    Choose a random element from a non-empty sequence.
 random.choice([10,104,2,23]) #случайный выбор элемента из совокупности
 10
 s = ['12','212','kjd','134nh']
 random.shuffle(s) #перемешивание элементов списка
 s
 ['kjd', '212', '12', '134nh'] 
 random.sample(s,2) #получение выборки заданной размерности из совокупности
 ['134nh', '12']
 random.betavariate(1, 232) #cлучайное число с бета-распределением
 0.003122288899067793
 random.gammavariate(1, 21)  #cлучайное число с гамма-распределением
 30.78691787356758
 ```
 Создание списка с 4 случайными значениями, подчиняющимися равномерному, нормальному, бета и гамма - рапределениям соответственно
 ```py
 s=[random.random(), random.gauss(), random.betavariate(1,10), random.gammavariate(1,10)]; s
 [0.10166127692065208, -0.9624978096753845, 0.00956693409670233, 3.1161536544662676]
 ```
 ## 6 Функции из модуля time
 Работа с календарем и со временем
 ```py
 c1=time.time() #время в секундах, прошедшее с начала эпохи, за которое обычно принимается 1.01.1970г
 c1
 1760880089.5032163
 c2=time.time()-c1 #временной интервал в секундах, со времени ввода предыдущей инструкции
 c2
 15.655876636505127
 ```
 с помощью этой функции можно измерять временные промежутки в секундах
 Функция, возвращающая объект класса struct_time, содержащий полную информацию о текущем времени: год (tm_year), месяц (tm_mon), день (tm_mday).
 ```py
 dat=time.gmtime()
 dat
 time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=14, tm_min=9, tm_sec=24, tm_wday=6, tm_yday=292, tm_isdst=0) #Эта функция возвращает, так называемое, «Всемирное координированное время» (UTC). Москов-ское время MSK опережает UTC на 3 часа
 dat.tm_mon
 10
 dat.tm_hour
 14
 dat.tm_year
 2025
 dat=time.localtime(); dat  #получение «местного» времени
 time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=17, tm_min=13, tm_sec=35, tm_wday=6, tm_yday=292, tm_isdst=0)
 l=time.localtime()
 time.asctime(l)
 'Sun Oct 19 17:20:49 2025' #преобразование представления времени из кортежа в строку
 time.ctime() #преобразование времени в секундах, прошедшего с начала эпохи, в строку
 'Sun Oct 19 17:15:49 2025'
 t=time.asctime();type(t)
 <class 'str'>
 t1=time.ctime(); type(t1)
 <class 'str'>
 time.sleep(3) #прерывание работы программы на заданное время
 time.mktime(l) #из кортежа в секунды с начала эпохи
 1760883649.0
 time.localtime(c1) #обратное преобразование из секунд в местное время осуществляется той же функцией
 time.struct_time(tm_year=2025, tm_mon=10, tm_mday=19, tm_hour=16, tm_min=21, tm_sec=29, tm_wday=6, tm_yday=292, tm_isdst=0)
 ```
 ## 7 Графические функции
 В развернутой версии Python должны быть установлены модули пакета matplotlib, в состав которого входит модуль pylab, содержащий ряд полезных вычислительных функций и графических возможностей.
 Импорт модуля инструкции
 ```py
 import matplotlib
 import pylab
 x=list(range(-3,55,4))
 t=list(range(15))
 pylab.plot(t,x)
 [<matplotlib.lines.Line2D object at 0x000001BC059DA5D0>]
 pylab.title('Первый график')
 Text(0.5, 1.0, 'Первый график')
 pylab.xlabel('время')
 Text(0.5, 0, 'время')
 pylab.ylabel('сигнал')
 Text(0, 0.5, 'сигнал')
 pylab.show()
 ```
 ![2](ris/ris1.png)
 ```py
 X1=[12,6,8,10,7]; X2=[5,7,9,11,13]
 pylab.plot(X1)
 [<matplotlib.lines.Line2D object at 0x000001BC05A8D590>]
 pylab.plot(X2)
 [<matplotlib.lines.Line2D object at 0x000001BC05A8D6D0>]
 pylab.show()
 ```
 ![3](ris/ris2.png)
 ```py
 # Круговая диаграмма:
 region=['Центр','Урал','Сибирь','Юг']
 naselen=[65,12,23,17]
 pylab.pie(naselen,labels=region)
 ([<matplotlib.patches.Wedge object at 0x00000158DBCC8820>, <matplotlib.patches.Wedge object at 0x00000158DBCC8760>, <matplotlib.patches.Wedge object at 0x00000158DBCC8FD0>, <matplotlib.patches.Wedge object at 0x00000158DBCDE490>], [Text(-0.1910130855889933, 1.083288512416601, 'Центр'), Text(-0.8613283319035216, -0.6841882085072037, 'Урал'), Text(0.04429273729355889, -1.0991078898011077, 'Сибирь'), Text(0.9873752043868569, -0.4848610169543564, 'Юг')])
 pylab.show()
 ```
 ![4](ris/ris3.png)
 ```py
 c1 = [10,1,1000,843,2837, 34,34,65]; c2 = [10,51046,54,46,1, 1535, 7, 12435]
 plt.bar(c1, c2)
 <BarContainer object of 8 artists>
 pylab.show()
 ```
 ![5](ris/ris4.png)
 ```py
 x1 = ['f', 'c', 'y']
 x2 = [12, 4, 24]
 plt.bar(x1, x2)
 <BarContainer object of 3 artists>
 pylab.show()
 ```
 ![6](ris/ris5.png)
 ## 8. Статистический модуль statistics
 ```py
 dir(s)
 ['Counter', 'Decimal', 'Fraction', 'NormalDist', 'StatisticsError', '__all__',
 '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__',
 '__package__', '__spec__', '_coerce', '_convert', '_exact_ratio', '_fail_neg',
 '_find_lteq', '_find_rteq', '_isfinite', '_normal_dist_inv_cdf', '_ss', '_sum',
 'bisect_left', 'bisect_right', 'erf', 'exp', 'fabs', 'fmean', 'fsum', 'geometric_mean',
 'groupby', 'harmonic_mean', 'hypot', 'itemgetter', 'log', 'math', 'mean', 'median',
 'median_grouped', 'median_high', 'median_low', 'mode', 'multimode', 'numbers', 'pstdev',
 'pvariance', 'quantiles', 'random', 'sqrt', 'stdev', 'tau', 'variance']
 data = [10, 20, 30, 40, 50]
 s.mean(data)
 30
 s.median(data)
 30
 s.stdev(data)
 15.811388300841896
 s.variance(data)
 250
 data = [10, 56, 73, 7, 20, 30, 40, 50, 56, 77, 3]
 s.quantiles(data)
 [10.0, 40.0, 56.0]
 ```
 ## 9. Завершили сеанс работы
--- a/TEMA4/ris/f1.png
+++ b/TEMA4/ris/f1.png
--- a/TEMA4/ris/ris1.png
+++ b/TEMA4/ris/ris1.png
--- a/TEMA4/ris/ris2.png
+++ b/TEMA4/ris/ris2.png
--- a/TEMA4/ris/ris3.png
+++ b/TEMA4/ris/ris3.png
--- a/TEMA4/ris/ris4.png
+++ b/TEMA4/ris/ris4.png
--- a/TEMA4/ris/ris5.png
+++ b/TEMA4/ris/ris5.png
--- a/TEMA4/task.md
+++ b/TEMA4/task.md
@@ -0,0 +1,53 @@
 # Общее контрольное задание по теме 4
 Криви Анастасия А-02-23
 ## Задание
 Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
 1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
 2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
 3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
 4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
 5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
 6. Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
 ## Решение
 1. Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления
 ```py
 import cmath
 divmod(round(cmath.phase(0.2+0.8j),2)*20,3)
 (8.0, 2.6000000000000014)
 ```
 2. Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
 ```py
 t = time.gmtime(time.time() + 3 * 60*60);t
 time.struct_time(tm_year=2025, tm_mon=10, tm_mday=20, tm_hour=10, tm_min=29, tm_sec=40, tm_wday=0, tm_yday=293, tm_isdst=0)
 st = t.tm_hour, t.tm_min; st = str(c.tm_hour)+"час"+str(c.tm_min)+"минут "
 st
 '11час16минут '
 ```
 3. Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели.
 ```
 D = ['ПН', 'ВТ', 'СР','ЧТ', 'ПТ', 'СБ', 'ВС']
 random.sample(D,3)
 ['СБ', 'ПТ', 'ЧТ']
 ```
 4. Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
 ```py
 random.choice(range(14, 33, 3))
 20
 ```
 5. Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
 ```py
 N = math.floor(random.gauss(15, 4)); N
 15
 l=random.sample(string.ascii_letters, N); l
 ['P', 'H', 'X', 'B', 's', 'T', 'z', 'N', 'E', 'l', 'I', 'w', 'o', 'u', 'C']
 ```
 6.Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
 ```py
 t = round(time.time() - time.mktime(localTime))
 t // 60
 6 minutes
 ```
--- a/TEMA4/test.md
+++ b/TEMA4/test.md
@@ -0,0 +1,27 @@
 # Индивидуальное контрольное задание по теме 4
 Криви Анастасия А-02-23
 ## Задание
 Создайте список1 с 5 элементами – целыми случайными числами из интервала от 10 до 50. На основе этого списка создайте список2 с 3 случайно отобранными из первого списка элементами. Рассчитайте среднее значение элементов списка2
 ## Решение
 Создание списка1 с пятью элементами, целыми случайными числами из интервала(10;50)
 ```py
 import random
 spis1=[random.randint(10,50), random.randint(10,50),random.randint(10,50),random.randint(10,50),random.randint(10,50)]; spis1
 [45, 38, 35, 26, 49]
 ```
 Создание списка2 с тремя элементами, случайными элементами из списка1
 ```py
 spis2 = random.sample(spis1,3); spis2
 [38, 45, 26]
 ```
 Вычисление среднего значения списка2, используя statistics.
 ```py
 import statistics
 statistics.mean(spis2) 
 36.333333333333336
 ```
 ## Завершение.
--- a/TEMA5/pic/F1.png
+++ b/TEMA5/pic/F1.png
--- a/TEMA5/pic/F2.png
+++ b/TEMA5/pic/F2.png
--- a/TEMA5/report.md
+++ b/TEMA5/report.md
@@ -0,0 +1,351 @@
 # Отчет по теме 5
 Криви Анастасия, А-02-23
 ## 1. Настроили рабочий каталог
 ## 2. Ветвление по условию – управляющая инструкция if
 Выполняется первое условие:
 ```py
 porog=10
 rashod1=11
 rashod2=10
 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
 0 
 ```
 Запись условных инструкций в одну строку:
 ```py
 dohod = 2 if porog >=4 else 0
 dohod
 2 
 ```
 Несколько функций подряд
 ```py
 if porog >= 5: rashod1 = 6; rashod2 = 0 
 rashod1
 6
 rashod2
 0
 ```
 ## 3. Цикл по перечислению – управляющая инструкция for
 ### 3.1 Простой цикл
 ```py
 temperatura = 2
 for i in range(3, 18, 3): # от 3 до 18 с шагом 3, значит всего будет 5 (3, 6, 9, 12, 15)
    temperatura += i
 temperatura
 47
 ```
 ### 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]
 ```
 Если длина sps меньше 10, то в конец списка добавляется его первый элемент. Если длина sps больше 10, цикл прерывается. 
 При этом k пробегается по всем даже новым элементам списка и поэтому может делать это бесконечно, так как список постоянно увеличивается. Для каждого элемента списка цикл прибаляет первый элемент в конец, и для k появляется новое значение, которое оно может принять.
 ```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 не сможет достигнуть 10, Так как у нас есть заданное количество выполнений цикла(4).
 Срез sps по сути создает новый объект, постоянный в отличии от изменяемого в цикле объекта списка. k проходится только по 4 элементам, так как срез не изменяется.  
 ### 3.3 Список с помощью цикла
 ```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: #здесь else относится не к if, а к for
 	print(ss)
 374
 sps5
 [51, 28, 29, 41, 51, 29, 60, 44, 29, 12]
 ```
 Программа работает исправно. ss не превысело значение равное 500, поэтому цикл завершился после 10 значения i.
 ```py
 for i in range(10):
 	sps5.append(rn.randint(1,100))
 	ss=sum(sps5)
 	if ss>500: break
 else:
 	print(ss)
 ss
 519
 sps5
 [51, 28, 29, 41, 51, 29, 60, 44, 29, 12, 76, 69]
 ```
 ss превысело значение равное 500, поэтому вывода суммы не произошло
 ### 3.4 Пример с символьной строкой
 Прибаляется пробел и один элемент из строки (ss проходит по каждому элементу stroka)
 ```py
 stroka = 'Это автоматизированная система'
 stroka1 = '' # Сначала пустая
 for ss in stroka:
    stroka1 += ' ' + ss 
 stroka1
 ' Э т о   а в т о м а т и з и р о в а н н а я   с и с т е м а'
 ```
 ### 3.5 Запись цикла в строке
 Создание списка с синусоидальным сигналом
 ```py
 import math
 sps2 = [math.sin(i*math.pi/5 + 2) for i in range(100)]
 sps2
 [0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
 ```
 Создадим график:
 ```py
 import pylab
 pylab.plot(sps2)
 [<matplotlib.lines.Line2D object at 0x000001A7E1879090>]
 pylab.title('Синусоидальный сигнал')
 pylab.show()
 ```
 ![График](pic/F1.png)
 ## 4. Цикл «пока истинно условие» – управляющая инструкция while
 ### 4.1 Цикл со счетчиком.
 ```py
 rashod = 300
 while rashod:
    print('Расход = ', rashod)
    rashod -= 50
 Расход =  300
 Расход =  250
 Расход =  200
 Расход =  150
 Расход =  100
 Расход =  50
 ```
 Цикл работал пока rashod == True, соответсвенно выход из цикла произошел по значению rashod == False.
 ### 4.2 Пример с символьной строкой
 ```py
 import math
 stroka = 'Расчет процесса в объекте регулирования'
 i=0
 sps2=[]
 while i < len(stroka):
 	r = 1 - 2/(1 + math.exp(0.1*i))
 	sps2.append(r) # Список дополняется в конце вычисленным значением
 	print('Значение в момент', i, "=", r)
 	i += 1 # Прибавляется один до тех пор, пока i не превышает длину строки. Тогда выходим из цикла по значению False
 Значение в момент 0 = 0.0
 Значение в момент 1 = 0.049958374957880025
 Значение в момент 2 = 0.09966799462495568
 Значение в момент 3 = 0.14888503362331795
 Значение в момент 4 = 0.197375320224904
 ...
 Значение в момент 38 = 0.9562374581277391
 ```
 График
 ```py
 pylab.plot(sps2)
 [<matplotlib.lines.Line2D object at 0x00000276105D8A50>]
 pylab.title('График выходного сигнала')
 pylab.show()
 ```
 ![График выходного сигнала](pic/F2.png)
 ### 4.3 Определение, является ли число простым
 ```py
 chislo = 267
 kandidat = chislo // 2 # Для значений chislo > 1. Oкруг. в меньшую сторону
 while kandidat > 1:
    if chislo%kandidat == 0: # Остаток от деления
        print(chislo, 'имеет множитель', kandidat)
        break	# else выполняться не будет
    kandidat -= 1
 else:	# При завершении цикла без break
    print(chislo, 'является простым!')
 ```
 267 имеет множитель 89
 С помощью цикла проверяем все числа от kandidat до 1. Иначе простое число.
 ```py
 chislo = 7
 kandidat = chislo // 2
 while kandidat > 1:
    if chislo%kandidat == 0:
        print(chislo, 'имеет множитель', kandidat)
        break
    kandidat -= 1
 else:
    print(chislo, 'является простым!')
 7 является простым!
 ```
 Выявление всех простых чисел от 250 до 300:
 ```py
 for i in range(250, 301):
    chislo = i
    kandidat = chislo // 2
    while kandidat > 1:
        if chislo%kandidat == 0:
            print(chislo, 'имеет множитель', kandidat)
            break
        kandidat -= 1
    else:
        print(chislo, 'является простым!')
 ```
 Вывод:
 ```py
 250 имеет множитель 125
 251 является простым!
 252 имеет множитель 126
 253 имеет множитель 23
 254 имеет множитель 127
 255 имеет множитель 85
 256 имеет множитель 128
 257 является простым!
 258 имеет множитель 129
 259 имеет множитель 37
 260 имеет множитель 130
 261 имеет множитель 87
 262 имеет множитель 131
 263 является простым!
 264 имеет множитель 132
 265 имеет множитель 53
 266 имеет множитель 133
 267 имеет множитель 89
 268 имеет множитель 134
 269 является простым!
 270 имеет множитель 135
 271 является простым!
 272 имеет множитель 136
 273 имеет множитель 91
 274 имеет множитель 137
 275 имеет множитель 55
 276 имеет множитель 138
 277 является простым!
 278 имеет множитель 139
 279 имеет множитель 93
 280 имеет множитель 140
 281 является простым!
 282 имеет множитель 141
 283 является простым!
 284 имеет множитель 142
 285 имеет множитель 95
 286 имеет множитель 143
 287 имеет множитель 41
 288 имеет множитель 144
 289 имеет множитель 17
 290 имеет множитель 145
 291 имеет множитель 97
 292 имеет множитель 146
 293 является простым!
 294 имеет множитель 147
 295 имеет множитель 59
 296 имеет множитель 148
 297 имеет множитель 99
 298 имеет множитель 149
 299 имеет множитель 23
 300 имеет множитель 150
 ```
 ### 4.4  Инструкция continue
 Эта инструкция не вызывает завершение цикла, но завершает его текущий виток и обеспечивает переход к следующему витку.
 ```py
 l=0
 for i in range(1, 10):
    if i == 5:
        continue # Пропускаем значение i равное 4, переходим к следующему
    else: l +=i
    print(l)
 1
 3
 6
 10
 16
 23
 31
 40
 ```
 ## 5. Завершение работы.
--- a/TEMA5/task.md
+++ b/TEMA5/task.md
@@ -0,0 +1,74 @@
 # Общее контрольное задание по теме 5
 Для заданной символьной строки с англоязычным текстом определите порядковый номер каждой буквы в английском алфавите.
 ## Решение
 ```py
 alphabet = 'abcdefghijklmnopqrstxvwxyz'
 stroka = 'That is all'
 for i in range(len(stroka)):
    str1 = stroka.lower()
    letters = str1[i]
    if not letters in alphabet:
        continue
    else:
        print('Буква ', letters, 'соответствует ', alphabet.index(letters) + 1, 'номеру в алфавите')
 Буква  t соответствует  20 номеру в алфавите
 Буква  h соответствует  8 номеру в алфавите
 Буква  a соответствует  1 номеру в алфавите
 Буква  t соответствует  20 номеру в алфавите
 Буква  i соответствует  9 номеру в алфавите
 Буква  s соответствует  19 номеру в алфавите
 Буква  a соответствует  1 номеру в алфавите
 Буква  l соответствует  12 номеру в алфавите
 Буква  l соответствует  12 номеру в алфавите
 ```
 Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
 ## Решение
 ```py
 stroka = 'Создайте список со словами из задания данного пункта Для этого списка  определите есть ли в нем некоторое заданное значение и выведите соответствующее сообщение либо о нахождении элемента либо о его отсутствии в списке'
 spis = stroka.split()
 spis
 ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке']
 znach = 'в'
 for slovo in spis:
    if slovo == znach:
        print('Найдено!')
        break
 else: print('Не найдено!')
 Найдено!
 znach = 'пригород'
 for slovo in spis:
    if slovo == znach:
        print('Найдено!')
        break
 else: print('Не найдено!')
 Заданное слово не найдено!
 ```
 ## Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
 ## Решение
 ```py
 name = ['Криви', 'Шинкаренко', 'Зеленкина',  'Кузьменко']
 balll = [4.45, 4.9, 4.6, 4.8]
 name1 = ['Криви', 'Кузьменко', 'Шинкаренко', 'Зеленкина']
 ballz = [4.1, 4.6, 4.9, 4.0]
 stud = input('Укажите фамилию студента: ')
 Укажите фамилию студента: Криви
 if stud in name and stud in name1:
    print('Средний балл на летней сессии: ', balll[name.index(stud)], '\nСредний балл на зимней сессии: ', ballz[name1.index(stud)])
 Средний балл на летней сессии:  4.45 
 Средний балл на зимней сессии:  4.1
 ```
--- a/TEMA5/test.md
+++ b/TEMA5/test.md
@@ -0,0 +1,98 @@
 # Индивидуальное контрольное задание по теме 5
 # Задание. Вариант 10
 Создайте список со 100 случайными целыми числами в интервале значений от -40 до +100. Рассчитайте сумму значений по тем числам, которые нацело делятся на 3.
 ## Решение
 Создание  списка со 100 случайными целыми числами в интервале от -40 до 100:
 ```py
 import random
 while len(spis) < 100:
    spis.append(random.randint(-40,100))
 ```
 Полученный список
 ```py
 spis
 [70, 19, 9, 46, -6, -40, 8, 91, -17, 91, -37, 10, -20, 70, 52, 0, 21, 73, 52, -38, 55, 48, 74, -32, 51, 70, 50, 16, 89, 11, 11, 79, -40, -32, 38, 13, -16, 66, 4, -36, 32, 89, 17, 16, 100, 65, 92, 70, 95, 7, 20, -7, -1, 48, 70, 43, 86, -29, 39, 76, 78, 46, 82, 5, 85, 18, 90, 98, 28, -12, 99, 90, 29, 24, 13, 17, 33, 26, -28, -12, 65, -35, 54, 59, 68, -14, 43, -20, 99, 24, 16, 71, -28, 92, -40, -6, -33, 66, -39, 39]
 ```
 Расчет суммы значений по числам кратным трём.
 ```py
 for i in range(100):
    if spis[i]%3==0:
        s+=spis[i]
 print("Итоговая сумма равна", s)
 Итоговая сумма равна 852
 ```
 Расчет суммы значений по числам кратным трём со следованием каждого кратного и проверкой работоспособности программы:
 ```py
 s=0
 for i in range(100):
    if spis[i]%3==0:
        s+=spis[i]
        print("Значение кратное 3 номер",i, "=", spis[i])
        print("Сумма равна", s)
 ```
 Вывод каждого кратного и суммы
 ```py
 Значение кратное 3 номер 2 = 9
 Сумма равна 9
 Значение кратное 3 номер 4 = -6
 Сумма равна 3
 Значение кратное 3 номер 15 = 0
 Сумма равна 3
 Значение кратное 3 номер 16 = 21
 Сумма равна 24
 Значение кратное 3 номер 21 = 48
 Сумма равна 72
 Значение кратное 3 номер 24 = 51
 Сумма равна 123
 Значение кратное 3 номер 37 = 66
 Сумма равна 189
 Значение кратное 3 номер 39 = -36
 Сумма равна 153
 Значение кратное 3 номер 53 = 48
 Сумма равна 201
 Значение кратное 3 номер 58 = 39
 Сумма равна 240
 Значение кратное 3 номер 60 = 78
 Сумма равна 318
 Значение кратное 3 номер 65 = 18
 Сумма равна 336
 Значение кратное 3 номер 66 = 90
 Сумма равна 426
 Значение кратное 3 номер 69 = -12
 Сумма равна 414
 Значение кратное 3 номер 70 = 99
 Сумма равна 513
 Значение кратное 3 номер 71 = 90
 Сумма равна 603
 Значение кратное 3 номер 73 = 24
 Сумма равна 627
 Значение кратное 3 номер 76 = 33
 Сумма равна 660
 Значение кратное 3 номер 79 = -12
 Сумма равна 648
 Значение кратное 3 номер 82 = 54
 Сумма равна 702
 Значение кратное 3 номер 88 = 99
 Сумма равна 801
 Значение кратное 3 номер 89 = 24
 Сумма равна 825
 Значение кратное 3 номер 95 = -6
 Сумма равна 819
 Значение кратное 3 номер 96 = -33
 Сумма равна 786
 Значение кратное 3 номер 97 = 66
 Сумма равна 852
 Значение кратное 3 номер 98 = -39
 Сумма равна 813
 Значение кратное 3 номер 99 = 39
 Сумма равна 852
 ```
--- a/TEMA6/report.md
+++ b/TEMA6/report.md
@@ -0,0 +1,471 @@
 # Отчет по Теме 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('Введите пароль:')
 Введите пароль:1234
 psw
 '1234'
 type(psw)
 <class 'str'>
 ```
 Пример 1. Ввод с контролем значения.
 ```py
 while True:
    znach=float(input('Задайте коэф.усиления = '))
    if znach<17.5 or znach>23.8:	#Число, которое должно находиться в интервале значений от 17.5 до 23.8
        print('Ошибка!')
    else:
        break
 Задайте коэф.усиления = 15.4
 Ошибка!
 Задайте коэф.усиления = 21.6
 ```
 Пример 2. Ввод и обработка выражения.
 ```py
 import math
 print(eval(input('введите выражение для расчета = ')))
 введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
 ```
 Вывод
 ```py
 1.34504378689765
 ```
 ## 4. Ввод-вывод при работе с файлами.
 ### 4.1 Функции для работы с путем к файлу.
 Используя функцию os.getcwd(), можно получить путь к текущему рабочему каталогу.
 При обычном эхо-выводе отображаются двойные обратные слэши, при использовании print() - одинарные.
 ```py
 import os
 os.getcwd()
 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313' #B получаемой символьной строке компоненты пути разделяются двойными обратными слэшами: «\\». Как обычно, при работе с файлами, размещенными в рабочем каталоге, путь доступа к ним можно не указывать
 ```
 ```py
 a=os.getcwd()
 print(a)
 C:\Users\Сергей\AppData\Local\Programs\Python\Python313
 os.getcwd()
 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'
 ```
 Использование функции os.chdir() для смены рабочего каталога.
 ```py
 os.chdir('C:\\Users\\Сергей\\python-labs\\TEMA6')
 os.getcwd()
 'C:\\Users\\Сергей\\python-labs\\TEMA6'
 ```
 Изучение других функций.
 Функция os.mkdir() создаёт новый каталог.
 ```py
 os.mkdir('new'); os.chdir('new'); os.getcwd()
 'C:\\Users\\Сергей\\python-labs\\TEMA6\\new'
 ```
 Функция os.listdir() возвращает список каталогов и файлов, находящихся внутри данного каталога.
 ```py
 os.listdir()
 ['.git', '.gitignore', 'README.md', 'TEMA0', 'TEMA1', 'TEMA2', 'TEMA3', 'TEMA4', 'TEMA5', 'TEMA6', 'TEMA7', 'TEMA8', 'TEMA9']
 ```
 Удаление каталога
 ```py
 os.listdir()
 ['.gitkeep', 'new']
 os.rmdir('new')
 os.listdir()
 ['.gitkeep']
 ```
 Проверка наличия каталога. Для несуществующих каталогов, ровно как и для любых файлов, которые не являются в свою очередь каталогами - возвращает False.
 ```py 
 os.path.isdir('report.md')        
 False
 os.chdir('../')    
 os.path.isdir('TEMA5')
 True
 ```
 Был получен путь до файла, имя которого передаётся в качестве аргумента в os.path.abspath(). Затем из абсолютного пути был извлечен путь до каталога, в котором находится файл, затем имя самого файла, после чего был получен кортеж с путём до каталога и именем файла, находящегося внутри него.
 ```py
 fil=os.path.abspath('report.md'); print(fil)        
 C:\Users\Сергей\Desktop\python-labs\report.md
 drkt=os.path.dirname(fil); print(d)
 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(r'C:\Users\Сергей\Desktop\python-labs')       
 True
 ```
 Проверка на наличие файла с известным расположением с помощью функции, аргументом которой должна быть символьная строка с путем и именем интересующего файла.
 ```
 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 для работы с текстовыми данными.
 В аргументе функции с именем file указывается путь и имя открываемого файла, а в аргументе с именем mode – предполагаемая цель его использования(w=write – для записи). 
 ```py
 fp=open(file=drkt+'\\zapis1.txt',mode='w') 
 ```
 Аргументы функции при указании их имен могут располагаться в любом порядке. 
 Если же имя файла располагается на месте первого аргумента, а цель использования – на втором, то имена аргументов можно не указывать, а вводить в соответствующем порядке.
 ```py
 fp=open(drkt+'\\zapis1.txt','w')        
 ```
 Путь в переменной drkt совпадает с рабочим каталогом - его можно опустить, оставив только имя открываемого файла.
 ```py       
 fp=open('zapis1.txt','w')
 dir(fp)
 ['_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']
 ```
 Файл по такой инструкции открывается только для записи в файл. Если требуются другие операции с открываемым файлом, то для второго аргумента mode могут  быть заданы следующие значения:
 w – запись с созданием нового файла или перезапись существующего файла,
 w+ - чтение и запись/перезапись файла,
 r – только чтение (это значение - по умолчанию),
 r+ - чтение и/или запись в существующий файл,
 a – запись в конец существующего файла или, если его нет, запись с созданием файла,
 a+ - то же, но с возможностью чтения из файла.
 Создаваемые и читаемые файлы могут быть бинарными или символьными. При открытии бинарного файла к указанным выше буквам в аргументе-цели надо добавить символ b. 
 ```
 fp1=open(drkt+'\\zapis2.bin',mode='wb+')
 ```
 В бинарный файл можно записать объекты любого типа. Файл символьный по умолчанию. В символьный файл можно записывать только объекты типа str. Объекты других типов надо перед записью преобразовать к этому типу. 
 ### 4.4. Закрытие файла.
 Сразу после завершения работы с файлом его следует закрыть для обеспечения сохранности его содержимого. 
 ```py
 fp.close()
 ```
 ### 4.5. Запись информации в файл с помощью метода write
 Метод write относится к объекту – файловой переменной. Cоздание списка с элементами-числами от 1 до 12 и запишите их в файл по 4 числа на строке:
 ```py
 sps=list(range(1,13))               
 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.
 Метод readline читает файл построчно, каждый вызов возвращает следующую строку. 
 Метод readlines читает все строки файла и возвращает их в виде списка.
 ```py
 fp=open('zapis3.txt')        
 sp1=fp.readline()        
 sp2=fp.readlines()       
 fp.close()      
 sp1; sp2
 '[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.
--- a/TEMA6/task.md
+++ b/TEMA6/task.md
@@ -0,0 +1,65 @@
 # Общее контрольное задание по теме 6
 Криви Анастасия, А-02-23
 ## Задание
 Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
 1. Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
 2. Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
 3. Записывается кортеж в бинарный файл.
 4. Записывается в этот же файл список и закрывается файл.
 5. Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
 6. Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
 7. Разделяется кортеж на  совокупности по 5 чисел в каждой и они записываются  в виде отдельных списков со своими именами.
 ## Выполнение
 1. Создание объекта-кортежа со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
 ```py
 import random
 t1=[]
 for i in range(125): t1.append(str(random.randint(6,56)))
 t1=tuple(t1);t1
 ('32', '20', '6', '10', '51', '52', '16', '37', '35', '8', '51', '31', '23', '47', '45', '51', '42', '56', '30', '51', '36', '33', '24', '41', '16', '33', '22', '44', '39', '27', '13', '33', '29', '8', '33', '33', '18', '34', '35', '7', '12', '14', '17', '7', '51', '31', '23', '19', '38', '50', '37', '47', '56', '56', '35', '15', '33', '11', '25', '17', '28', '7', '35', '56', '23', '12', '19', '56', '21', '45', '27', '14', '47', '34', '33', '16', '21', '48', '18', '46', '39', '31', '13', '42', '35', '24', '50', '43', '52', '34', '35', '53', '16', '23', '50', '51', '49', '17', '35', '52', '36', '29', '45', '45', '25', '25', '47', '22', '56', '50', '27', '45', '17', '51', '46', '23', '9', '28', '24', '15', '48', '35', '54', '16', '39')
 ```
 2-4. Создание списка, запись кортежа и списка в бинарный файл, чтение обоих объектов из файла
 ```py
 s1=['Криви', 'Зеленкина', 'Капитонов', 'Шинкаренко', 'Кузьменко']
 import pickle
 fp=open('fil.mnz', 'wb')
 pickle.dump(t1, fp)
 pickle.dump(s1, fp)
 fp.close()
 fp=open('fil.mnz', 'rb')
 t2=pickle.load(fp)
 s2=pickle.load(fp)
 fp.close()
 ```
 5. Проверка на совпадение объектов 
 ```py
 print('Кортежи совпадают') if t1 == t2 else print('Кортежи не совпадают')
 Кортежи совпадают
 print('Списки совпадают') if s1 == s2 else print('Списки не совпадают')
 Списки совпадают
 ```
 6. Разделение кортежа на списки по 5 чисел, представленных в строковом виде.
 ```py
 for i in range(0, len(t1), 5):
    exec('spisk' + str(i//5+1) + '=' + str(list(t1[i:i+5])))
 spisk1
 ['32', '20', '6', '10', '51']
 spisk2
 ['52', '16', '37', '35', '8']
 spisk3
 ['51', '31', '23', '47', '45']
 ```
--- a/TEMA6/test.md
+++ b/TEMA6/test.md
@@ -0,0 +1,103 @@
 # Индивидуальное контрольное задание по теме 6
 Криви Анастасия, А-02-23
 Вариант 4
 ## Задание
 1) Создайте словарь с 7 элементами, в которых ключами являются логины пользователей, а значениями - их пароли.
 2) Запросите у пользователя логин и пароль, проверьте их наличие в качестве элемента словаря. Если такой элемент найден, выдайте сообщение "Access granted", иначе - "Access denied".
 3) Запишите словарь в бинарный файл и после этого удалите словарь из памяти.
 4) Прочитайте словарь из файла. Отобразите его на экране.
 5) Запросите у пользователя логин и пароль нового пользователя и добавьте соответствующий элемент в словарь.
 ## Выполнение
 Создание словаря с семью элементами, в которых ключи - логины пользователей, а значения - их паролив соотвествии.
 ```py
 clov={'ac':'123','as':'124','az':'125', 'ax':'126', 'aw':'127', 'af':'128', 'an':'129'}
 ```
 Ввод информации от пользователя - логин и пароль.
 ```py
 log=input('Введите ваш логин: ')
 Введите ваш логин: ac
 pas=input('Введите ваш пароль: ')
 Введите ваш пароль: 123
 ```
 Проверка наличия пользователя в системе, то есть существуют ли вводимые значения в созданной нами словаре:
 ```py
 if (log in clov)and (clov[log] == pas):
    print('Access granted')
 else:
    print('Access denied')
 Access granted
 ```
 Изменение вводимых значений и повторная проверка.
 ```py
 log=input('Введите ваш логин: ')
 Введите ваш логин: ac
 pas=input('Введите ваш пароль: ')
 Введите ваш пароль: 12
 if (log in clov)and (clov[log] == pas):
    print('Access granted')
 else:
    print('Access denied')
 Access denied
 ```
 Запись словаря с данными пользователей в бинарный файл.
 ```py
 with open('clov.txt','wb')as fp:
    pickle.dump(clov, fp)
 ```
 Удаление словаря из памяти.
 ```py
 del clov
 ```
 Полученный бинарный файл с словарем
 ```py
 Ђ•R       }”(Њac”Њ123”Њas”Њ124”Њaz”Њ125”Њax”Њ126”Њaw”Њ127”Њaf”Њ128”Њan”Њ129”u.
 ```
 Чтение словаря и его отображение на экране.
 ```py
 with open('clov.txt','rb')as fp:
    nclov=pickle.load(fp); print(nclov)
 ```
 Ввод новых данных пользователя - логин и пароль. Добавление их в словарь
 ```py
 nlog=input('Введите новый логин: ')
 npas=input('Введите новый пароль: ')
 nclov[nlog] = npas;
 ```
 Полученный код с решением варианта.
 ```py
 import pickle
 import os
 clov={'ac':'123','as':'124','az':'125', 'ax':'126', 'aw':'127', 'af':'128', 'an':'129'}
 log=input('Введите ваш логин: ')
 pas=input('Введите ваш пароль: ')
 if (log in clov)and (clov[log] == pas):
    print('Access granted')
 else:
    print('Access denied')
 with open('clov.txt','wb')as fp:
    pickle.dump(clov, fp)
 del clov
 with open('clov.txt','rb')as fp:
    nclov=pickle.load(fp); print(nclov)
 nlog=input('Введите новый логин: ')
 npas=input('Введите новый пароль: ')
 nclov[nlog] = npas;
 ```
--- a/TEMA7/F1.png
+++ b/TEMA7/F1.png
--- a/TEMA7/F2.png
+++ b/TEMA7/F2.png
--- a/TEMA7/report.md
+++ b/TEMA7/report.md
@@ -0,0 +1,640 @@
 # Отчет по теме 7
 Криви Анстасия, А-02-23
 ## Создание пользовательских функций
 ## 1. Запуск интерактивной оболочки IDLE
 ## 2. Создание пользовательской функции
 **Пользовательская функция** – это совокупность инструкций, которая выполняется при обращении к функции из любого места программы. Как и при использовании других языков программирования, в виде функции оформляются инструкции, которые могут многократно потребоваться при выполнении данной программы или могут быть использованы в других программах. 
 Аргументы функции – это ссылки на объекты-источники данных, которые используются при её выполнении. 
 Возвращаемые данные – это результаты вычисления функции, передаваемые в ту часть программы, из которой была вызвана функция. Функция является объектом класса function.
 -**Создание функции** предполагает выполнение трех операций: 
 - формирование функции; 
 - ее сохранение;
 - использование. 
 В общем виде функция в языке Python представляется так:<br>
 def <Имя функции>([<Список аргументов >]):<br>
 <отступы> """<Комментарий по назначению функции>"""<br>
 <отступы> <Блок инструкций – тело функции><br>
 <отступы> return <Значение или вычисляемое выражение><br>
 - Именование функций должно производиться по тем же правилам задания 
 - совокупность латинских букв, цифр, знаков подчеркивания. 
 Имя должно начинаться с буквы или знака подчеркивания и не должно совпадать с зарезервированными идентификаторами или ключевыми словами, а также не должно содержать пробелов. Желательно использовать **мнемонические имена**, отражающие назначение функции. Функция считается оконченной, если в очередной строке нет отступов или их число меньше, чем в отступах в функции. Если при выполнении функции будет выполнена инструкция return, то выполнение функции прекращается с возвратом значения, следующего за этой инструкцией. Однако наличие этой инструкции в функции является необязательным.
 ### 2.1. Функция без аргументов.
 Функции могут быть без аргументов:
 ```py
 def uspeh():
 	"""Подтверждение успеха операции""" 	#описание работы функции
 	print('Выполнено успешно!')   
 uspeh()
 Выполнено успешно!
 type(uspeh) 	#определение класса объекта, пользовательской функции
 <class 'function'>
 ```
 Появление имени функции в пространстве имён и вызов инструкции help.
 ```py
 dir()
 ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'uspeh']
 help(uspeh)
 Help on function uspeh in module __main__:
 uspeh()
    Подтверждение успеха операции
 ```
 Исходя из вывода после функции help, ясно что комментарий в начале функции выступает в качестве описания её работы. Данная справочная информация о функции должна быть составлена так, чтобы было возможно понять как работать с функцией.
 ### 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
 ```
 Данную функцию можно применять для аргументов - символьным строками. Каждый символ имеет свой ASCII-код, и при выполнении этой функции сравниваются коды составляющих их символов, где "А" имеет код 65, "а" - 97 и тд.
 ```py
 sravnenie('A','a')
 A  меньше  a
 sravnenie('A','A')
 A  равно  A
 sravnenie('As','A')
 As  больше  A
 sravnenie('Aa','A')
 Aa  больше  A
 sravnenie('A','a')
 A  меньше  a
 sravnenie('Aa','a')
 Aa  меньше  a
 sravnenie('=','<')
 =  больше  <
 ```
 ### 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
 logistfun(w,v) 		#без присваения
 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]
 ```
 Данная функция может работать и с кортежами, но вот при работе со словарями и множествами уже получается ошибка: 
 ```py
 slozh((1, -1), (-3, 2), (1, -1), (1, 3))	#Сложение кортежей
 (1, -1, -3, 2, 1, -1, 1, 3) 
 slozh({"A" : 41, "B" : 542}, {"A" : 354, "D" : 4}, {"D" : 11, "A" : 546}, {"W" : 7, "G" : 809})		#Сложение словарей
 Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    slozh({"A" : 41, "B" : 542}, {"A" : 354, "D" : 4}, {"D" : 11, "A" : 546}, {"W" : 7, "G" : 809})
  File "<pyshell#25>", line 3, in slozh
    return a1+a2+a3+a4
 TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
 slozh({1, 2}, {3, 4}, {5, 6}, {7, 8}) # Сложение множеств
 Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    slozh({1, 2}, {3, 4}, {5, 6}, {7, 8})
  File "<pyshell#25>", line 3, in slozh
    return a1+a2+a3+a4
 TypeError: unsupported operand type(s) for +: 'set' and 'set'
 ```
 ### 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)
 yy
 0.9923955100021263
 ```
 Построение графика зависимости выходной величины от шага.
 ```py
 pylab.plot(spsy)
 [<matplotlib.lines.Line2D object at 0x000001ECA0F90CD0>]
 pylab.xlabel('шаг')
 Text(0.5, 0, 'шаг')
 pylab.ylabel('yy - выходной сигнал')
 Text(0, 0.5, 'yy - выходной сигнал')
 pylab.show()
 ```
 ![График работы устройства](F1.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__ # Использование атрибута объекта-функции
 'Модель устройства с памятью:\n    x - текущее значение вх. сигнала,\n    T - постоянная времени,\n    ypred - предыдущее значение выхода устройства'
 help(inerz)
 Help on function inerz in module __main__:
 inerz(x, T, ypred)
    Модель устройства с памятью:
    x- текущее значение вх.сигнала,
            T -постоянная времени,
            ypred - предыдущее значение выхода устройства
 ```
 ### 3.2. Ссылка на объект-функцию.
 Ссылку на объект-функцию можно присваивать переменным, а затем обращаться к ним как к самой функции:
 ```py
 fnkt = sravnenie
 v = 16
 fnkt(v, 23)
 16 меньше 23
 ```
 ### 3.3. Альтернативное определение функций.
 ```py
 typ_fun=8
 if typ_fun==1:
 	def func():
 		print('Функция 1')
 else:
 	def func():
 		print('Функция 2')
 func()
 Функция 2
 ```
 Определение функции выполняется во время выполнения кода. Так как условие if ложно, интерпретатор доходит только до блока else, и функция переопределяется именно в этой ветке. Исходное определение функции, если бы оно было в блоке if, игнорируется.
 ## 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
 ```
 ### 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
 logistfun(0.8, 0.5)
 0.34498724056380625
 ```
 ### 4.4. Аргументы функции, содержащиеся в списке или кортеже.
 Аргументы функции могут содержаться в списке или кортеже, в таком случае при их передаче в функцию необходима распаковка с помощью оператора " __*__ ".
 ```py
 b1234 = [b1, b2, b3, b4]	#Список списков из п.2.4
 qq=slozh(*b1234); qq 	#Перед ссылкой на список или кортеж надо ставить звездочку
    [1, 2, -1, -2, 0, 2, -1, -1]
 slozh(b1, b2, b3, b4)		#аналогично
    [1, 2, -1, -2, 0, 2, -1, -1]
 ```
 ### 4.5. Аргументы функции, содержащиеся в словаре.
 Имена ключей словаря с аргументами не должны совпадать с именами остальных переданных аргументов, иначе произойдет ошибка.
 ```py
 dic4 = {"a1" : 1, "a2" : 2, "a3" : 3, "a4" : 4}
 slozh(**dic4)    #Перед ссылкой на словарь надо ставить две звездочки   
 10
 ```
 ### 4.6. Смешанные ссылки.
 Данные способы передачи аргументов в функцию можно комбинировать:
 ```py
 e1=(-1,6);dd2={'a3':3,'a4':9}
 qqqq=slozh(*e1,**dd2); qqqq
 12
 ```
 ### 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
 ```
 Пример реализации аналогичной функции для произвольного количества аргументов, переданного в виде словаря:
 ```py
 def func4(a,b=7,*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж
 	"""Кортеж - сборка аргументов - должен быть последним!"""
 	smm=0
 	for elt in kort7:
 		smm+=elt
 	return a*smm+b
 func4(-1, 2, **{"a1" : 0, "a2" : 3, "a3" : 6})
 -7
 ```
 ### 4.9. Изменение значений объектов с помощью функций.
 С помощью функций можно изменять значения переменных - объектов изменяемого типа:
 ```py
 a=90    # Числовой объект – не изменяемый тип
 def func3(b):
 	b=5*b+67
 func3(a)
 a # Числовой объект является неизменяемым
 90
 sps1 = [1, 2, 3, 4]
 def func2(sps):
 	sps[1] = 99 
 func2(sps1)
 sps1 # Список - изменяемый объект
 [1, 99, 3, 4]
 kort = (1, 2, 3, 4)
 func2(kort) # Кортеж также является неизменяемым
    Traceback (most recent call last):
      File "<pyshell#55>", line 1, in <module>
        func2(kort)
      File "<pyshell#51>", line 2, in func2
        sps[1] = 99
    TypeError: 'tuple' object does not support item assignment
 ```
 ## 5. Специальные типы пользовательских функций.
 ### 5.1. Анонимные функции.
 Это лямбда-функция - это функции без имени, определяемые по следующей схеме:<br>
 __lambda [<Список аргументов >]: <Возвращаемое значение или выражение>__<br>
 Анонимная функция возвращает ссылку на объект-функцию, которую можно присвоить другому объекту.
 ```py
 anfun1 = lambda: 1.5 + math.log10(12.23)  #Анонимная функция без аргументов
 anfun1()
 2.5874264570362855
 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
 ```
 ### 5.2. Функции-генераторы.
 Это функции, использующиеся в итерационных процессах, позволяющие на каждой из итераций получать значение с помощью инструкции 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
 ```
 При каждом обращении к функции будет генерироваться только одно очередное значение.
 При работе с такими функциями часто используют метод next, активирующий очередную итерацию выполнения функции:
 ```py
 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#78>", line 1, in <module>
        print(alp.__next__())
    StopIteration
 ```
 ## 6. Локализация объектов.
 По отношению к функции все объекты подразделяются на локальные и глобальные. Локальными являются объекты, которые создаются в функциях присваиванием им некоторых значений. Они записываются в пространство имен, создаваемое в функции.  Глобальные – это те объекты, значения которых заданы вне функции. Они определены в пространствах имен вне функции.
 ### 6.1. Примеры на локализацию объектов в функциях.
 Локальный и глобальный объекты могут иметь одинаковое имя:
 ```py
 glb=10
 def func7(arg):
 	loc1=15
 	glb=8
 	return loc1*arg
 res=func7(glb); res
 150
 glb # Значение не изменилось, т.к. операции проводились над локальной переменной
 10
 ```
 При использовании локального объекта до его определения будет ошибка:
 ```py
 def func8(arg):
     loc1 = 15
     print(glb)
     glb = 8
     return loc1 * arg
 func8(glb)
    Traceback (most recent call last):
       File "<pyshell#97>", line 1, in <module>
         func8(glb)
       File "<pyshell#96>", line 3, in func8
         print(glb)
     UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
 ```
 Локализацию объекта можно переопределить с помощью дескриптора __global__:
 ```py
 glb = 11
 def func7(arg):
     loc1 = 15
     global glb
     print(glb)
     glb = 8
     return loc1 * arg 
 func7(glb)
 11
 165
 glb # Значение изменилось
 8
 ```
 ### 6.2. Выявление локализации объекта с помощью функций locals() и globals() из builtins.
 Эти функции возвращают словари, ключами в которых будут имена объектов, являющихся, соответственно, локальными или глобальными на уровне вызова этих функций. 
 ```py
 globals().keys()
 dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
 locals().keys()
 dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
 ```
 globals().keys() и locals().keys() возвращают одинаковые перечни, поскольку ссылаются на один и тот же словарь пространства имен.
 Пример просмотра локальных и глобальных объектов изнутри функциии:
 ```py
 glb=10
 def func8(arg):
 	loc1=15
 	glb=8
 	print(globals().keys())  #Перечень глобальных объектов «изнутри» функции
 	print(locals().keys())  #Перечень локальных объектов «изнутри» функции
 	return loc1*arg
 func8(glb)
 dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8'])
 dict_keys(['arg', 'loc1', 'glb'])
 150
 "glb" in globals().keys()	#проверка наличия объекта в перечне глобальных
 True
 ```
 ### 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) 	#вызов вложенной функции func9_1. glb=15*5=75
 	print('loc_func9:',locals().keys())
 	print('glob_func9:',globals().keys())
 	return arg2+arg3*glb
 kk=func9(10, 1);kk
 glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'func8', 'func9']) 	#перечень глобальных объектов
 locl_func9_1: dict_keys(['arg1', 'loc1', 'glb1'])	#перечень локальных объектов в функции func9_1
 loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'loc1', 'glb'])	#перечень локальных объектов в функции func9
 glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'slozh', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'pylab', 'fun_arg', 'zz', 'func8', 'glb', 'func9'])	#перечень глобальных объектов (не изменился)
 85
 ```
 ### 6.4. Моделирование системы
 Моделирование системы, состоящей из последовательного соединения реального двигателя, охваченного отрицательной обратной связью с тахогенератором в ней, и нелинейного звена типа "зона нечувствительности", при подаче на нее синусоидального входного сигнала.
 ```py
 znach = input("k1, T, k2, Xm, A, F, N = ").split(",")	#запрос параметров задачи
 k1, T, k2, Xm, A, F, N = 7, 4, 2, 5, 2, 0.01, 100	#ввод значений
 ```
 Распаковка введенного списка по значениям-парметрам задачи
 ```py
 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])
 ```
 Реализация входного сигнала
 ```py
 import math
 vhod=[]
 for i in range(N):
 		vhod.append(A*math.sin((2*i*math.pi)/F))
 vhod
 [0.0, 7.857546894913888e-15, 1.5715093789827776e-14, -2.038010347584904e-13, 3.143018757965555e-14, -6.428332918551267e-13, -4.076020695169808e-13, -1.081865548951763e-12, ..., -7.666359036382766e-12, -6.521633112271693e-12, -5.376907188160619e-12, -1.8784096492416397e-11, -3.0874553399384703e-12]
 ```
 Создание функций, реализующих компоненты системы
 ```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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.0750309723388316, 0, -12.800524758874488, 11.328734010636943, 37.9986846091337, -51.695128234754044, -93.73359277523646, 176.80628109766909, 206.3512386278131, -546.6832050741272, -399.06819555417735, 1598.4573240949626, 604.2307443815814, -4487.243599090263, -296.234076116122, 12162.217953139934, -2805.586281370296, -31870.75393905672, 17036.29869407474, 80623.4912164512, -69802.97975583967, -195996.03820751337, 245998.54033834403, 453751.31553486304, -796405.0354457049, -982958.5881199688, 2433666.144586724, 1918572.300755354, -7113910.846421458, -3041359.0662945407, 20031038.041300073, 2216408.8952286365, -54513798.16041583, 10262153.3054456, 143509014.33326405]
 ```
 ### 7. Завершение работы со средой.
--- a/TEMA7/task.md
+++ b/TEMA7/task.md
@@ -0,0 +1,79 @@
 # Общее контрольное задание по теме 7
 Криви Анастасия, А-02-23
 ## Задание
 1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
 2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
 3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х 
 Y=b1+b2*X
 и имеющую аргументы b1, b2 и X.
 ## Решение
 Функция, осуществляющая расчет выходного сигнала - входной с учетой задержки.
 ```py
 def func_zad(x, T):
 	"""Функция, реализующая для момента времени расчет выхода (выходного 	сигнала) для устройства задержки, где
 	x - входной сигнал, введенный списком
 	T - задержка"""
 	for i in range(len(x)):
 		x[i] += T
 	return x
 func_zad([5,19,33,40], 10)
 [15, 29, 43, 50]
 ```
 Функция, осуществляющая расчет гистограммы по выборке случайных величин с каким-то распределением.
 ```py
 def histogram(vbor, ch):
    """
    Расчет гистограммы для выборки данных
    vbor - список значений
    ch - количество интервалов
    Возвращает список количеств элементов в каждом интервале
    """
    min_v = min(vbor)
    max_v = max(vbor)
    width = (max_v - min_v) / ch
    # Инициализация счетчиков
    counts = [0] * ch
    for i in vbor:	 # подсчет элементов в каждом интервале
        if i == max_v:  	# для максимального значения
            ind = ch - 1
        else:
            ind = int((i - min_v) / width)
        counts[ind] += 1
    # Вывод таблицы
    print("Гистограмма:")
    print("Интервал       Количество")
    for i in range(ch):
        lg = min_v + i * width
        rg = min_v + (i + 1) * width
        print(f"[",lg,";",rg,"]","|",counts[i])
    	print(f"Список с числами элементов выборки в интервалах разбиения")
    return counts
 import random
 histogram([random.randint(0, 100) for _ in range(10)], 4)
 Гистограмма:
 Интервал       Количество
 [ 29.0 ; 45.75 ] | 3
 [ 45.75 ; 62.5 ] | 2
 [ 62.5 ; 79.25 ] | 1
 [ 79.25 ; 96.0 ] | 4
 Список с числами элементов выборки в интервалах разбиения
 [3, 2, 1, 4]
 regression = lambda x, b1, b2: b1 + b2 * x
 regression(3, 7, 1)
 10
 ```
--- a/TEMA7/test.md
+++ b/TEMA7/test.md
@@ -0,0 +1,77 @@
 # Индивидуальное контрольное задание по теме 7
 Криви Анастасия, А-02-23
 ## Задание
 Разработайте анонимную функцию, вычисляющую значение a*sin(x)/x, где a,x – аргументы функции. Рассчитайте эту функцию в интервале значений х:  0<x≤50 с шагом 0.5 и при некотором значении коэффициента a. Обеспечьте запись рассчитанных значений в текстовый файл по одному значению на строке. Отобразите рассчитанные значения в виде графика.
 ## Решение
 ```py
 import math
 import pylab
 fun = lambda a, x: a * math.sin(x) / x 
 ```
 Определение коэффициента а
 ```py
 a = int(input('Вести коэффициент a'))
 ```
 Вычисление занчение функции в соответствии с шагом 0,5 от 0 до 50. Использование от 1, так как 0 не включатся, и до 101, так как 50 включается.
 ```py
 xz = [i*0.5 for i in range(1,101)] 
 yz = [fun(a, x) for x in xz]
 ```
 Запись в файл
 ```py
 with open('Znach.txt', 'w', encoding='utf-8') as file:
    for y in yz:
        file.write(f'{y}\n')
 ```
 Построение графика
 ```py
 pylab.plot(xz, yz)
 pylab.title('График функции')
 pylab.xlabel('x',)
 pylab.ylabel('f(x)')
 pylab.grid(True)
 pylab.show()
 ```
 Фрагмент полученного текстового файла:
 ```py
 4.79425538604203
 4.207354924039483
 3.3249832886801816
 2.2732435670642044
 1.196944288207913
 0.23520001343311203
 -0.501118896699457
 -0.9460031191349103
 -1.086144575183441
 -0.9589242746631385
 -0.6414002959730836
 -0.23284624849910487
 0.16547691391370425
 0.4692761419419922
 0.6253333178498259
 0.6183489041396136
 0.46969830154322956
 0.2289547140231981
 -0.039553221295689105
 -0.2720105554446849
 -0.41890274284365236
 -0.4545410029775925
 -0.3806313802993167
 -0.2235720491668479
 -0.026528758940480276
 ...
 ```
 Полученыый график функции по заданному параметру коэффициента а, равным 2.
 ![График функции](F2.png)
 ## Завершение.
--- a/TEMA8/report.md
+++ b/TEMA8/report.md
@@ -0,0 +1,331 @@
 # Отчет по теме 8
 Криви Анастасия, А-02-23
 ## 1. Настроили рабочий каталог и импортировали важные модули
 ```py
 import os
 os.chdir(''C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'')
 os.getcwd()
 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'
 import os,sys,importlib
 ```
 ## 2. Создание и использование модулей в среде Python.
 ### 2.1. Запуск модуля на выполнение путем его импорта.
 Файл Mod1.py
 ```py
 perm1 = input('Mod1: Введите значение = ')
 print('Mod1: Значение perm1 = ', perm1)
 ```
 ```py
 import mod1	# Вызов файла
 Mod1: Введите значение = 5
 Mod1: Значение perm1 = 5
 Mod1.perm1	# Обращение к перменной из модуля
 '5'
 import Mod1
 import Mod1
 import importlib 	# повторный запуск модуля
 importlib.reload(Mod1)
 Mod1:Введите значение = 3
 Mod1:Значение perm1= 3
 <module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313'>
 Mod1.perm1
 '3'
 ```
 ### 2.2. Словарь импортированных модулей
 Импортированные модули заносятся в словарь - значение атрибута __sys.modules__, поэтому их можно увидеть с помощью инструкции __keys()__
 ```py
 print(sorted(sys.modules.keys()))
    ['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
 sys.modules.pop('Mod1')		# удаление из словаря
 <module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
 print(sorted(sys.modules.keys()))
    ['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', ...., 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
 ```
 Принципиальное отличие importlib.reload() от sys.modules.pop() заключается в следующем: importlib.reload() перезагружает модуль, выполняя его код заново, но не удаляет модуль из кэша. Он имеет тот же адрес в памяти и все зависимости от него остаются в силе. sys.modules.pop() убирает модуль из кэша, при повторном импорте он уже будет иметь другой адрес, а старые зависимости ссылаются на пустой объект.
 ```py
 import Mod1
 Mod1:Введите значение = 9
 Mod1:Значение perm1= 9
 Mod1.perm1
 '9'
 sys.modules.pop('Mod1')
 <module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
 ```
 ### 2.3. Запуск модуля на выполнение с помощью функции exec().
 Объект-модуль при этом не создается, а всё созданные при выполнении модуля объекты становятся объектами главной программы
 ```py
 exec(open('Mod1.py', encoding='utf-8').read())
 Mod1: Введите значение = 7
 Mod1: Значение perm1 = 7
 Mod1.perm1
 '9'
 perm1
 '7'
 exec(open('Mod1.py', encoding='utf-8').read())
 Mod1: Введите значение = 8
 Mod1: Значение perm1 = 8
 perm1
 '8'
 exec(open('Mod1.py', encoding='utf-8').read())
 Mod1: Введите значение = 10
 Mod1: Значение perm1 = 10
 perm1
 '10'
 ```
 ### 2.4. Использование инструкции from … import …
 В одном модуле может содержаться несколько программных единиц, поэтому иногда бывает целесообразней осуществлять не импорт модуля целиком, а только некоторой его части. Это можно сделать с помощью следующей конструкции: from <Имя модуля> import <Имя объектов для импорта>
 Пример 1.
 ```py
 from Mod1 import perm1
 Mod1:Введите значение = 10
 Mod1:Значение perm1= 10
 perm1
 '10' # Измененный объект доступен из глобальной области видимости. Как видно, объект mod1 всё же появился в sys.modules.keys(). Аналогично обычному import, при первом импорте команда инициализирует ввод, но при последующих ничего не делает.
 ```
 Пример 2.
 ```py
 from Mod2 import beta
 g = beta(2)
 g
 535.4916555247646
 print(sorted(sys.modules.keys()))
 ['Mod1', 'Mod2', '__future__', '__main__', ... # Объект Mod2 появился в списке всех модулей.
 alpha()
 Traceback (most recent call last):
  File "<pyshell#249>", line 1, in <module>
    alpha()
 NameError: name 'alpha' is not defined #v Так происходит потому, что на этапе преобразования программы в байт-код python связывает модуль, найденный в рабочей директории, с именем al. Модуль становится объектом в пространстве имен, создаётся ссылка на объект модуля alpha и ему присваивается имя al. Но имя alpha ему НЕ присваивается, поэтому обратиться к методам и атрибутам по имени alpha нельзя.
 from Mod2 import alpha as al
 al()
 ****ALPHA****
 Значение t=5
 '5'
 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
 # Создадим файл Mod0.py/. Удалим имена модулей из словоря
 sys.modules.pop('Mod1')
 <module 'Mod1' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
 sys.modules.pop('Mod2')
 <module 'Mod2' from 'C:\\Users\\Сергей\\AppData\\Local\\Programs\\Python\\Python313\\Mod1.py'>
 import Mod0
 Mod1:Введите значение = 8
 Mod1:Значение perm1= 8
 perm1= 8
 ****ALPHA****
 Значение t=2
 tt= 2
 ****BETA****
 qq= 535.4916555247646
 Mod0.tt; Mod0.qq; Mod0.Mod1.perm1
 '2'
 535.4916555247646
 '8'
 ```
 ### 3.2. Пример
 ```py
 # MM1.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
 # MM2.py
 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)
 # MM0.py
 import MM2
 print('y=',MM2.vyhod)
 import MM0
 k1,T,k2,Xm,A,F,N=10, 5, 1000, 5, 12, 10, 55
 y= [0, 6.755705045849462, -19547.26848683914, 32531679.702139076, -54127249249.99543, 90058634784633.7, -1.4984241414273363e+17, 2.493125631963529e+20, -4.1481415341004534e+23, 6.901809506237099e+26, -1.1483449653005795e+30, 1.9106527906044007e+33, -3.1790047386055634e+36, 5.289328954885494e+39, -8.800553347165468e+42, 1.4642639903265762e+46, -2.436288888650032e+49, 4.0535747571281913e+52, -6.744466302077864e+55, 1.1221657037377626e+59, -1.8670949045402017e+62, 3.1065317456668895e+65, -5.168746089643875e+68, 8.599923749845232e+71, -1.430882601320581e+75, 2.3807478744201644e+78, -3.9611638553191535e+81, 6.590710111421783e+84, -1.0965832608633041e+88, 1.824530024346934e+91, -3.035710947404653e+94, 5.050912198329557e+97, -8.403867982571026e+100, 1.3982622206705469e+104, -2.326473050039974e+107, 3.8708596803585995e+110, -6.440459159743297e+113, 1.071584030772168e+117, -1.7829355120880777e+120, 2.96650467810176e+123, -4.935764611527293e+126, 8.212281773981242e+129, -1.366385499376474e+133, 2.2734355496927698e+136, -3.7826142043847984e+139, 6.29363353676212e+142, -1.0471547177383632e+146, 1.7422892459128525e+149, -2.8988761307209507e+152, 4.823242088520591e+155, -8.025063229828587e+158, 1.3352354839501832e+162, -2.221607165626982e+165, 3.6963804944456478e+168, -6.1501551539433455e+171]
 ```
 ### 3.3. Области действия объектов в модулях
 ```py
 for Mod2 import alpha
 # Обращение в функции alpha к функции beta
 def alpha():
    print('****ALPHA****')
    t=input('Значение t=')
    beta(int(t))
    return t
 def beta(q):
    import math
    expi=q*math.pi
    return math.exp(expi)
 Тестирование:
 Mod1: Введите значение = 8
 Mod1: Значение perm1 = 8
 perm1 =  8
 ****ALPHA****
 Значение t=5
 tt =  5
 qq =  6635623.99934113
 # Обращение в функции beta к функции alpha 
 def alpha():
    print('****ALPHA****')
    t=input('Значение t=')
    return t
 def beta(q):
    import math
    expi = int(alpha())*math.pi
    return math.exp(expi)
 Mod1: Введите значение = 8
 Mod1: Значение perm1 = 8
 perm1 =  8
 ****ALPHA****
 Значение t=5
 tt =  5
 ****ALPHA****
 Значение t=5
 qq =  6635623.99934113
 # Ввод запускается два раза - первый от самой функции alpha, а второй - от той, которая упоминалась в beta.
 # Отобразить на экране в модуле Mod0 значения объектов t и expi
 #Модуль Mod0
 import Mod1
 print('perm1 = ', Mod1.perm1)
 from Mod2 import alpha as al
 tt = al()
 print('tt = ', tt)
 from Mod2 import beta
 qq=beta(float(tt))
 print('qq = ', qq)
 print(f't = {al.t}, expi = {beta.expi}')
 Traceback (most recent call last):
  File "D:\STUDY\POAS\Тема8\progs\mod0.py", line 10, in <module>
    print(f't = {al.t}, expi = {beta.expi}')
                 ^^^^
 AttributeError: 'function' object has no attribute 't'
 Traceback (most recent call last):
  File "D:\STUDY\POAS\Тема8\progs\mod0.py", line 10, in <module>
    print(f't = {al}, expi = {beta.expi}')
                              ^^^^^^^^^
 AttributeError: 'function' object has no attribute 'expi'
 ```
 так как переменная expi также определена в другом модуле и напрямую доступа к ней нет. Не получится вызвать эти переменные по их непосредственному имени (t и expi), упоминая объекты, атрибутами которых они являются, без изменения кода (например, объявления t в alpha как глобальную переменную, или задание его как метода. Но, так как мы знаем, что alpha возвращает t, то узнать t можем по имени al. С expi и beta так не получится:
 В модуле Mod0 увеличить в 3 раза значение объекта perm1 и отобразить его после этого на экране.
 ```py
 ## Так как perm1 имеет тип str, то умножение напрямую без преобразования будет выглядеть так:
 ...
 print('perm1 = ', mod1.perm1)
 print('Умножено:' , mod1.perm1 * 3)
 ...
 Mod1: Введите значение = 9
 Mod1: Значение perm1 = 9
 perm1 =  9
 Умножено: 999
 ...
 print('Умножено:' , int(mod1.perm1) * 3)	# Преобразование типа perm1, можно получить классическое умножение:
 ...
 Mod1: Введите значение = 9
 Mod1: Значение perm1 = 9
 perm1 =  9
 Умножено: 27
 # В командной строке (в главном модуле) увеличить в 2 раза значения объектов perm1, tt, qq
 mod0.mod1.perm1 * 2
 '99'
 mod0.tt * 2
 '77'
 mod0.qq * 2
 7106642561.694082
 # perm1 и tt, как упоминалось ранее, имеют строковый тип, так что умножение дублирует содержимое строки.
 ```
 ## 4. Завершили саеанс работы со средой
--- a/TEMA8/task.md
+++ b/TEMA8/task.md
@@ -0,0 +1,88 @@
 # Общее контрольное задание по теме 8
 Криви Анастасия, А-02-23
 ## Разработайте программу, состоящую из трех модулей
 ### Модуль 1
 Cодержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
 ```py
 Task1.py
 def reading (file):
    nums = []
    with open(file, 'r') as file:
        for line in file:
            nums.extend(map(float, line.split()))
    return nums
 ```
 ### Модуль 2 
 Cодержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
 ```py
 Task2.py
 import math
 def correlation(l1, l2):
    n = min(len(l1), len(l2))
    sum1 = sum(l1)
    sum2 = sum(l2)
    sum1sq = sum(now ** 2 for now in l1)
    sum2sq = sum(now ** 2 for now in l2)
    sum12 = sum(x * y for x, y in zip(l1, l2))
    part1 = n * sum12 - sum1 * sum2
    part2 = math.sqrt((n * sum1sq - sum1 ** 2) * (n * sum2sq - sum2 ** 2))
    try:
        corr = part1 / part2
        return corr
    except ZeroDivisionError:
        print("Ошибка деления на ноль!")
        return
 ```
 ### Модуль 3 
 3апрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1
 и считывает два списка из двух текстовых файлов. За-тем вызывает функцию расчета коэффициента корреляции с помощью функции
 из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
 ```py
 Task3.py
 from Task1 import reading
 from Task2 import correlation
 file1 = input("Введите имя первого файла: ")
 file2 = input("Введите имя второго файла: ")
 arr1 = reading(file1)
 arr2 = reading(file2)
 if arr1 is None or arr2 is None:
    print("Не удалось считать данные из файлов.")
 else:
    corr = correlation(arr1, arr2)
    if corr is not None:
        print(f"Коэффициент корреляции: {corr:.2f}")
 # Два текстовых  файла с числовыми данными:
 # 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
 import Task3
 Введите имя первого файла: data1.txt
 Введите имя второго файла: data2.txt
 Коэффициент корреляции: -0.76
 ```
--- a/TEMA8/test.md
+++ b/TEMA8/test.md
@@ -0,0 +1,57 @@
 # Индивидуальное контрольное задание по теме 8
 Криви Анастасия, А-02-23
 ## Задание
 Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
 Разработайте функцию с 3 параметрами: х, yT и T, реализующую расчет по значениям последовательности значений входного сигнала х значений выходного сигнала по формуле: y= (x+T*yТ)/(T+1). Здесь х- одно текущее значение входного сигнала, yT – значение выходного сигнала в предыдущий момент времени, Т – постоянная времени инерционного звена. Создайте список с последовательностью из 100 значений входного синусоидального сигнала с амплитудой 2, периодом 7 и фазой 0.35. Рассчитайте последовательность значений выходных сигналов, принимая Т=3 и yT равным предыдущему в последовательности вычисленных значений y (для первого значения х принять yT=0). Записать результаты в текстовый файл в виде двух столбцов: хi, yi.
 ## Решение
 ```py
 xz=int(input('Ввод значений x'))
 import math
 def func(xz, T, yT1=0):
    """Расчет выходного значения, где
 	хz - входные значения, 
 	yT1 – начальное значение yT
 	Т – постоянная времени"""
    yz = []
    yT = yT1
    for x in xz:
        y = (x + T * yT) / (T + 1)
        yz.append(y)
        yT = y
    return yz
 def generator(A, tau, phi):
    sign = []
    for i in range(100):
        t = i
        x = A*math.sin(2*math.pi*t/tau + phi)
        sign.append(x)
    return sign
 with open(Znach.txt, 'w', encoding='utf-8') as file:
      if header:
          file.write(header + '\n')
      for x, y in zip(xz, yz):
          file.write(f'{x}\t{y}\n')
 A = 2
 tau = 7
 phi = 0.35
 T=3         
 inputsign = generator(n,A,tau,phi)
 inputsign
 [0.6857956149109027, 1.8964488934073493, 1.6790374746606227, 0.19727659137173062, -1.4330375889291693, -1.9842452361268608, -1.0412757492945761, 0.6857956149109016, 1.896448893407349, 1.6790374746606234, 0.197276591371732, -1.4330375889291658, -1.984245236126861, -1.0412757492945734, 0.6857956149109011, 1.8964488934073476, 1.6790374746606236, 0.19727659137172895, -1.4330375889291704, -1.9842452361268605, -1.041275749294574, 0.685795614910904, 1.8964488934073476, 1.679037474660622, 0.19727659137172943, -1.43303758892917, -1.9842452361268597, -1.0412757492945743, 0.6857956149109036, 1.8964488934073496, 1.679037474660626, 0.19727659137172993, -1.4330375889291698, -1.9842452361268605, -1.0412757492945688, 0.685795614910903, 1.8964488934073493, 1.6790374746606225, 0.19727659137173043, -1.4330375889291695, -1.9842452361268608, -1.0412757492945752, 0.6857956149109026, 1.8964488934073493, 1.6790374746606305, 0.1972765913717309, -1.433037588929169, -1.9842452361268608, -1.0412757492945757, 0.6857956149109021, 1.8964488934073491, 1.6790374746606231, 0.19727659137171724, -1.4330375889291689, -1.9842452361268608, -1.0412757492945761, 0.6857956149109017, 1.896448893407349, 1.6790374746606234, 0.19727659137173187, -1.4330375889291584, -1.9842452361268608, -1.0412757492945766, 0.6857956149109012, 1.8964488934073487, 1.6790374746606236, 0.19727659137173237, -1.4330375889291682, -1.9842452361268592, -1.041275749294577, 0.6857956149109008, 1.8964488934073487, 1.6790374746606316, 0.19727659137176112, -1.4330375889291578, -1.9842452361268645, -1.0412757492945894, 0.6857956149109004, 1.896448893407344, 1.6790374746606243, 0.19727659137174747, -1.4330375889291476, -1.9842452361268628, -1.0412757492945777, 0.6857956149108865, 1.8964488934073482, 1.679037474660632, 0.19727659137176212, -1.4330375889291374, -1.9842452361268612, -1.0412757492945903, 0.6857956149108727, 1.8964488934073436, 1.67903747466064, 0.19727659137174847, -1.4330375889291667, -1.984245236126863, -1.0412757492946028, 0.6857956149108856, 1.896448893407348]
 outputsign = output(inputsign,T)
 outputsign
 [0.17144890372772567, 0.6026989011476316, 0.8717835445258794, 0.7031568062373422, 0.16910820744571436, -0.36923015344742943, -0.5372415524092161, -0.23148226057918672, 0.3005005279174472, 0.6451347646032413, 0.533170221295364, 0.04161826873923152, -0.4648476074772916, -0.6089546429316121, -0.28526707847098376, 0.26016191449859905, 0.6148808045391052, 0.5104797512472612, 0.024600416203153286, -0.47761099687935016, -0.6185271849831562, -0.2924464850096411, 0.25477735959460607, 0.61084238836111, 0.5074509391137649, 0.0223288071030312, -0.4793147037044415, -0.6198049651019748, -0.29340482009875524, 0.25405860827777094, 0.6103033248734847, 0.507046641498046, 0.02202558389124204, -0.4795421211132836, -0.6199755281586049, -0.2935327423912279, 0.25396266655841643, 0.610231368583968, 0.5069926742809086, 0.021985108478389026, -0.47957247767292344, -0.6199982955783363, -0.2935498179560266, 0.2539498598848174, 0.6102217635787707, 0.5069854705270107, 0.021979705662965754, -0.4795765297844909, -0.6200013346620121, -0.29355209726878356, 0.2539481504002496, 0.6102204814653429, 0.5069845089419365, 0.021978984474160135, -0.4795770706760951, -0.6200017403307154, -0.29355240152031115, 0.2539479222116039, 0.6102203103238588, 0.5069843805858271, 0.021978888207080716, -0.4795771428764046, -0.6200017944809476, -0.2935524421329854, 0.2539478917520981, 0.6102202874792295, 0.5069843634523552, 0.021978875356974348, -0.47957715251398403, -0.6200018017091322, -0.29355244755412396, 0.2539478876862442, 0.610220284429841, 0.5069843611653211, 0.02197887364170137, -0.4795771538004401, -0.6200018026739774, -0.293552448277758, 0.2539478871435175, 0.6102202840227942, 0.5069843608600325, 0.021978873412737465, -0.4795771539721626, -0.6200018028027664, -0.29355244837435324, 0.25394788707107213, 0.6102202839684621, 0.5069843608192871, 0.02197887338218102, -0.47957715399507955, -0.6200018028199572, -0.2935524483872497, 0.2539478870613986, 0.610220283961209, 0.5069843608138438, 0.02197887337809118, -0.4795771539981474, -0.6200018028222611, -0.29355244838897443, 0.2539478870601062]
 ```
--- a/TEMA9/F1.png
+++ b/TEMA9/F1.png
--- a/TEMA9/report.md
+++ b/TEMA9/report.md
@@ -0,0 +1,309 @@
 # Отчет по теме 9
 Криви Анастасия, А-02-23
 # Создание пользовательских классов и объектов
 ## 1. Настроили рабочий каталог
 ## 2. Классов и их наследников
 ### 2.1. Создание автономного класса
 ```py
 class Class1:
    def zad_zn(self, znach):
            self.data = znach # self - ссылка на экземпляр класса
    def otobrazh(self):
            print(self.data)
 ```
 Класс — это шаблон для создания объектов (экземпляров). Он определяет свойства (данные) и методы (функции), которые будут доступны у созданных объектов. У этого класса есть два метода: zad_zn (устанавливает значение свойства объекта) и otobrazh (выводит это значение на экран). Еще у него есть один атрибут - data. self — это обязательный первый параметр всех методов в классе ссылающийся на конкретный экземпляр класса и нужный для определения обращения к атрибутам и методам.
 ```py
 z1 = Class1()
 z2 = Class1()
 z1.zad_zn('экз.класса 1')
 z2.zad_zn(-632.453)
 z1.otobrazh()
 экз.класса 1
 z2.otobrazh()
 -632.453
 z1.data = 'Новое значение атрибута у экз. 1'
 z1.otobrazh()
 Новое значение атрибута у экз. 1
 # Если вывести имя экземпляра без чего-либо еще, вернется адрес в памяти z1
 <__main__.Class1 object at 0x000001D1B6566090>
 ```
 ### 2.2. Создание класса-наследника
 ```py
 class Class2(Class1):
    def otobrazh(self):
            print('значение =', self.data)
 z3 = Class2()
 z3
 <__main__.Class2 object at 0x000001D1B66F9370>
 dir(z3)
 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
 '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__',
 '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
 '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
 ```
 Объекты с нижними подчеркиваниями - встроенные атрибуты и методы, которые есть у каждого класса. Кроме этого, есть унаследованные от родительского класса методы, один из которых переопределен.
 Этот пример хорошо иллюстрирует сразу две парадигмы ООП: наследование и полиморфизм. При создании дочернего класса атрибуты и методы родительского класса переносятся дочернему. В дочернем классе
 методы могут быть переопределены. То есть метод с одинаковым именем в разных классах будет вести себя по-разному. Это - пример полиморфизма.
 ```py
 z3.zad_zn('Совсем новое')
 z3.otobrazh()
 значение = Совсем новое
 # Но при этом:
 z1.otobrazh()
 Новое значение атрибута у экз. 1
 del  z1, z2, z3
 ```
 ## 3. Использование классов, содержащихся в модулях
 ```py
 from mod3 import Class1
 z4 = Class1()
 z4.otobrazh()
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "D:\STUDY\POAS\Тема9\progs\mod3.py", line 5, in otobrazh
    print(self.data)
          ^^^^^^^^^
 AttributeError: 'Class1' object has no attribute 'data'
 ```
 Ошибка возникла потому, что otobrazh было вызвано раньше, чем метод,
 инициализирующий атрибут data. Проще говоря, мы пытаемся напечатать значение 
 несуществующего объекта.
 ```py
 del z4
 import mod3
 z4 = mod3.Class2()
 z4.zad_zn('Класс из модуля')
 z4.otobrazh()
 значение = Класс из модуля
 ```
 Здесь otobrazh - это метод класса Class2 и соответствующего ему экземпляра класса z2. Этот метод не принимает значимых параметров, кроме формального self.
 mod3.otobrazh('Объект')
 значение объекта = Объект
 Здесь otobrazh - это уже просто функция, глобально определенная в модуле mod3. Она определена вне пользовательского класса, поэтому атрибута data в ее зоне доступа нет. Так что эта функция принимает один обязательный параметр - выводимую переменную.
 ## 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
 from mod3 import Class3
 # Примечание: при импорте класса его родительские классы подгружаются автоматически
 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__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
 '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
 '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
 Class3.fio='Иванов И.И.'
 dir(Class3)
 ['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
 '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
 '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
 z7 = Class3(123)
 dir(z7)
 ['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
 '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
 '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
 ```
 В dir(z7), по сравнению с dir(Class3), указаны также атрибуты, относящиеся непосредтсвенно к экзаемпляру. dir(Class3) показывает атрибуты класса Class3. Это включает методы, свойства, и встроенные специальные методы класса, но не атрибуты конкретных объектов, созданных на основе этого класса. dir(z7) показывает атрибуты объекта z7. Это включает все атрибуты класса, а также любые другие атрибуты, добавленные динамически постфактум.
 ```py
 dir(z7)==dir(Class3)
 False
 # Добавим еще один атрибут:
 z7.rozden='1987'
 dir(z7)
 ['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
 '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
 '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
 # При этом у dir(Class3) его не будет:
 dir(Class3)
 ['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__',
 '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
 '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
 ```
 ## 6. Выявление родительских классов
 ```py
 Class3.__bases__
 (<class 'mod3.Class2'>,)
 Class2.__bases__
 (<class 'mod3.Class1'>,)
 Class1.__bases__
 (<class 'object'>,)
 # При этом:
 object.__bases__
 ()
 Полный порядок наследования (Method Resolution Order)
 Class3.__mro__
 (<class 'mod3.Class3'>, <class 'mod3.Class2'>, <class 'mod3.Class1'>, <class 'object'>)
 ZeroDivisionError.__mro__
 (<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
 IndexError.__mro__
 (<class 'IndexError'>, <class 'LookupError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
 ```
 ## 7.	Создание свойства класса.
 ```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)
 ```
 Свойства нужны для того, чтобы инкапсулировать атрибут, т.е. ограничить прямой доступ к изменению атрибута. Еще с их помощью можно проверять правильность введенных данных.
 ```py
 importlib.reload(mod3)
 <module 'mod3' from 'D:\\STUDY\\POAS\\Тема9\\progs\\mod3.py'>
 from mod3 import Class4
 exempl=Class4(12)
 exempl.svojstvo
 12
 exempl.svojstvo=45
 print(exempl.svojstvo)
 45
 del exempl.svojstvo
 exempl.svojstvo
 Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "D:\STUDY\POAS\Тема9\progs\mod3.py", line 25, in chten
    return sam.__prm
           ^^^^^^^^^
 AttributeError: 'Class4' object has no attribute '_Class4__prm'
 #Такой вывод происходит, потому что этот атрибут уже удален.
 ```
 ## Пункт 8. Рассмотрите пример представления в виде класса модели системы автоматического регулиро-вания (САР), состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
 ```py
 # SAU.pu
 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])
 ```
 Содержимое модуля-программы main_SAU.py с тестированием класса:
 ```py
 from SAU import *
 prm=[2.5,4,1.3,0.8] #Параметры модели: коэф.усиления, 2 пост.времени, обратная связь
 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])
 import pylab
 pylab.plot(yt)
 pylab.show()
 ```
 Вывод:
 ```py
 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
 ```
 ![график](F1.png)
--- a/TEMA9/task.md
+++ b/TEMA9/task.md
@@ -0,0 +1,70 @@
 # Общее контрольное задание по теме 9
 Криви Анастасия, А-02-23
 Создайте и запишите в модуль класс, содержащий следующие компоненты:
 - конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
 - метод для обеспечения операции повышения оклада сотрудника на заданное значение;
 - метод для обеспечения перевода сотрудника из одного отдела в другой;
 - метод для изменения должности сотрудника;
 - свойство, содержащее перечень (список) поощрений сотрудника.
 Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
 ```py
 class employee:
    def __init__(self, fio, otdel, dolzhnost, oklad):
        self.fio = fio
        self.otdel = otdel
        self.dolzhnost = dolzhnost
        self.oklad = oklad
        self._pooshrenia = []
    def salary_raise(self, summa):
        if summa > 0:
            self.oklad += summa
            print(f"Оклад сотрудника {self.fio} увеличен на {summa}. Новый оклад: {self.oklad}")
        else:
            print("Сумма для повышения оклада должна быть больше нуля.")
    def change_department(self, new_department):
        print(f"Сотрудник {self.fio} переведен из отдела {self.otdel} в отдел {new_department}.")
        self.otdel = new_department
    def change_position(self, new_position):
        print(f"Должность сотрудника {self.fio} изменена с {self.dolzhnost} на {new_position}.")
        self.dolzhnost = new_position
    @property
    def pooshrenia(self):
        return self._pooshrenia
    def add_encouragement(self, tekst):
        self._pooshrenia.append(tekst)
        print(f"Сотрудник {self.fio} теперь имеет поощрение: {tekst}")
 emp1 = employee("Сидорова Е.Ю.", "Кафедра Управления и информационных технологий", "Старший преподаватель", 90000)
 emp2 = employee("Бауэр В.Ю.", "Дир. ИВТИ", "Заместитель директора института", 120000)
 print(f"{emp1.fio}, {emp1.otdel}, {emp1.dolzhnost}, оклад: {emp1.oklad}")
 print(f"{emp2.fio}, {emp2.otdel}, {emp2.dolzhnost}, оклад: {emp2.oklad}")
 emp1.salary_raise(10000)
 emp2.change_department("ЭНМИ")
 emp1.change_position("Заместитель заведующего кафедрой")
 emp2.add_encouragement("За ответственность")
 emp1.add_encouragement("За преданность делу")
 print(f"Поощрения {emp1.fio}: {emp1.pooshrenia}")
 print(f"Поощрения {emp2.fio}: {emp2.pooshrenia}")
 Сидорова Е.Ю., Кафедра Управления и информационных технологий, Старший преподаватель, оклад: 90000
 Бауэр В.Ю., Дир. ИВТИ, Заместитель директора института, оклад: 120000
 Оклад сотрудника Сидорова Е.Ю. увеличен на 10000. Новый оклад: 100000
 Сотрудник Бауэр В.Ю. переведен из отдела Дир. ИВТИ в отдел Дир. ЭНМИ.
 Должность сотрудника Сидорова Е.Ю. изменена с Старший преподаватель на Заместитель заведующего кафедрой.
 Сотрудник Бауэр В.Ю. теперь имеет поощрение: За преданность делу
 Сотрудник Сидорова Е.Ю. теперь имеет поощрение: За ответственность
 Поощрения Сидорова Е.Ю.: ['За ответственность']
 Поощрения Бауэр В.Ю.: ['За преданность делу']
 ```
--- a/TEMA9/test.md
+++ b/TEMA9/test.md
@@ -0,0 +1,149 @@
 # Индивидуальное задание по модулю 3
 Криви Анастасия, А-02-23
 Вариант 7
 # Задание
 1) Создайте модуль М1, содержащий две функции: 
 - функция 1: аргументы - три целочисленных параметра: Т1, Т2 и М; функция должна рассчитать и вернуть список СС с М неповторяющимися целыми числами в интервале значений между Т1 и Т2;
 - функция 2: аргументы - список СС с неповторяющимися целыми числами и список или кортеж КК с целыми числами; функция должна создать список НН, с числом элементов, равным длине СС, и с целыми значениями из КК, близкими к соответствующим элементам в СС; так, элемент КК[i] считается близким к элементу CC[j], если для него  абсолютная разность |KK[i]-CC[j]|  - наименьшая по всем CC[j].
 2) Создайте еще один модуль М2, в котором должны выполняться операции: 
 - запрашиваются у пользователя целочисленные границы диапазона значений Т1 и Т2; проверяется T1<T2 и, если это не выполняется - запрос повторяется;
 - запрашивается у пользователя целое число М - число значений в списке СС; если М>(T2-T1), то принимается М=Т2-Т1;
 - с помощью функции 1 создается и отображается список СС;
 - создается список КК с 500 случайными целыми числами в диапазоне значений от Т1 до Т2;
 - с помощью функции 2 рассчитывается список НН; результат отображается на экране.
 3) Создайте модуль М0 - главную программу, которая вызывает М2 и записывает списки КК, СС и НН в бинарный файл Res1212.bin.
 4) Проверьте программу при двух наборах исходных данных:
 - Т1=34, Т2=78, М= 10
 - Т1=25, Т2=30, М=8.
 # Решение
 ## Пункт первый - модуль М1
 Создание первой функции: аргументы - три целочисленных параметра: Т1, Т2 и М; функция должна рассчитать и вернуть список СС с М неповторяющимися целыми числами в интервале значений между Т1 и Т2;
 ```py
 import random
 def func1(T1, T2, M):
    """
    Рассчет списка СС с M неповторяющимися целыми числами
    в интервале между T1 и T2
    """
    if T2 - T1 < M:
        M = T2 - T1
    CC = random.sample(range(T1, T2), M)
    return CC 
 ```
 Создание второй функции: аргументы - список СС с неповторяющимися целыми числами и список или кортеж КК с целыми числами; функция должна создать список НН, с числом элементов, равным длине СС, и с целыми значениями из КК, близкими к соответствующим элементам в СС; так, элемент КК[i] считается близким к элементу CC[j], если для него  абсолютная разность |KK[i]-CC[j]|  - наименьшая по всем CC[j]
 ```py
 def func2(CC, KK):
    """
    Создание списка НН (с числом элементов, равным длине СС) с целыми значениями из КК, 
    близкими к соответствующим элементам в СС
    """
    HH = []
    for i in CC:
        cl = min(KK, key= lambda x: abs(x - i))
        HH.append(cl)
    return HH
 ```
 ## Пункт второй - модуль М2
 Запрос у пользователя целочисленных границ диапазона значений Т1 и Т2; проверка условия T1<T2 и, если это не выполняется - повтор запроса.
 ```py
 def main():
    while True:
        try:
            T1 = int(input("Введите первую границу: "))
            T2 = int(input("Введите вторую границу: "))
            if T1 < T2:
                break
            else:
                print("Ошибка. Первая граница должна быть меньше второй границы.")
        except ValueError:
            print("Ошибка: введите целое число.")
 ```
 Запрос у пользователя целого числа число значений в списке СС
 ```py
    while True:
        try:
            M = int(input("Введите количество значений в списке СС: "))
            break
        except ValueError:
            print("Ошибка: введите целое число.")
 ```
 Проверка условия если М>(T2-T1), то принимается М=Т2-Т1, иначе значение М не изменяется
 ```py
    if M > (T2 - T1):
        M = T2 - T1
 ```
 С помощью функции 1, созданной в пункте первом, создается и отображается список СС. Создание списка КК с 500 случайными целыми числами в диапазоне значений от Т1 до Т2. С помощью функции 2, созданной в пункте первом, рассчитывается список НН, а результат отображается на экране.
 ```py
    CC = M1.func1(T1, T2, M)
    print("Список СС:", CC)
    KK = [random.randint(T1, T2) for _ in range(500)]
    HH = M1.func2(CC, KK)
    print("Список НН:", HH)
    return KK, CC, HH
 ```
 и завершение выполнение второго пункта, а именно создание модуля М2.
 ## Пункт третий
 Создание модуля М0 - главной программы, которая вызывает М2 и записывает списки КК, СС и НН в бинарный файл Res1212.bin.
 ```py
 import M2
 import pickle
 CC, KK, HH = M2.main()
 data_M2 = {'CC': CC,'KK': KK,'HH': HH}
 filename = "Res1212.bin"
 with open(filename, 'wb') as file:
    pickle.dump(data_M2, file)
 ```
 ## Тестирование
 Вывод с тестовыми значениями 1 (Т1=34, Т2=78, М= 10)
 ```py
 Введите первую границу: 34
 Введите вторую границу: 78
 Введите количество значений в списке СС: 10
 Список СС: [73, 54, 66, 42, 46, 48, 58, 72, 52, 75]
 Список НН: [73, 54, 66, 42, 46, 48, 58, 72, 52, 75]
 ```
 Фрагмент файла с бит(Res1212.bin)
 ```py
 Ђ•      ]”(K.K&K4KMK6K?KEK3KGK0e]”(K9KNK8K2KDK;KKK3KKKNK;K+K6KJK%K/KGKHK*K=KAKBKIK"K:K(K4KLK$K(KMK0K6K#KKKHK5K?K0K+K7K&K/KEK3K1KDK?K;KCK,K?K3K/K3K<KLKAK&K8KDK-K;KEKFKGK6K"K9K?K:K5KLK'KDK"KGKEK<K.........
 ```
 Вывод с тестовыми значениями 2 (Т1=25, Т2=30, М=8.)
 ```py
 Введите первую границу: 25
 Введите вторую границу: 30
 Введите количество значений в списке СС: 8
 Список СС: [27, 28, 29, 26, 25]
 Список НН: [27, 28, 29, 26, 25]
 ```
 Фрагмент файла с бит(Res1212.bin) при этих значениях.
 ```py
 Ђ•      ]”(KKKKKe]”(KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK.........
 ```
Автор	SHA1	Сообщение	Дата
Пользователь № 11 аудитории К-522	688b619337	выполнение икз	2025-12-15 12:13:20 +03:00
Пользователь № 11 аудитории К-522	14e1e63fdd	график	2025-12-15 10:33:39 +03:00
Пользователь № 11 аудитории К-522	8328af9495	отчет	2025-12-15 10:32:13 +03:00
Пользователь № 11 аудитории К-522	4c4c7a5faf	выполнение ИКЗ	2025-12-01 12:48:06 +03:00
Пользователь № 11 аудитории К-522	cf11a51e14	выполенние ИКЗ	2025-12-01 12:21:24 +03:00
Пользователь № 11 аудитории К-522	a180811ab2	добавление2	2025-12-01 11:22:09 +03:00
Пользователь № 11 аудитории К-522	caf821c487	добавление	2025-12-01 11:20:33 +03:00
Пользователь № 11 аудитории К-522	62f4d67d20	изменение	2025-12-01 11:12:40 +03:00
Пользователь № 11 аудитории К-522	c0daf15519	изменения	2025-12-01 10:49:59 +03:00
Пользователь № 11 аудитории К-522	34b14499ba	Изменения	2025-12-01 10:39:42 +03:00
Пользователь № 11 аудитории К-522	af46acb8cd	изменения	2025-12-01 10:33:02 +03:00
Пользователь № 11 аудитории К-522	ac6b140d31	выполнение темы7 и темы8	2025-12-01 10:23:44 +03:00
Пользователь № 11 аудитории К-522	35176277bd	выполнение ИКЗ	2025-11-17 12:36:54 +03:00
Пользователь № 11 аудитории К-522	2630d47c5b	внесение изменений	2025-11-17 10:27:10 +03:00
Пользователь № 11 аудитории К-522	a98cdcbe60	отчёт	2025-11-17 09:48:44 +03:00
Пользователь № 11 аудитории К-522	cc16eb5dec	Выполнение ИКЗ	2025-11-03 10:49:24 +03:00
Пользователь № 11 аудитории К-522	eebe2e3d94	исправление	2025-11-03 09:44:00 +03:00
Пользователь № 11 аудитории К-522	dfab28d052	отчет	2025-11-03 09:29:11 +03:00
Пользователь № 11 аудитории К-522	2d5b033dad	выполнение ИКЗ	2025-10-20 12:03:27 +03:00
Пользователь № 11 аудитории К-522	fc5d1a8988	О. изменение	2025-10-20 11:18:40 +03:00
Пользователь № 11 аудитории К-522	88490bdb79	исправления2	2025-10-20 10:50:00 +03:00
Пользователь № 11 аудитории К-522	d9d5f10bf2	исправления	2025-10-20 10:48:24 +03:00
Пользователь № 11 аудитории К-522	80b9b9d9de	Выполнение	2025-10-20 10:28:14 +03:00
Пользователь № 11 аудитории К-522	c29ce51b81	выполнение ИКЗ	2025-10-06 11:49:28 +03:00
Пользователь № 11 аудитории К-522	b98c7ae906	внесение изменений 2	2025-10-06 10:59:27 +03:00
Пользователь № 11 аудитории К-522	75ec6411a5	внесение изменений	2025-10-06 09:58:33 +03:00