Тест

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по теме 1 Лыковой Е.А
+print("Hello")
+h=input("Your name=")
+import os
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova")

TEMA1/protokol.py

@@ -0,0 +1,60 @@
+#Протокол по теме 1 Лыковой Е.А
+import os
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova\\TEMA1\\")
+
+============= RESTART: C:/Users/u207-06/Desktop/Lykova/TEMA1/Pr0.py ============
+Hello
+Your name=Lizp
+import Pr0
+Hello
+Your name=Lizp
+import prb1
+Как Вас зовут? Лизп
+Привет, Лизп
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+help(print),help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+
+============ RESTART: C:\Users\u207-06\Desktop\Lykova\TEMA1\prb1.py ============
+Как Вас зовут? Лизп
+Привет, Лизп
+import tdemo_chaos

TEMA1/report.md

@@ -0,0 +1,123 @@
+# Отчет по теме 1
+
+Лыкова Елизавета, А-01-23
+
+## 1. Создание копии репозитория 
+
+```
+$ git clone http://uit.mpei.ru/git/LykovaYA/python-labs.git
+```
+
+## 1.1 Клонирование форка на рабочий стол, перебазирование личного форка на исходный репозиторий
+
+```
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git remote add upstream http://uit.mpei.ru/git/main/python-labs.git
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git fetch upstream
+From http://uit.mpei.ru/git/main/python-labs
+ * [new branch]      main       -> upstream/main
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git stash push
+No local changes to save
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git rebase upstream/main
+Current branch main is up to date.
+
+u207-06@w10prog-02 MINGW64 ~/Desktop/python-labs (main)
+$ git stash pop
+No stash entries found.
+```
+
+## 2. Запуск Питона
+
+## 2.1 Изучение интерпретатора
+
+>>> print("Hello")
+Hello
+
+>>> h=input("Your name=")
+Your name=Lizp
+
+>>> exit()
+
+## 3. Ввод интрукций настройки рабочего каталога среды
+
+import os
+
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova\\TEMA1\\")
+
+## 4. Создание файла "Программа по теме 1", её запуск
+
+#Программа по теме 1 Лыковой Е.А
+
+print("Hello")
+
+h=input("Your name=")
+
+import os
+
+os.chdir("C:\\Users\\u207-06\\Desktop\\Lykova")
+
+
+## 5. Запуск программы prb1.py из рабочего каталога
+
+## 5.1 Попытка открыть файл Pr0.cpython-311 из каталога `pycache`.
+При попытке открыть файл в текстовом редакторе человек вместо привычных букв увидит странные символы и/или надписи NUL.
+Так происходит из-за того, что информация записана в двоичном коде. Компиляция программ происходит для преобразования текста в машинный код, оптимизации.
+
+## 6. Создание файла "Протокол по теме 1"
+
+## 6.1 Изучение раздела Help.
+В этом разделе можно найти актуальную информацию про IDLE, по типу версии, обновлений, лицензии. Так же здесь присутсвует краткий гайд для использования программы.
+В наличии так же демо-версия программы TURTLE и справочник по Python.
+
+## 6.2 
+
+help(print)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+help(print),help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+
+## 7. Перемещение между различными окнами программы благодаря Window. В TURTLE присутсвуют готовые примеры программ с доступным кодом.

TEMA1/test.md

@@ -0,0 +1,11 @@
+# Индивидуальное контрольное задание по теме 1
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Для чего предназначено предложение "Окно (Window)" главного меню?
+
+## Ответ
+
+Предложение "Окно"("Window") главного меню предназначено для возможности быстрого перемещения между окнами программы, благодаря выпадающему меню, в котором записаны все открытые на данный момпент файлы.

TEMA2/report.md

@@ -0,0 +1,484 @@
+# Отчет по теме 2
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA2\\")
+```
+
+## 2. Изучение простых объектов, операции присваивания.
+
+```py
+f1 = 16; f2 = 3
+f1,f2
+(16, 3)
+f1;f2
+16
+3
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+type(f2)
+<class 'int'>
+del f1,f2
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+## 3. Изучение правил наименования объектов.
+
+```py
+gg1 = 1.6
+hh1 = "Строка"
+73sr = 3
+SyntaxError: invalid decimal literal
+and = 7
+SyntaxError: invalid syntax
+```
+
+## 4. Список ключевых слов.
+
+```py
+import keyword
+keyword.kwlist
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+keyword_list = keyword.kwlist
+```
+
+## 5. Список встроенных идентификаторов.
+
+```py
+dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError',
+'BaseException', 'BaseExceptionGroup', 'BlockingIOError',
+'BrokenPipeError', 'BufferError', 'BytesWarning',
+'ChildProcessError',...]
+help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the argument.
+
+help (len)
+Help on built-in function len in module builtins:
+
+len(obj, /)
+    Return the number of items in a container.
+
+help(max)
+Help on built-in function max in module builtins:
+
+max(...)
+    max(iterable, *[, default=obj, key=func]) -> value
+    max(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its biggest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the largest argument.
+
+help(min)
+Help on built-in function min in module builtins:
+
+min(...)
+    min(iterable, *[, default=obj, key=func]) -> value
+    min(arg1, arg2, *args, *[, key=func]) -> value
+
+    With a single iterable argument, return its smallest item. The
+    default keyword-only argument specifies an object to return if
+    the provided iterable is empty.
+    With two or more positional arguments, return the smallest argument.
+
+help(pow)
+Help on built-in function pow in module builtins:
+
+pow(base, exp, mod=None)
+    Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
+
+    Some types, such as ints, are able to use a more efficient algorithm when
+    invoked using the three argument form.
+
+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.
+
+help(sorted)
+Help on built-in function sorted in module builtins:
+
+sorted(iterable, /, *, key=None, reverse=False)
+    Return a new list containing all items from the iterable in ascending order.
+
+    A custom key function can be supplied to customize the sort order, and the
+    reverse flag can be set to request the result in descending order.
+
+help (sum)
+Help on built-in function sum in module builtins:
+
+sum(iterable, /, start=0)
+    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+    When the iterable is empty, return the start value.
+    This function is intended specifically for use with numeric values and may
+    reject non-numeric types.
+
+help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables, strict=False)
+ |
+ |  The zip object yields n-length tuples, where n is the number of iterables
+ |  passed as positional arguments to zip().  The i-th element in every tuple
+ |  comes from the i-th iterable argument to zip().  This continues until the
+ |  shortest argument is exhausted.
+ |
+ |  If strict is true and one of the arguments is exhausted before the others,
+ |  raise a ValueError.
+ |
+ |     >>> list(zip('abcdefg', range(3), range(4)))
+ |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+ |
+ |  Methods defined here:
+ |
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |
+ |  __next__(self, /)
+ |      Implement next(self).
+ |
+ |  __reduce__(self, /)
+ |      Return state information for pickling.
+ |
+ |  __setstate__(self, object, /)
+ |      Set state information for unpickling.
+ |
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |
+ |  __new__(*args, **kwargs)
+ |      Create and return a new object.  See help(type) for accurate signature.
+
+abs(-5)
+5
+len('primer')
+6
+max(9,8,3)
+9
+min(9,8,3)
+3
+pow(2,3)
+8
+round (5.2381, 2)
+5.24
+pack = (2,5,1,0,4)
+sorted(pack)
+[0, 1, 2, 4, 5]
+sum(pack)
+12
+pack2 = ('A','B','C','D','E')
+fullpack = list(zip(pack,pack2))
+print(fullpack)
+[(2, 'A'), (5, 'B'), (1, 'C'), (0, 'D'), (4, 'E')]
+```
+
+## 6. Убеждаемся, что малые и большие буквы в именах объектов различаются.
+
+```py
+Gg1=45
+gg1,Gg1
+(1.6, 45)
+```
+
+## 7. Изучение простых базовых типов объектов.
+
+## 7.1. Логический тип
+
+```py
+bb1=True;bb2=False
+bb1,bb2
+(True, False)
+type(bb1)
+<class 'bool'>
+```
+
+## 7.2. Остальные типы
+
+```py
+ii1=-1234567890
+ii1
+-1234567890
+type(ii1)
+<class 'int'>
+ff1=-8.9876e-12
+ff1
+-8.9876e-12
+type(ff1)
+<class 'float'>
+dv1=0b1101010
+type(dv1)
+<class 'int'>
+vsm1=0o52765
+vsm1
+22005
+type(vsm1)
+<class 'int'>
+shest1=0x7109af6
+shest1
+118528758
+type(shest1)
+<class 'int'>
+cc1=2-3j
+cc1
+(2-3j)
+type(cc1)
+<class 'complex'>
+a=3.67;b=-0.45
+cc2=complex(a,b)
+cc2
+(3.67-0.45j)
+```
+
+## 7.3 Символьная строка.
+
+```py
+ss1='Это-строка символов'
+ss1="Это-строка символов"
+ssa1 = "Это - \"строка символов\", \n \t выводимая на двух строках"
+print(ssa1)
+Это - "строка символов", 
+ 	 выводимая на двух строках
+ss1b = 'Меня зовут: \n Лыкова Е.А'
+print(ss1b)
+Меня зовут: 
+ Лыкова Е.А
+mnogo = """Нетрудно заметить, что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвут в операции."""
+print(mnogo)
+Нетрудно заметить, что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвут в операции.
+ss1[0]
+'Э'
+ss1[8]
+'к'
+ss1[-2]
+'о'
+ss1[6:9]
+'рок'
+ss1[13:]
+'мволов'
+ss1[5:-8]
+'трока '
+ss1[3:17:2]
+'-тоасмо'
+ss1[17:3:-2]
+'оомсаот'
+ss1[-4:3:-2]
+'омсаот'
+ss1[4]='='
+Traceback (most recent call last):
+  File "<pyshell#82>", line 1, in <module>
+    ss1[4]='='
+TypeError: 'str' object does not support item assignment
+ss1=ss1[:4]+'='+ss1[5:]
+ss1
+'Это-=трока символов'
+print(ss1b)
+Меня зовут: 
+ Лыкова Е.А
+ss1b[5:8]
+'зов'
+ss1b[::-2]
+'АЕаоы  твзяе'
+ss1b[-6:10:3]
+''
+```
+
+## 8. Изучение более сложных типов объектов.
+
+## 8.1 Списки.
+
+```py
+spis1 = [111,'Spisok',5-9j]
+spis1
+[111, 'Spisok', (5-9j)]
+stup = [0,0,1,1,1,1,1,1,1]
+stup
+[0, 0, 1, 1, 1, 1, 1, 1, 1]
+spis = [1,2,3,4,
+        5,6,7,
+        8,9,10]
+spis
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+spis[-1]
+10
+stup[-8::2]
+[0, 1, 1, 1]
+```
+
+В этот список вошло четыре элемента. В исходном списке они имели индексы 1, 3, 5, 7
+
+```py
+spis1[1] = 'Список'
+spis1
+[111, 'Список', (5-9j)]
+len(spis1)
+3
+dir(spis1)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+help(spis1.append)
+Help on built-in function append:
+
+append(object, /) method of builtins.list instance
+    Append object to the end of the list.
+
+spis1.append('New item')
+spis1
+[111, 'Список', (5-9j), 'New item']
+spis1+['New item']
+[111, 'Список', (5-9j), 'New item', 'New item']
+spis1.append(ss1b)
+spis1
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.pop(1)
+'Список'
+spis1
+[111, (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.insert(1, 'Vesch')
+spis1
+[111, 'Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.remove(111)
+spis1
+['Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А']
+spis1.extend(['lol'])
+spis1
+['Vesch', (5-9j), 'New item', 'Меня зовут: \n Лыкова Е.А', 'lol']
+spis1.clear()
+spis1
+[]
+spisnew = [ 'V', 'C', 'O', 'S']
+spisnew.sort()
+spisnew
+['C', 'O', 'S', 'V']
+spisnew.reverse()
+spisnew
+['V', 'S', 'O', 'C']
+spisnew.copy()
+['V', 'S', 'O', 'C']
+spiscopy = spisnew.copy()
+spiscopy
+['V', 'S', 'O', 'C']
+spisnew.count('O')
+1
+spisnew.index('O')
+2
+spis2=[spis1,[4,5,6,7]]
+spis2[0][1]
+'Spisok'
+spis2[0][1]=78
+spis2
+[[111, 78, (5-9j)], [4, 5, 6, 7]]
+spis1
+[111, 78, (5-9j)]
+```
+
+Объект spis1 отличается от своего изначального вида, поскольку мы использовали на нём различные функции,
+которые добавляли, убирали и изменяли объекты в нём.
+
+```py
+spisochek = [17, 17, 17, 16]
+moispisok = [1991, 'Stroka', False, spisochek]
+moispisok
+[1991, 'Stroka', False, [17, 17, 17, 16]]
+```
+
+## 8.2 Объект-кортеж
+
+```py
+kort1 = (222,'Kortezh',77+8j)
+kort1 = kort1 + (1,2)
+kort1 = kort1 + (ss1b,)
+kort2 = kort1[:2]+kort1[3:]
+kort2.index(2)
+3
+kort1.count(222)
+1
+kort1[2]=90
+Traceback (most recent call last):
+  File "<pyshell#177>", line 1, in <module>
+    kort1[2]=90
+TypeError: 'tuple' object does not support item assignment
+moikort = (2005,'StrokaNovaya',spisochek,kort1)
+moikort
+(2005, 'StrokaNovaya', [17, 17, 17, 16], (222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Лыкова Е.А'))
+```
+
+## 8.3. Объект-словарь
+
+```py
+dic1={'Saratov':145,'Orel':56,'Vologda':45}
+dic1['Orel']
+56
+dic1['Pskov']=78
+dic1
+{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+sorted(dic1.keys())
+['Orel', 'Pskov', 'Saratov', 'Vologda']
+sorted(dic1.values())
+[45, 56, 78, 145]
+dic2={1:'mean',2:'standart devation',3:'correlation'}
+dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+dic3['statistics'][2]
+'standart devation'
+dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
+dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+dic4
+{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Лыкова Е.А'}
+dic5
+{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Лыкова Е.А'}
+kortezh = ('A','B','C','D','E','F','G')
+spisok = (1,2,3,4,5)
+slovar = dict(zip(kortezh,spisok))
+print(slovar,len(slovar))
+{'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5} 5
+```
+
+## 8.4. Объект-множество
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'микропроцессор', 'линия связи', 'датчик', 'двигатель'}
+len(mnoz1)
+4
+'датчик' in mnoz1
+True
+mnoz1.add('реле')
+mnoz1.remove('линия связи')
+mnoz1
+{'микропроцессор', 'двигатель', 'датчик', 'реле'}
+mnozestvo = {'огурец','дикий огурец','кукуруза'}
+len(mnozestvo)
+3
+'кукуруза' in mnozestvo
+True
+mnozestvo.add('кукуруза сейчас')
+mnozestvo
+{'дикий огурец', 'огурец', 'кукуруза сейчас', 'кукуруза'}
+mnozestvo.remove('огурец')
+mnozestvo
+{'дикий огурец', 'кукуруза сейчас', 'кукуруза'}
+```

TEMA2/task.md

@@ -0,0 +1,33 @@
+# Общее контрольное задание по теме 2
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия.
+
+## Решение
+
+```py
+familia = 'Lykova'
+sovpad = familia[0]
+import keyword
+sp_kw = keyword.kwlist
+sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+sp_kw.remove('nonlocal')
+sp_kw
+['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+kort_nam = ('Елизавета','Екатерина','Дмитрий','Даниил')
+print('Тип переменной:', type(kort_nam))
+Тип переменной: <class 'tuple'>
+kort_nam = kort_nam + ('Иван','Федор')
+kort_nam
+('Елизавета', 'Екатерина', 'Дмитрий', 'Даниил', 'Иван', 'Федор')
+count = kort_nam.count('Дима')
+count
+0
+dict_bas = {'Строка': familia, 'Список': sp_kw, 'Кортеж': kort_nam}
+dict_bas
+{'Строка': 'Lykova', 'Список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'Кортеж': ('Елизавета', 'Екатерина', 'Дмитрий', 'Даниил', 'Иван', 'Федор')}
+```

TEMA2/test.md

@@ -0,0 +1,23 @@
+# Индивидуальное контрольное задание по теме 2
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Пусть создан объект dd = [11,2,-4,23,12,56]
+К какому классу он относится? Как расположить его элементы в порядке убывания?
+
+## Решение
+
+```py
+dd = [11,2,-4,23,12,56]
+print('Класс объекта:', type(dd))
+Класс объекта: <class 'list'>
+dd.sort(reverse=True)
+dd
+[56, 23, 12, 11, 2, -4]
+# Ещё можно вот так (создается новый список)
+dds = sorted(dd, reverse=True)
+dds
+[56, 23, 12, 11, 2, -4]
+```

TEMA3/report.md

@@ -0,0 +1,680 @@
+# Отчет по теме 3
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA3")
+```
+
+## 2. Преобразование простых базовых типов объектов.
+
+## 2.1 Логическая функция bool.
+
+```py
+logiz1 = bool(56)
+logiz1, type(logiz1)
+(True, <class 'bool'>)
+logiz2 = bool(0)
+logiz2, type(logiz2)
+(False, <class 'bool'>)
+logiz3 = bool("Beta")
+logiz3, type(logiz3)
+(True, <class 'bool'>)
+logiz4 = bool("")
+logiz4, type(logiz4)
+(False, <class 'bool'>)
+```
+
+## 2.2.1 Функция int.
+
+```py
+tt1 = int(198.6)
+tt1, type(tt1)
+(198, <class 'int'>)
+tt2 = int('-76')
+tt2, type(tt2)
+(-76, <class 'int'>)
+tt3 = int('B',16)
+tt3, type(tt3)
+(11, <class 'int'>)
+tt4 = int('71',8)
+tt4, type(tt4)
+(57, <class 'int'>)
+tt5 = int('98.76')
+Traceback (most recent call last):
+  File "<pyshell#19>", line 1, in <module>
+    tt5 = int('98.76')
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+
+Диагностическое сообщение было выведено из-за того, что int ожидает в кавычках целое число, а не дробное.
+
+## 2.2.2 Функция float.
+
+```py
+flt1 = float(789)
+flt1, type(flt1)
+(789.0, <class 'float'>)
+flt2 = float(-6.78e2)
+flt2, type(flt2)
+(-678.0, <class 'float'>)
+flt3 = float('Infinity')
+flt3, type(flt3)
+(inf, <class 'float'>)
+flt4 = float('-inf')
+flt4, type(flt4)
+(-inf, <class 'float'>)
+```
+
+## 2.3. Другие системы счисления.
+
+```py
+hh = 123
+dv1 = bin(hh)
+dv1
+'0b1111011'
+vos1 = oct(hh)
+vos1
+'0o173'
+shs1 = hex(hh)
+shs1
+'0x7b'
+int(dv1,2)
+123
+int(vos1,8)
+123
+int(shs1,16)
+123
+```
+
+## 3. Сложные базовые типы объектов.
+
+## 3.1 Функция str.
+
+```py
+strk1 = str(23.6)
+strk1, type(strk1)
+('23.6', <class 'str'>)
+strk2 = str(logiz3)
+strk2, type(strk2)
+('True', <class 'str'>)
+strk3 = str(['A','B','C'])
+strk3, type(strk3)
+("['A', 'B', 'C']", <class 'str'>)
+strk4 = str(('A','B','C'))
+strk4, type(strk4)
+("('A', 'B', 'C')", <class 'str'>)
+strk5 = str({'A':1,'B':2,'C':9})
+strk5, type(strk5)
+("{'A': 1, 'B': 2, 'C': 9}", <class 'str'>)
+```
+
+## 3.2 Функция list.
+
+```py
+spis1 = list('Строка символов')
+spis1, type(spis1)
+(['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'], <class 'list'>)
+spis2 = list((124,236,-15,908))
+spis2, type(spis2)
+([124, 236, -15, 908], <class 'list'>)
+spis3 = list({'A':1,'B':2,'C':9})
+spis3, type(spis3)
+(['A', 'B', 'C'], <class 'list'>)
+# Список со значениями
+spis4 = list({'A':1,'B':2,'C':9}.values())
+spis4, type(spis4)
+([1, 2, 9], <class 'list'>)
+# Словарь полностью
+spis4 = list({'A':1,'B':2,'C':9}.items())
+spis4, type(spis4)
+([('A', 1), ('B', 2), ('C', 9)], <class 'list'>)
+```
+
+## 3.3 Функция tuple.
+
+```py
+kort7=tuple('Строка символов')
+kort7, type(kort7)
+(('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'), <class 'tuple'>)
+kort8 = tuple(spis2)
+kort8, type(kort8)
+((124, 236, -15, 908), <class 'tuple'>)
+kort9 = tuple({'A':1,'B':2,'C':9})
+kort9, type(kort9)
+(('A', 'B', 'C'), <class 'tuple'>)
+```
+
+## 3.4 Удаление объектов.
+
+```py
+del strk5, kort8
+print(strk5)
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    print(strk5)
+NameError: name 'strk5' is not defined
+print(kort8)
+Traceback (most recent call last):
+  File "<pyshell#10>", line 1, in <module>
+    print(kort8)
+NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
+imya = 'Lykova E.A'
+imya
+'Lykova E.A'
+spis = list(imya)
+spis
+['L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A']
+kort = tuple(spis)
+kort
+('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A')
+strk = str(kort)
+strk
+"('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A')"
+```
+
+## 4. Арифметические операции.
+
+## 4.1 Сложение и вычитание.
+
+```py
+12+7+90
+109
+5.689e-1-0.456
+0.11289999999999994
+23.6 + 54
+77.6
+14 - 56.7 + 89
+46.3
+```
+
+## 4.2 Умножение.
+
+```py
+-6.7 * 12
+-80.4
+```
+
+## 4.3 Деление.
+
+```py
+-234.5/6
+-39.083333333333336
+a = 178/45
+a, type(a)
+(3.9555555555555557, <class 'float'>)
+```
+
+## 4.4 Деление с округлением вниз.
+
+```py
+b = 178//45
+b, type(b)
+(3, <class 'int'>)
+c = -24.6//12.1
+c, type(c)
+(-3.0, <class 'float'>)
+d = 178//12.1
+d, type(d)
+(14.0, <class 'float'>)
+e = -24.6//45
+e, type(e)
+(-1.0, <class 'float'>)
+```
+
+## 4.5 Остаток от деления.
+
+```py
+148%33
+16
+12.6%3.8
+1.2000000000000002
+148%3.8
+3.6000000000000068
+12.6%33
+12.6
+```
+
+## 4.6 Возведение в степень.
+
+```py
+14**3
+2744
+e = 2.7**3.6
+e
+35.719843790663525
+14**3.6
+13367.830445904418
+2.7**3
+19.683000000000003
+c1 = 3 + 4j
+c2 = 1 - 2j
+c1 + c2
+(4+2j)
+c1 - c2
+(2+6j)
+c1 * c2
+(11-2j)
+c1/c2
+(-1+2j)
+c1//c2
+Traceback (most recent call last):
+  File "<pyshell#50>", line 1, in <module>
+    c1//c2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+c1%c2
+Traceback (most recent call last):
+  File "<pyshell#51>", line 1, in <module>
+    c1%c2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+c1** 2
+(-7+24j)
+```
+
+Как мы видим, для работы с комплексными числами нельзя применять операции остатка от деления и деление с округлением вниз.
+
+## 5. Операции с двоичным представдением целых чисел.
+
+## 5.1 Двоичная инверсия.
+
+```py
+dv1 = 9
+dv2 = ~dv1
+bin(dv1)
+'0b1001'
+dv2
+-10
+bin(dv2)
+'-0b1010'
+```
+
+## 5.2 Двоичное 'И'.
+
+```py
+7&9
+1
+bin(7&9)
+'0b1'
+7&8
+0
+bin(7&8)
+'0b0'
+```
+
+## 5.3 Двоичное 'ИЛИ'.
+
+```py
+7|9
+15
+bin(7|9)
+'0b1111'
+7|8
+15
+bin(7|8)
+'0b1111'
+14|5
+15
+bin(14|5)
+'0b1111'
+```
+
+## 5.4 Двоичное исключающее 'ИЛИ'.
+
+```py
+14^5
+11
+bin(14^5)
+'0b1011'
+```
+
+## 5.5 Сдвиг двоичного представления на заданное число разрядов.
+
+```py
+l1 = 68
+l2 = 71
+bin(l1)
+'0b1000100'
+bin(l2)
+'0b1000111'
+bin(~l1)
+'-0b1000101'
+bin(~l2)
+'-0b1001000'
+bin(l1&l2)
+'0b1000100'
+bin(l1|l2)
+'0b1000111'
+bin(l1^l2)
+'0b11'
+bin(l1>>2)
+'0b10001'
+bin(l2<<1)
+'0b10001110'
+```
+
+## 6. Операции при работе с последовательностями.
+
+## 6.1 Объединение последовательностей.
+
+```py
+'Система' + 'регулирования'
+'Системарегулирования'
+['abc','de','fg']+['hi','jkl']
+['abc', 'de', 'fg', 'hi', 'jkl']
+('abc','de','fg')+('hi','jkl')
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+
+## 6.2 Повторение
+
+```py
+'ля'*5
+'ляляляляля'
+['ку','-']*3
+['ку', '-', 'ку', '-', 'ку', '-']
+('кис','-')*4
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+signal1=[0]*3+[1]*99
+signal1
+[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+signal2 = (0,)*3+(1,)*5+(0,)*7
+signal2
+(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+```
+
+## 6.3 Проверка наличия заданного элемента в последовательности.
+
+```py
+stroka = 'Система автоматического управления'
+'автомат' in stroka
+True
+'ку' in ['ку','-']*3
+True
+'ля-' in ('abc','de','fg','hi','jkl')
+False
+```
+
+## 6.4 Подстановка значений в строку.
+
+```py
+stroka = 'Температура = %g %s %g'
+stroka
+'Температура = %g %s %g'
+stroka % (16, 'меньше', 25)
+'Температура = 16 меньше 25'
+stroka = 'Температура = %(zn1)g%(sptavn)s %(zn2)g'
+stroka
+'Температура = %(zn1)g%(sptavn)s %(zn2)g'
+stroka %{'zn1':16,'sptavn':'меньше','zn2':25}
+'Температура = 16меньше 25'
+```
+
+## 7. Оператор присваивания.
+
+## 7.1 Обычное присваивание.
+
+```py
+zz=-12
+zz
+-12
+```
+
+## 7.2 Увеличение значения на заданную величину.
+
+```py
+zz+=5
+zz
+-7
+zz-=3
+zz
+-10
+stroka = 'Система'
+stroka+= 'регулирования'
+stroka
+'Системарегулирования'
+```
+
+## 7.3 Умножение на заданную величину.
+
+```py
+zz/=2
+zz
+-5.0
+zz*=5
+zz
+-25.0
+strokan = 'ля'
+strokan *= 5
+strokan
+'ляляляляля'
+```
+
+## 7.4 Операция деления с округлением, получение остатка от деления и возведение в степень.
+
+```py
+ll = 77
+ll//=3
+ll
+25
+ll%=3
+ll
+1
+ll**=7
+ll
+1
+```
+
+## 7.5 Множественное присваивание.
+
+```py
+w = v = 10
+n1,n2,n3=(11,-3,'all')
+w
+10
+v
+10
+n1
+11
+n2
+-3
+n3
+'all'
+a1,a2,a3 = 'na', 'no', 'nu'
+a1,a2,a3
+('na', 'no', 'nu')
+a1,a2,a3 = 'abc'
+a1,a2,a3
+('a', 'b', 'c')
+b1,b2,b3 = ['la','lo','lu']
+b1,b2,b3
+('la', 'lo', 'lu')
+c1,c2,c3 = {'ha':1,'ho':2,'he':3}
+c1,c2,c3
+('ha', 'ho', 'he')
+d1,d2,d3 = {'me','ma','mo'}
+d1,d2,d3
+('ma', 'me', 'mo')
+```
+
+## 8. Логические операции.
+
+## 8.1 Операции сравнения.
+
+```py
+w == v
+True
+w != v
+False
+w < v
+False
+w > v
+False
+w <= v
+True
+w >= v
+True
+```
+
+## 8.2 Проверка наличия заданного элемента.
+
+```py
+mnoz1 = {'pen','book','pen','iPhone','table','book'}
+mnoz1
+{'pen', 'table', 'iPhone', 'book'}
+'book' in mnoz1
+True
+'cap' in mnoz1
+False
+dic1={'Saratov':145,'Orel':56,'Vologda':45}
+'Vologda' in dic1
+True
+'Pskov' in dic1
+False
+56 in dic1.values()
+True
+dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa':['A-01-15','A-02-15']}
+'UII' in dct1['Depart']
+True
+dct1['Depart'][1] == 'MM'
+False
+```
+
+## 8.3 Создание больших логических выражений.
+
+```py
+a = 17
+b = -6
+(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+(a < b) or ('Saratov' in dic1) or ('deck' in mnoz1)
+True
+('Saratov' in dic1) and not (a<b) and not ('pen' in mnoz1)
+False
+```
+
+## 8.4 Проверка ссылок на один и тот же объект.
+
+```py
+w=v=10
+w is v
+True
+w1 =['A','B']
+v1 = ['A','B']
+w1 is v1
+False
+```
+
+В первом случае обе переменные присваиваются к одному уже существующему в памяти объекту, когда как во втором переменные ипсользуют два разных списка.
+
+## 9. Операции с объектами, выполняемые с помощью методов.
+
+```py
+stroka = 'Микропроцессорная система управления'
+dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+## 9.1 Методы для работы со строками.
+
+```py
+stroka.find('пр')
+5
+stroka.count('c')
+0
+stroka.replace('у','автоматического у')
+'Микропроцессорная система автоматического управления'
+spis22=stroka.split(' ')
+spis22
+['Микропроцессорная', 'система', 'управления']
+stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+stroka3=''.join(spis22)
+stroka3
+'Микропроцессорнаясистемауправления'
+stroka3.partition('с')
+('Микропроце', 'с', 'сорнаясистемауправления')
+stroka3.rpartition('с')
+('Микропроцессорнаяси', 'с', 'темауправления')
+strk1='Момент времени {}, значение = {}'
+strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+strk2 = 'Момент времени {1}, значение = {0}:{2}'
+strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+strk3 = 'Момент времени {num}, значение = {znch}'
+strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+
+## 9.2 Методы для работы со списками.
+
+```py
+spsk = [167, 'haha', 'meme', 89.7, 'sasalele']
+dir(spsk)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+spsk.pop(2)
+'meme'
+spsk.append('с')
+spsk
+[167, 'haha', 89.7, 'sasalele', 'с']
+spsk.insert(2,'a')
+spsk
+[167, 'haha', 'a', 89.7, 'sasalele', 'с']
+spsk.count('a')
+1
+```
+
+## 9.3 Методы работы с кортежом.
+
+```py
+tupl = (178, 'nana', 'jaja', 456, 90.4)
+dir(tupl)
+['__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']
+tupl.count(456)
+1
+tupl.index('nana')
+1
+```
+
+## 9.4 Методы словарей и множеств.
+
+```py
+slvr = {'A':'wot','B':45,'C':39,'D':'meme','F':'pepe'}
+slvr
+{'A': 'wot', 'B': 45, 'C': 39, 'D': 'meme', 'F': 'pepe'}
+dir(slvr)
+['__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']
+slvr.keys()
+dict_keys(['A', 'B', 'C', 'D', 'F'])
+slvr.items()
+dict_items([('A', 'wot'), ('B', 45), ('C', 39), ('D', 'meme'), ('F', 'pepe')])
+slvr.values()
+dict_values(['wot', 45, 39, 'meme', 'pepe'])
+slvr.get('A')
+'wot'
+mnozh = {'haha', 763, 'ikk', 98.6, 'fsfs'}
+dir(mnozh)
+['__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']
+mnozh.pop()
+98.6
+mnozh.pop()
+'fsfs'
+mnozh
+{763, 'haha', 'ikk'}
+mnozh.add('pfff')
+mnozh
+{'pfff', 763, 'haha', 'ikk'}
+mnozh.remove('haha')
+mnozh
+{'pfff', 763, 'ikk'}
+```
+
+
+
+
+
+
+

TEMA3/task.md

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

TEMA3/test.md

@@ -0,0 +1,62 @@
+# Тест 1 Вариант 3
+
+Лыкова Елизавета, А-01-23
+
+## Задание 
+
+1)	Как можно запустить на выполнение программу, исходный код которой находится в текстовом файле?
+
+2)	Создайте объект-словарь с 6 элементами: ключи - названия звеньев в схеме регулятора ("инерционное звено1",:) (названия могут повторяться с точностью до порядкового номера), значения - список параметров соответствующего звена. Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+3)	Напишите инструкцию, позволяющую увеличить в два раза второй параметр инерционного звена в словаре. Отобразите на экране получившийся объект.
+
+4)	Напишите инструкции, позволяющие создать список названий звеньев из словаря. Преобразуйте этот список во множество. Отобразите полученный объект. Добавьте к полученному множеству элемент "гистерезис".
+
+5)	Напишите инструкцию, позволяющую подсчитать число элементов в схеме. Удалите из словаря один из его элементов. Отобразите результат.
+
+## Решение 
+
+1) Для запуска программы, чей исходный код находится в текстовом файле с расширением .txt, можно переименовать расширение файла в .py и запустить
+
+2) 
+```py
+slov = {'инерционное звено1': [5,7,0],'усилительное звено': [8,3,3],'интегрирующее звено': [9,1,4],'дифференцирующее звено': [9,4,5],'пропорциональное звено': [7,2,3],'инерционное звено': [4,6,2]}
+slov
+{'инерционное звено1': [5, 7, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+type(slov)
+<class 'dict'>
+dir(slov)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
+```
+
+3)
+```py
+slov['инерционное звено1'][1]*=2
+slov
+{'инерционное звено1': [5, 14, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+```
+
+4)
+```py
+spis = slov.keys()
+spis
+dict_keys(['инерционное звено1', 'усилительное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено', 'инерционное звено'])
+mnoz = set(spis)
+mnoz
+{'инерционное звено1', 'усилительное звено', 'инерционное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено'}
+mnoz.add('гистерезис')
+mnoz
+{'инерционное звено1', 'усилительное звено', 'инерционное звено', 'интегрирующее звено', 'дифференцирующее звено', 'пропорциональное звено', 'гистерезис'}
+```
+
+5)
+```py
+slov
+{'инерционное звено1': [5, 14, 0], 'усилительное звено': [8, 3, 3], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+len(slov)
+6
+slov.pop('усилительное звено')
+[8, 3, 3]
+slov
+{'инерционное звено1': [5, 14, 0], 'интегрирующее звено': [9, 1, 4], 'дифференцирующее звено': [9, 4, 5], 'пропорциональное звено': [7, 2, 3], 'инерционное звено': [4, 6, 2]}
+```

TEMA4/report.md

@@ -0,0 +1,542 @@
+# Отчет по теме 4
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA4")
+```
+
+## 2. Стандартные функции.
+
+## 2.1 Функция round.
+
+```py
+help(round)
+Help on built-in function round in module builtins:
+
+round(number, ndigits=None)
+    Round a number to a given precision in decimal digits.
+
+    The return value is an integer if ndigits is omitted or None.  Otherwise
+    the return value has the same type as the number.  ndigits may be negative.
+
+round(123.456,1)
+123.5
+round(123.456,0)
+123.0
+a = round(123.456,1)
+b = round(123.456,0)
+type(a)
+<class 'float'>
+type(b)
+<class 'float'>
+c = round(123.456)
+c
+123
+type(c)
+<class 'int'>
+```
+
+В первых двух случаях типы получившихся данных - float, когда во втором - int.
+
+## 2.2 Функция range.
+
+```py
+gg = range(76,123,9)
+gg
+range(76, 123, 9)
+list(gg)
+[76, 85, 94, 103, 112, 121]
+range(23)
+range(0, 23)
+d = range(23)
+list(d)
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+```
+
+Диапазон начинается от нуля и заканчивается предыдущим числом заданных 23-х. Шаг - единица.
+
+## 2.3 Функция zip.
+
+```py
+qq = ['Лыкова','Соловьёва','Коваленко','Голощапов']
+ff = zip(gg,qq)
+tuple(ff)
+((76, 'Лыкова'), (85, 'Соловьёва'), (94, 'Коваленко'), (103, 'Голощапов'))
+print(ff[0])
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    print(ff[0])
+TypeError: 'zip' object is not subscriptable
+tt = tuple(ff)
+tt
+((76, 'Лыкова'), (85, 'Соловьёва'), (94, 'Коваленко'), (103, 'Голощапов'))
+print(tt[1])
+(85, 'Соловьёва')
+```
+
+К объекту ff можно обратиться с указанием индекса, преобразовав его в кортеж.
+
+## 2.4 Функция eval.
+
+```py
+fff = float(input('Коэффициент усиления='));dan = eval('5*fff-156')
+Коэффициент усиления=3
+dan
+-141.0
+```
+
+## 2.5 Функция exec.
+
+```py
+exec(input('Введите инструкции:'))
+Введите инструкции:perem=-123.456;gg=round(abs(perem)+98,3)
+gg
+221.456
+```
+
+## 2.6 Функции abs,pow,max,min,sum,dinmod,len,map.
+
+```py
+abs(-5)
+5
+abs(10-15)
+5
+#Возвращает модуль числа
+pow(2,3)
+8
+pow(5,2)
+25
+#Возводит в степень
+chis = [4,5,2,8]
+max(chis)
+8
+min(chis)
+2
+slova = ['Радуга','Яблоко','Ананас','Груша']
+max(slova)
+'Яблоко'
+min(slova)
+'Ананас'
+#Находят максимальное и минимальное значения
+sum(chis)
+19
+sum(chis,10)
+29
+#Находит сумму элементов
+divmod(10,3)
+(3, 1)
+#Находит частное и остаток от деления
+len(chis)
+4
+строка  = 'Hallo!'
+len(строка)
+6
+slov = {'a':10,'b':20,'c':30}
+len(slov)
+3
+#Возвращает количество элементов в объекте
+list(map(str,chis))
+['4', '5', '2', '8']
+list(map(lambda x:x*2,chis))
+[8, 10, 4, 16]
+#Применение функции к каждому элементу последовательности
+```
+
+## 3. Функции модуля math.
+
+```py
+import math
+dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(n, /)
+    Find n!.
+
+math.factorial(5)
+120
+help(math.sin)
+Help on built-in function sin in module math:
+
+sin(x, /)
+    Return the sine of x (measured in radians).
+
+math.sin(1)
+0.8414709848078965
+help(math.acos)
+Help on built-in function acos in module math:
+
+acos(x, /)
+    Return the arc cosine (measured in radians) of x.
+
+    The result is between 0 and pi.
+
+math.acos(0.5)
+1.0471975511965979
+help(math.degrees)
+Help on built-in function degrees in module math:
+
+degrees(x, /)
+    Convert angle x from radians to degrees.
+
+math.degrees(45)
+2578.3100780887044
+help(math.radians)
+Help on built-in function radians in module math:
+
+radians(x, /)
+    Convert angle x from degrees to radians.
+
+math.radians(45)
+0.7853981633974483
+help(math.exp)
+Help on built-in function exp in module math:
+
+exp(x, /)
+    Return e raised to the power of x.
+
+math.exp(3)
+20.085536923187668
+help(math.log)
+Help on built-in function log in module math:
+
+log(...)
+    log(x, [base=math.e])
+    Return the logarithm of x to the given base.
+
+    If the base is not specified, returns the natural logarithm (base e) of x.
+
+math.log(4,3)
+1.2618595071429148
+help(math.log10)
+Help on built-in function log10 in module math:
+
+log10(x, /)
+    Return the base 10 logarithm of x.
+
+math.log10(3)
+0.47712125471966244
+help(math.sqrt)
+Help on built-in function sqrt in module math:
+
+sqrt(x, /)
+    Return the square root of x.
+
+math.sqrt(5)
+2.23606797749979
+help(math.ceil)
+Help on built-in function ceil in module math:
+
+ceil(x, /)
+    Return the ceiling of x as an Integral.
+
+    This is the smallest integer >= x.
+
+math.ceil(3.2)
+4
+help(math.floor)
+Help on built-in function floor in module math:
+
+floor(x, /)
+    Return the floor of x as an Integral.
+
+    This is the largest integer <= x.
+
+math.floor(3.8)
+3
+math.pi
+3.141592653589793
+math.sin((2*math.pi/7)+(math.exp(0.23)))
+0.8334902641414562
+```
+
+## 4. Функции из модуля cmath.
+
+```py
+import cmath
+dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+cmath.phase(1-0.5j)
+-0.4636476090008061
+```
+
+## 5. Модуль random.
+
+```py
+import random
+dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__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()
+help(random.random)
+Help on built-in function random:
+
+random() method of random.Random instance
+    random() -> x in the interval [0, 1).
+
+random.random()
+0.3783037280071182
+help(random.uniform)
+Help on method uniform in module random:
+
+uniform(a, b) method of random.Random instance
+    Get a random number in the range [a, b) or [a, b] depending on rounding.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = (a + b) / 2
+        Var[X] = (b - a) ** 2 / 12
+
+random.uniform(3,5)
+4.139029942389151
+help(random.randint)
+Help on method randint in module random:
+
+randint(a, b) method of random.Random instance
+    Return random integer in range [a, b], including both end points.
+
+random.randint(4,88)
+5
+help(random.gauss)
+Help on method gauss in module random:
+
+gauss(mu=0.0, sigma=1.0) method of random.Random instance
+    Gaussian distribution.
+
+    mu is the mean, and sigma is the standard deviation.  This is
+    slightly faster than the normalvariate() function.
+
+    Not thread-safe without a lock around calls.
+
+random.gauss()
+0.11579183153210448
+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(qq)
+'Лыкова'
+help(random.shuffle)
+Help on method shuffle in module random:
+
+shuffle(x) method of random.Random instance
+    Shuffle list x in place, and return None.
+
+random.shuffle(qq)
+qq
+['Коваленко', 'Лыкова', 'Соловьёва', 'Голощапов']
+help(random.sample)
+Help on method sample in module random:
+
+sample(population, k, *, counts=None) method of random.Random instance
+    Chooses k unique random elements from a population sequence.
+
+    Returns a new list containing elements from the population while
+    leaving the original population unchanged.  The resulting list is
+    in selection order so that all sub-slices will also be valid random
+    samples.  This allows raffle winners (the sample) to be partitioned
+    into grand prize and second place winners (the subslices).
+
+    Members of the population need not be hashable or unique.  If the
+    population contains repeats, then each occurrence is a possible
+    selection in the sample.
+
+    Repeated elements can be specified one at a time or with the optional
+    counts parameter.  For example:
+
+        sample(['red', 'blue'], counts=[4, 2], k=5)
+
+    is equivalent to:
+
+        sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)
+
+    To choose a sample from a range of integers, use range() for the
+    population argument.  This is especially fast and space efficient
+    for sampling from a large population:
+
+        sample(range(10000000), 60)
+
+random.sample(qq,3)
+['Соловьёва', 'Лыкова', 'Голощапов']
+help(random.betavariate)
+Help on method betavariate in module random:
+
+betavariate(alpha, beta) method of random.Random instance
+    Beta distribution.
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+    Returned values range between 0 and 1.
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha / (alpha + beta)
+        Var[X] = alpha * beta / ((alpha + beta)**2 * (alpha + beta + 1))
+random.betavariate(2,5)
+0.5473034184133493
+help(random.gammavariate)
+Help on method gammavariate in module random:
+
+gammavariate(alpha, beta) method of random.Random instance
+    Gamma distribution.  Not the gamma function!
+
+    Conditions on the parameters are alpha > 0 and beta > 0.
+
+    The probability distribution function is:
+
+                x ** (alpha - 1) * math.exp(-x / beta)
+      pdf(x) =  --------------------------------------
+                  math.gamma(alpha) * beta ** alpha
+
+    The mean (expected value) and variance of the random variable are:
+
+        E[X] = alpha * beta
+        Var[X] = alpha * beta ** 2
+
+random.gammavariate(2,5)
+4.616261402628337
+spis = [random.uniform(0,10),random.gauss(50,15),random.betavariate(2,5),random.gammavariate(2,5)]
+spis
+[0.21672125817392973, 25.399177937155795, 0.14356042747670408, 10.552855133080406]
+```
+
+## 6. Функции модуля time.
+
+```py
+import time
+dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+c1=time.time()
+c2=time.time()-c1
+c1,c2
+(1761295798.980248, 5.403235197067261)
+dat=time.gmtime()
+dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=8, tm_min=50, tm_sec=26, tm_wday=4, tm_yday=297, tm_isdst=0)
+dat.tm_mon
+10
+local_time = time.localtime()
+local_time
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=50, tm_sec=50, tm_wday=4, tm_yday=297, tm_isdst=0)
+print(f"Год: {local_time.tm_year}")
+Год: 2025
+c1 = time.time()
+local_struct = time.localtime(c1)
+local_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=54, tm_sec=13, tm_wday=4, tm_yday=297, tm_isdst=0)
+time_str = time.asctime(local_struct)
+time_str
+'Fri Oct 24 11:54:13 2025'
+time_str2 = time.ctime(c1)
+time.sleep(2)
+seconds = time.mktime(local_struct)
+seconds
+1761296053.0
+new_struct = time.localtime(seconds)
+new_struct
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=11, tm_min=54, tm_sec=13, tm_wday=4, tm_yday=297, tm_isdst=0)
+```
+
+## 7. Графические функции.
+
+```py
+import pylab
+x=list(range(-3,55,4))
+t=list(range(15))
+x
+[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
+t
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+pylab.plot(t,x)
+[<matplotlib.lines.Line2D object at 0x000002487CE9E990>]
+pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+pylab.xlabel('время')
+Text(0.5, 0, 'время')
+pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+pylab.show()
+```
+
+![Ris1](ris1.png)
+
+```py
+X1=[12,6,8,10,7]
+X2=[5,7,9,11,13]
+pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x000002487D263390>]
+pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x000002487D2634D0>]
+pylab.show()
+```
+
+![Ris2](ris2.png)
+
+```py
+region=['Центр','Урал','Сибирь','Юг']
+naselen=[65,12,23,17]
+pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000002487CE1DFD0>, <matplotlib.patches.Wedge object at 0x000002487D305090>, <matplotlib.patches.Wedge object at 0x000002487D305450>, <matplotlib.patches.Wedge object at 0x000002487D3056D0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+pylab.show()
+```
+
+![Ris3](ris3.png)
+
+```py
+data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+pylab.hist(data,5)
+(array([1., 2., 3., 2., 1.]), array([1. , 1.8, 2.6, 3.4, 4.2, 5. ]), <BarContainer object of 5 artists>)
+pylab.show()
+```
+
+![Ris4](ris4.png)
+
+```py
+c = ['A', 'B', 'C']
+v = [10, 25, 15]
+pylab.bar(c, v)
+<BarContainer object of 3 artists>
+pylab.show()
+```
+
+![Ris5](ris5.png)
+
+
+## 8. Модуль statistics.
+
+```py
+import statistics
+data = [1, 2, 2, 3, 3, 3, 4, 4, 5]
+sred = statistics.mean(data)
+sred
+3
+moda = statistics.mode(data)
+moda
+3
+mediana = statistics.median(data)
+mediana
+3

TEMA4/task.md

@@ -0,0 +1,82 @@
+# Общее контрольное задание по теме 4
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+* Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления. 
+* Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+* Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+* Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+* Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+* Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+
+## Решение
+
+```py
+import cmath
+import time
+import math
+import random
+```
+
+#1
+
+```py
+res = divmod((round(cmath.phase(0.2+0.8j), 2) * 20), 3)
+res
+(8.0, 2.6000000000000014)
+```
+
+#2
+
+```py
+Msk = time.localtime()
+Msk
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=24, tm_hour=12, tm_min=42, tm_sec=30, tm_wday=4, tm_yday=297, tm_isdst=0)
+Msk1 = [Msk.tm_hour,Msk.tm_min]
+stroka = ",".join(map(str,Msk1))
+stroka
+'12,42'
+```
+
+#3
+
+```py
+Week = ["Пн","Вт","Ср","Чт","Пт","Сб","Вс"]
+random.sample(Week, 3)
+['Пн', 'Вт', 'Сб']
+```
+
+#4
+
+```py
+row = [14, 17, 20, 23, 26, 29, 32]
+hm = random.choice(row)
+hm
+20
+```
+
+#5
+
+```py
+g = round(random.gauss(15, 4))
+g
+13
+Alph = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
+spis = random.sample(Alph, g)
+spis
+['M', 'P', 'H', 'f', 'q', 'C', 'n', 'E', 'x', 'd', 'Z', 'y', 'A']
+```
+
+#6
+
+```py
+endtime = time.time()
+sttime = time.mktime(Msk)
+razn = (endtime - sttime) /60
+razn
+8.829542791843414
+```

TEMA4/test.md

@@ -0,0 +1,27 @@
+# Индивидуальное контрольное задание по теме 4
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Создайте список с 5 элементами – случайными, нормально распределенными числами с математическим ожиданием 7 и дисперсией 36. Случайным образом отберите из списка 3 элемента и запишите их в кортеж. Создайте новый список с элементами, равными округленным до двух знаков после точки значениям из кортежа.
+
+## Решение
+
+```py
+import random
+import numpy as np
+random.seed(123)
+spis = list(map(float,np.random.normal(7,6,5)))
+spis
+[15.489450958964749, 14.130008288024907, 5.405877651624498, -7.268338076225266, 12.186023165514843]
+selec = tuple(random.sample(spis,3))
+selec
+(-7.268338076225266, 5.405877651624498, 15.489450958964749)
+spisnew = [round(x,2) for x in selec]
+spisnew
+[-7.27, 5.41, 15.49]
+```
+
+
+

TEMA5/report.md

@@ -0,0 +1,291 @@
+# Отчет по теме 5
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA5")
+```
+
+## 2. Ветвление по условию.
+
+```py
+porog,rashod1,rashod2 = 5,13,24
+if rashod1>=porog:
+    dohod=12
+elif rashod2==porog:
+    dohod=0
+else:
+    dohod=-8
+dohod
+12
+porog,rashod1,rashod2 = 5,13,4
+if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog			
+dohod
+13
+if porog == 3:
+    dohod = 1
+elif porog == 4:
+    dohod = 2
+elif porog == 5:
+    dohod = 3
+else:
+    dohod = 0  
+dohod
+3
+dohod = 2 if porog >= 4 else 0
+dohod
+2
+porog,rashod1,rashod2 = 5,13,24
+if porog >= 5:rashod1 = 6; rashod2 = 0
+rashod1,rashod2
+(6, 0)
+```
+
+## 3. Цикл по перечислению.
+
+## 3.1 Простой цикл.
+
+```py
+temperatura = 5
+for i in range(3,18,3):
+    temperatura += i  
+temperatura
+50
+```
+
+## 3.2 Более сложный цикл.
+
+```py
+sps = [2,15,14,8]
+for k in sps:
+    if len(sps) <= 10: sps.append(sps[0])
+    else: break  
+sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+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]
+```
+
+Вывод второго цикла отличается от первого из-за того, что работает он по длине копии списка. Следовательно, когда в оригинальный список добавляется новый элемент, длина копии остается такой же.
+
+## 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:
+    print(ss)  
+386
+for i in range(10):
+    sps5.append(rn.randint(1,100))
+    ss = sum(sps5)
+    if ss>500: break
+else:
+    print(ss)
+#Пусто
+```
+
+Вывод значения бывает не всегда, т.к у нас есть условие, что если сумма всех чисел будет превышать 500, то цикл заканчивается, при этом не выводя ничего.
+
+## 3.4 Символьная строка.
+
+```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)]
+import pylab
+pylab.plot(sps2, label = 'Синусоидальный сигнал')
+[<matplotlib.lines.Line2D object at 0x0000023CE2346990>]
+pylab.show()
+```
+
+![график](ris1.png)
+
+## 4. Цикл while.
+
+## 4.1 Цикл со счётчиком.
+
+```py
+rashod = 300
+while rashod:
+    print('Расход =',rashod)
+    rashod -= 50 
+Расход = 300
+Расход = 250
+Расход = 200
+Расход = 150
+Расход = 100
+Расход = 50
+```
+
+Завершение цкила произошло в тот момент, когда значение rashod стало равнятся нулю, т.к в питоне 0 идентифицируется как False.
+
+## 4.2 Символьная строка.
+
+```py
+import math
+stroka = 'Расчет процесса в объекте регулирования'
+i = 0
+sps2 = []
+while i < len(stroka):
+    r = 1 -2/(1 + math.exp(0.1*i))
+    sps2.append(r)
+    print('Значение в момент', i, '=', r)
+    i += 1
+Значение в момент 0 = 0.0
+Значение в момент 1 = 0.049958374957880025
+Значение в момент 2 = 0.09966799462495568
+Значение в момент 3 = 0.14888503362331795
+Значение в момент 4 = 0.197375320224904
+Значение в момент 5 = 0.2449186624037092
+Значение в момент 6 = 0.2913126124515909
+Значение в момент 7 = 0.3363755443363322
+Значение в момент 8 = 0.3799489622552249
+Значение в момент 9 = 0.421899005250008
+Значение в момент 10 = 0.4621171572600098
+Значение в момент 11 = 0.5005202111902354
+Значение в момент 12 = 0.5370495669980353
+Значение в момент 13 = 0.5716699660851172
+Значение в момент 14 = 0.6043677771171636
+Значение в момент 15 = 0.6351489523872873
+Значение в момент 16 = 0.6640367702678489
+Значение в момент 17 = 0.6910694698329307
+Значение в момент 18 = 0.7162978701990245
+Значение в момент 19 = 0.7397830512740043
+Значение в момент 20 = 0.7615941559557649
+Значение в момент 21 = 0.7818063576087741
+Значение в момент 22 = 0.8004990217606297
+Значение в момент 23 = 0.8177540779702878
+Значение в момент 24 = 0.8336546070121553
+Значение в момент 25 = 0.8482836399575129
+Значение в момент 26 = 0.8617231593133063
+Значение в момент 27 = 0.874053287886007
+Значение в момент 28 = 0.8853516482022625
+Значение в момент 29 = 0.8956928738431645
+Значение в момент 30 = 0.9051482536448664
+Значение в момент 31 = 0.9137854901178277
+Значение в момент 32 = 0.9216685544064713
+Значение в момент 33 = 0.9288576214547277
+Значение в момент 34 = 0.935409070603099
+Значение в момент 35 = 0.9413755384972874
+Значение в момент 36 = 0.9468060128462683
+Значение в момент 37 = 0.9517459571646616
+Значение в момент 38 = 0.9562374581277391
+pylab.plot(sps2, label = 'Сигнал на выходе')
+[<matplotlib.lines.Line2D object at 0x0000023CE271BC50>]
+pylab.show()
+```
+
+![график2](ris2.png)
+
+## 4.3 Цикл определения, является ли число простым.
+
+```py
+chislo = 267
+kandidat = chislo//2
+while kandidat > 1:
+    if chislo % kandidat == 0:
+        print(chislo, 'имеет множитель', kandidat)
+        break
+    kandidat -= 1
+else:
+    print(chislo, 'Является простым!')
+267 имеет множитель 89
+```
+
+Дополнение:
+
+```py
+chislo=list(range(250,301))
+ for i in chislo:
+     kandidat =i // 2
+     while kandidat > 1:
+         if i%kandidat == 0:
+             print(i, ' имеет множитель ', kandidat)
+             break
+         kandidat -= 1
+     else:
+         print(i, ' является простым!')
+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
+```
+
+    
+
+
+
+
+

TEMA5/task.md

@@ -0,0 +1,91 @@
+# Общее контрольное задание по теме 5
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Реализовать, записать в текстовый файл программы и результаты их выполнения при решении следующих задач:
+
+•Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помо-щи) определите порядковый номер каждой буквы в английском алфавите.
+
+•Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+•Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его сред-ние баллы по двум сессиям.
+
+## Решение
+
+# 1.
+
+```py
+import string
+strk = 'Golden brown texture like sun'
+for i in strk.lower():
+    n = string.ascii_lowercase.find(i)
+    if n >= 0:
+        print(f'Порядковый номер буквы {i} в английском алфавите: {n+1}')  
+Порядковый номер буквы g в английском алфавите: 7
+Порядковый номер буквы o в английском алфавите: 15
+Порядковый номер буквы l в английском алфавите: 12
+Порядковый номер буквы d в английском алфавите: 4
+Порядковый номер буквы e в английском алфавите: 5
+Порядковый номер буквы n в английском алфавите: 14
+Порядковый номер буквы b в английском алфавите: 2
+Порядковый номер буквы r в английском алфавите: 18
+Порядковый номер буквы o в английском алфавите: 15
+Порядковый номер буквы w в английском алфавите: 23
+Порядковый номер буквы n в английском алфавите: 14
+Порядковый номер буквы t в английском алфавите: 20
+Порядковый номер буквы e в английском алфавите: 5
+Порядковый номер буквы x в английском алфавите: 24
+Порядковый номер буквы t в английском алфавите: 20
+Порядковый номер буквы u в английском алфавите: 21
+Порядковый номер буквы r в английском алфавите: 18
+Порядковый номер буквы e в английском алфавите: 5
+Порядковый номер буквы l в английском алфавите: 12
+Порядковый номер буквы i в английском алфавите: 9
+Порядковый номер буквы k в английском алфавите: 11
+Порядковый номер буквы e в английском алфавите: 5
+Порядковый номер буквы s в английском алфавите: 19
+Порядковый номер буквы u в английском алфавите: 21
+Порядковый номер буквы n в английском алфавите: 14
+```
+
+# 2.
+
+```py
+spis = ['Создайте', 'список', 'со', 'словами', 'из', 'задания', 'данного', 'пункта', 'Для', 'этого', 'списка', 'определите', 'есть', 'ли', 'в', 'нем', 'некоторое', 'заданное', 'значение', 'и', 'выведите', 'соответствующее', 'сообщение', 'либо', 'о', 'нахождении', 'элемента', 'либо', 'о', 'его', 'отсутствии', 'в', 'списке', 'проверить', 'как', 'с', 'имеющимся', 'так', 'и', 'с', 'отсутствующим', 'словом']
+val = 'список'
+if val in spis:
+    print(f'{val} есть в списке')
+else:
+    print(f'{val} нет в списке')
+список есть в списке
+valu = 'кот'
+if valu in spis:
+    print(f'{valu} есть в списке')
+else:
+    print(f'{valu} нет в списке')
+кот нет в списке
+```
+
+# 3.
+
+```py
+stud_spis = ['Лыкова', 'Соловьева', 'Коваленко','Голощапов']
+stud_ocen = [3.9, 4.4, 4.6, 4.8]
+stud_spis2 = ['Соловьева', 'Голощапов', 'Лыкова', 'Коваленко']
+stud_ocen2 = [4.3, 4.8, 3.2, 4.9]
+nam = input('Введите фамилию студента:')
+if nam in stud_spis and stud_spis2:
+    print(f'Средний балл за летнюю сессию: ', stud_ocen[stud_spis.index(nam)])
+    print(f'Средний балл за зимнюю сессию: ', stud_ocen2[stud_spis2.index(nam)])
+else:
+    print(f'Студент отсутствует в списке')
+Введите фамилию студента:Лыкова
+Средний балл за летнюю сессию:  3.9
+Средний балл за зимнюю сессию:  3.2
+Введите фамилию студента:Иванов
+Студент отсутствует в списке
+```
+
+

TEMA5/test.md

@@ -0,0 +1,28 @@
+# Индивидуальное контрольное задание по теме 5
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Создайте кортеж с 20 случайными числами, равномерно распределенными в диапазоне от 20 до 98. Рассчитайте среднее значение по тем числам из множества, которые находятся в диапазоне значений от 40 до 70.
+
+## Решение
+
+```py
+import random
+kort = tuple(random.randint(20,98) for _ in range(20))
+kort
+(73, 47, 73, 39, 44, 27, 58, 22, 68, 85, 51, 42, 24, 46, 22, 24, 83, 88, 63, 57)
+filt_kort = []
+for i in kort:
+    if 40<= i <= 70:
+        filt_kort.append(i) 
+filt_kort
+[47, 44, 58, 68, 51, 42, 46, 63, 57]
+if filt_kort:
+    sred = sum(filt_kort)/len(filt_kort)
+    print(f'Среднее значение: ', sred)
+else:
+    print(f'В диапазоне нет значений от 40 до 70')
+Среднее значение:  52.888888888888886
+```

TEMA6/Stroka.txt

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

TEMA6/lll.py

@@ -0,0 +1,27 @@
+import sys
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA6")
+N = int(input('Введите целое число от 10 до 70: '))
+if (N < 10) or (N > 70):
+    int(input('Число не подходит условиям! Введите верное значение: '))
+print('Введено число ', N)
+SPS1 = [-25 + 3*i for i in range(N)]
+sumSPS1 = sum(SPS1)
+print('SPS1: ', SPS1)
+print('Сумма SPS1: ', sumSPS1)
+SPS1_new = [SPS1[i] for i in range(len(SPS1)) if (i + 1) % 4 != 0]
+SPS2 = [SPS1[i] for i in range(len(SPS1)) if (i + 1) % 4 == 0]
+print(SPS1,SPS2)
+sum2SPS1 = sum(SPS1_new)
+sum2SPS2 = sum(SPS2)
+sumall = sum2SPS1 + sum2SPS2
+print(sum2SPS1,sum2SPS2,sumall)
+imya = input('Введите имя текстового файла для вывода результатов: ')
+fc = open(imya,'w')
+for i in range(len(SPS1_new)):
+    line = ' '.join(str(j) for j in SPS1_new[i:i+3])
+    fc.write(line + '\n')
+for i in range(len(SPS2)):
+    line = ' '.join(str(j) for j in SPS1_new[i:i+3])
+    fc.write(line + '\n')
+fc.close()

TEMA6/report.md

@@ -0,0 +1,367 @@
+# Отчет по теме 6
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA6")
+```
+
+## 2. Вывод данных.
+
+## 2.1 Вывод в командной строке.
+
+```py
+stroka='Автоматизированная система управления'
+stroka
+'Автоматизированная система управления'
+```
+
+## 2.2 Вывод с помощью print.
+
+```py
+fff=234.5;gg='Значение температуры = '
+print(gg,fff)
+Значение температуры =  234.5
+print(gg,fff,sep='/')
+Значение температуры = /234.5
+print(gg,fff,sep='/',end='***');print('___')
+Значение температуры = /234.5***___
+print()
+
+print(""" Здесь может выводиться
+большой текст,
+занимающий несколько строк""")
+ Здесь может выводиться
+большой текст,
+занимающий несколько строк
+print("Здесь может выводиться",
+      "большой текст,",
+      "занимающий несколько строк")
+Здесь может выводиться большой текст, занимающий несколько строк
+```
+
+## 2.3 Вывод с использованием write.
+
+```py
+import sys
+sys.stdout.write('Функция write')
+Функция write13
+sys.stdout.write('Функция write\n')
+Функция write
+14
+```
+
+## 3. Ввод данных с клавиатуры.
+
+```py
+psw=input('Введите пароль:')
+Введите пароль:123
+psw
+'123'
+type(psw)
+<class 'str'>
+while True:
+    znach = float(input('Задайте коэф.усиления = '))
+    if znach < 17.5 or znach > 23.8:
+        print('Ошибка!')
+    else:
+        break
+Задайте коэф.усиления = 15.4
+Ошибка!
+Задайте коэф.усиления = 21.6
+import math
+print(eval(input('введите выражение для расчета = ')))
+введите выражение для расчета = math.log10(23/(1+math.exp(-3.24)))
+1.34504378689765
+```
+
+## 4. Ввод-вывод при работе с файлами.
+
+## 4.1 Путь к файлу.
+
+```py
+import os
+os.getcwd()
+'C:\\Users\\Home\\Desktop\\python-labs\\TEMA6'
+Lykova = os.getcwd()
+print(Lykova)
+C:\Users\Home\Desktop\python-labs\TEMA6
+os.mkdir('C:\\Users\\Home\\Desktop\\python-labs\\newdir') #Создает новую директорию.
+os.rmdir('C:\\Users\\Home\\Desktop\\python-labs\\newdir') #Удаляет директорию.
+os.listdir('C:\\Users\\Home\\Desktop\\python-labs')
+['.git', '.gitignore', 'README.md', 'TEMA0', 'TEMA1', 'TEMA2', 'TEMA3', 'TEMA4', 'TEMA5', 'TEMA6', 'TEMA7', 'TEMA8', 'TEMA9']
+os.path.isdir('C:\\Users\\Home\\Desktop\\python-labs') #Проверяет, является ли указанный
+True
+fil = os.path.abspath('OPLATA.dbf')
+fil
+'C:\\Users\\Home\\Desktop\\python-labs\\TEMA6\\OPLATA.dbf'
+drkt = os.path.dirname(fil)
+drkt
+'C:\\Users\\Home\\Desktop\\python-labs\\TEMA6'
+os.path.basename(fil)
+'OPLATA.dbf'
+os.path.split(fil)
+('C:\\Users\\Home\\Desktop\\python-labs\\TEMA6', 'OPLATA.dbf') #Функция отдельно выводит путь к файлу и его наименование.
+os.path.exists(fil)
+True
+fil2 = os.path.abspath('neoplata.dbf')
+os.path.exists(fil2)
+False
+os.path.isfile(fil)
+True
+os.path.isfile(os.path.dirname(fil)+'fil1.txt')
+False
+```
+
+## 4.2 Общая схема работы с файлом.
+
+## 4.3 Функция open.
+
+```py
+help(open)
+Help on built-in function open in module _io:
+
+open(
+    file,
+    mode='r',
+    buffering=-1,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=True,
+    opener=None
+)
+    ...
+
+    ========= ===============================================================
+    Character Meaning
+    --------- ---------------------------------------------------------------
+    'r'       open for reading (default)
+    'w'       open for writing, truncating the file first
+    'x'       create a new file and open it for writing
+    'a'       open for writing, appending to the end of the file if it exists
+    'b'       binary mode
+    't'       text mode (default)
+    '+'       open a disk file for updating (reading and writing)
+    ========= ===============================================================
+
+    The default mode is 'rt' (open for reading text). For binary random
+    access, the mode 'w+b' opens and truncates the file to 0 bytes, while
+    'r+b' opens the file without truncation. The 'x' mode implies 'w' and
+    raises an `FileExistsError` if the file already exists.
+
+    ...
+
+    * On input, if newline is None, universal newlines mode is
+      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
+      these are translated into '\n' before being returned to the
+      caller. If it is '', universal newline mode is enabled, but line
+      endings are returned to the caller untranslated. If it has any of
+      the other legal values, input lines are only terminated by the given
+      string, and the line ending is returned to the caller untranslated.
+
+    * On output, if newline is None, any '\n' characters written are
+      translated to the system default line separator, os.linesep. If
+      newline is '' or '\n', no translation takes place. If newline is any
+      of the other legal values, any '\n' characters written are translated
+      to the given string.
+
+   ...
+
+    open() returns a file object whose type depends on the mode, and
+    through which the standard file operations such as reading and writing
+    are performed. When open() is used to open a file in a text mode ('w',
+    'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
+    a file in a binary mode, the returned class varies: in read binary
+    mode, it returns a BufferedReader; in write binary and append binary
+    modes, it returns a BufferedWriter, and in read/write mode, it returns
+    a BufferedRandom.
+
+    It is also possible to use a string or bytearray as a file for both
+    reading and writing. For strings StringIO can be used like a file
+    opened in a text mode, and for bytes a BytesIO can be used like a file
+    opened in a binary mode.
+fp=open(file=drkt+'\\zapis1.txt',mode='w')
+                                                          
+fp=open(drkt+'\\zapis1.txt','w')
+                                                          
+fp=open('zapis1.txt','w')
+                                                          
+type(fp)
+                                                          
+<class '_io.TextIOWrapper'>
+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']
+```
+
+## 4.4 Закрытие файла.
+
+```py
+fp.close()
+```
+
+## 4.5 Запись в файл с помощью write.
+
+```py
+sps=list(range(1,13))
+fp2=open('zapis3.txt','w')
+fp2.write(str(sps[:4])+'\n')
+13
+fp2.write(str(sps[4:8])+'\n')
+13
+fp2.write(str(sps[8:])+'\n')
+16
+fp2.close()
+```
+
+[Созданный файл](zapis3.txt)
+
+```py
+sps3=[['Иванов И.',1],['Петров П.',2],['Сидоров С.',3]]
+fp3=open('zapis4.txt','w')
+for i in range(len(sps3)):
+    stroka4=sps3[i][0]+' '+str(sps3[i][1])
+    fp3.write(stroka4)
+
+fp3.close()
+```
+
+[Созданный файл](zapis4.txt)
+
+```py
+gh=open('zapis5.txt','w')
+for r in sps3:
+    gh.write(f'{r[0]} {str(r[1])}\n')
+ 
+gh.close()
+```
+
+[Созданный файл](zapis5.txt)
+
+## 4.6 Первый способ чтения информации из текстового файла.
+
+```py
+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]
+spsnew = [int(i.strip()) for i in sps1]
+spsnew
+[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()
+
+print(stroka1)
+[1, 2, 3, 4]
+print(stroka2)
+
+[5, 6, 7, 8]
+[9, 10, 11, 12]
+```
+
+## 4.8 Методы readline и readlines.
+
+```py
+fp = open('zapis3.txt')
+r = fp.readline()
+rr = fp.readline()
+print(r)
+[1, 2, 3, 4]
+print(rr)
+[5, 6, 7, 8]
+fp.close()
+fp = open('zapis3.txt')
+rrr = fp.readlines()
+print(rrr)
+['[1, 2, 3, 4]\n', '[5, 6, 7, 8]\n', '[9, 10, 11, 12]\n']
+fp.close()
+```
+
+## 4.9 Функции модуля pickle.
+
+```py
+import pickle
+mnoz1={'pen','book','pen','iPhone','table','book'}
+fp = open('zapis6.mnz','wb')
+pickle.dump(mnoz1,fp)
+fp.close()
+```
+
+![белиберда](ris1.png)
+
+```py
+fp=open('zapis6.mnz','rb')
+mnoz2=pickle.load(fp)
+fp.close()
+mnoz2
+{'book', 'iPhone', 'pen', 'table'}
+mnoz1 == mnoz2
+True
+```
+
+Результат ввода mnoz1 и вывода mnoz2 различаются, потому что множество не имеет порядка элементов и их повторений.
+
+```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()
+print(obj1,obj2)
+{'book', 'iPhone', 'pen', 'table'} [['Иванов И.', 1], ['Петров П.', 2], ['Сидоров С.', 3]]
+```
+
+## 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
+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
+```

TEMA6/task.md

@@ -0,0 +1,63 @@
+# Общее контрольное задание по теме 6
+
+Лыкова Елизавета, А-01-23
+
+# Задание
+
+Придумайте инструкции и запишите их в файл с расширением .py , которые выполняют следующие операции:
+
+• Создаётся объект-кортеж со 125 целыми случайными числами из диапазона от 6 до 56, представленными в виде символьных строк.
+
+• Создаётся объект-список с вашей фамилией и 4 фамилиями ваших одноклассников.
+
+• Записывается кортеж в бинарный файл.
+
+• Записывается в этот же файл список и закрывается файл.
+
+• Открывается этот файл для чтения и считывает из него данные в 2 новых объекта.
+
+• Проверяется на совпадение новых объектов с исходными и выводится соответствующее сообщение.
+
+• Разделяется кортеж на совокупности по 5 чисел в каждой и они записываются в виде отдельных списков со своими именами.
+
+# Решение
+
+```py
+import random
+kort = tuple(str(random.randint(6,56)) for _ in range(125))
+kort
+('32', '39', '38', '16', '25', '38', '38', '13', '49', '25', '10', '22', '16', '30', '50', '30', '53', '8', '39', '53', '47', '41', '52', '12', '27', '14', '24', '12', '46', '29', '53', '48', '42', '8', '54', '27', '30', '56', '22', '10', '14', '8', '20', '48', '51', '13', '41', '21', '9', '9', '8', '6', '54', '16', '29', '42', '24', '39', '17', '27', '31', '10', '37', '7', '51', '27', '9', '28', '49', '52', '48', '28', '9', '44', '31', '24', '28', '25', '12', '27', '42', '53', '46', '48', '15', '53', '33', '25', '25', '25', '37', '8', '7', '31', '31', '38', '6', '11', '47', '16', '9', '29', '51', '42', '23', '18', '17', '24', '18', '7', '18', '10', '15', '7', '47', '39', '55', '12', '14', '53', '38', '35', '52', '10', '56')
+spis = ['Lykova','Solovyova','Kovalenko','Podolsky','Melnikov']
+fp = open('bin.mnz','wb')
+import pickle
+pickle.dump(kort,fp)
+pickle.dump(spis,fp)
+fp.close()
+fp = open('bin.mnz','rb')
+obj1 = pickle.load(fp)
+obj2 = pickle.load(fp)
+obj1
+('32', '39', '38', '16', '25', '38', '38', '13', '49', '25', '10', '22', '16', '30', '50', '30', '53', '8', '39', '53', '47', '41', '52', '12', '27', '14', '24', '12', '46', '29', '53', '48', '42', '8', '54', '27', '30', '56', '22', '10', '14', '8', '20', '48', '51', '13', '41', '21', '9', '9', '8', '6', '54', '16', '29', '42', '24', '39', '17', '27', '31', '10', '37', '7', '51', '27', '9', '28', '49', '52', '48', '28', '9', '44', '31', '24', '28', '25', '12', '27', '42', '53', '46', '48', '15', '53', '33', '25', '25', '25', '37', '8', '7', '31', '31', '38', '6', '11', '47', '16', '9', '29', '51', '42', '23', '18', '17', '24', '18', '7', '18', '10', '15', '7', '47', '39', '55', '12', '14', '53', '38', '35', '52', '10', '56')
+obj2
+['Lykova', 'Solovyova', 'Kovalenko', 'Podolsky', 'Melnikov']
+if obj1 == kort:
+    print('Объекты совпадают')
+else: print('Объекты не совпадают')
+
+Объекты совпадают
+if obj2 == spis:
+    print('Объекты совпадают')
+else: print('Объекты не совпадают')
+
+Объекты совпадают
+for i in range(0,125,5):
+    exec('list' + str(i//5+1) + ' = ' + str(list(obj1[i:i+5])))
+
+    
+list1
+['32', '39', '38', '16', '25']
+list2
+['38', '38', '13', '49', '25']
+list3
+['10', '22', '16', '30', '50']
+```

TEMA6/tekstovy.txt

@@ -0,0 +1,8 @@
+-0.25,-0.2
+-0.15,-0.1
+-0.05,0.0
+0.05,0.1
+0.15,0.2
+0.25,0.3
+0.35,0.4
+0.45,0.5

TEMA6/test.md

@@ -0,0 +1,49 @@
+# Тест 2 Вариант 20
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+1) Создайте кортеж с элементами - числами: -0.25, -0.20, -0.15,:,0.45,0.50.
+
+2) Запишите элементы кортежа в текстовый файл по два элемента на строке с разделителем "," (запятая).
+
+3) Удалите кортеж из памяти.
+
+4) Прочитайте из созданного файла 7 первых элементов и сформируйте из них множество.
+
+5) Создайте из множества два списка: первый - с первыми 3 элементами и второй - с остальными 4 элементами.
+
+
+
+## Решение
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA6")
+kort = (-0.25, -0.20, -0.15, -0.10, -0.05, 0.00, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50)
+fc = open('tekstovy.txt', 'w')
+for i in range(0, len(kort), 2):
+    if i + 1 < len(kort):
+        fc.write(f'{kort[i]},{kort[i+1]}\n')
+
+fc.close()
+del kort
+fc = open('tekstovy.txt')
+mnoz = set()
+for line in fc:
+    numb = line.strip().split(',')
+    for i in numb:
+        if len(mnoz) < 7:
+            mnoz.add(float(i))
+        else:
+            break
+        if len(mnoz) >= 7:
+            break
+            
+fc.close()
+print(mnoz)
+spis1 = (list(mnoz))[:3]
+spis2 = (list(mnoz))[3:]
+print(spis1,spis2)
+```

TEMA6/zadan.py

@@ -0,0 +1,29 @@
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA6")
+kort = (-0.25, -0.20, -0.15, -0.10, -0.05, 0.00, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50)
+fc = open('tekstovy.txt', 'w')
+for i in range(0, len(kort), 2):
+    if i + 1 < len(kort):
+        fc.write(f'{kort[i]},{kort[i+1]}\n')
+
+fc.close()
+del kort
+fc = open('tekstovy.txt')
+mnoz = set()
+for line in fc:
+    numb = line.strip().split(',')
+    for i in numb:
+        if len(mnoz) < 7:
+            mnoz.add(float(i))
+        else:
+            break
+        if len(mnoz) >= 7:
+            break
+            
+fc.close()
+print(mnoz)
+spis1 = (list(mnoz))[:3]
+spis2 = (list(mnoz))[3:]
+print(spis1,spis2)
+print(type(spis1))
+

TEMA6/zapis3.txt

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

TEMA6/zapis4.txt

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

TEMA6/zapis5.txt

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

TEMA7/report.md

@@ -0,0 +1,528 @@
+# Отчет по теме 7
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA7")
+```
+
+## 2. Создание пользовательской функции.
+
+## 2. 1 Функция без аругментов.
+
+```py
+def uspeh():
+    '''Подтверждение успеха операции'''
+    print('Выполнено успешно!')
+
+    
+type(uspeh)
+<class 'function'>
+dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os', 'uspeh']
+help(uspeh)
+Help on function uspeh in module __main__:
+
+uspeh()
+    Подтверждение успеха операции
+```
+
+## 2.2 Функция с аргументами.
+
+```py
+def sravnenie(a,b):
+    '''Сравнение a и b'''
+    if a > b:
+        print(a, 'больше', b)
+    elif a < b:
+        print(a, 'меньше',b)
+    else:
+        print(a,'равно',b)
+
+        
+n,m = 16,5; sravnenie(n,m)
+16 больше 5
+sravnenie('a','b')
+a меньше b
+```
+
+## 2.3 Функция с return.
+
+```py
+def logistfun(b,a):
+    '''Вычисление логистической функции'''
+    import math
+    return a/(1+math.exp(-b))
+
+v,w = 1, 0.7; z = logistfun(w,v)
+z
+0.6681877721681662
+```
+
+## 2.4. Сложение для разных типов аргументов.
+
+```py
+def slozh(a1,a2,a3,a4):
+    '''Сложение значений четырех аргументов'''
+    return a1 + a2 + a3 + a4
+
+slozh(1,2,3,4)
+10
+slozh('1','2','3','4')
+'1234'
+b1 = [1,2]; b2 = [-1,-1]; b3= [0,2]; b4 = [-1,-1]
+q = slozh(b1,b2,b3,b4)
+q
+[1, 2, -1, -1, 0, 2, -1, -1]
+k1 = (0, 1); k2 = (2,3); k3 = (4,5); k4 = (6,7)
+qk = slozh(k1,k2,k3,k4)
+qk
+(0, 1, 2, 3, 4, 5, 6, 7)
+s1 = {'aaa':1,'bbb':2}; s2 = {'ccc':3,'ddd':4}; s3 = {'eee':5,'fff':6}; s4 = {'ggg':7,'hhh':8}
+qs = slozh(s1,s2,s3,s4)
+Traceback (most recent call last):
+  File "<pyshell#47>", line 1, in <module>
+    qs = slozh(s1,s2,s3,s4)
+  File "<pyshell#37>", line 3, in slozh
+    return a1 + a2 + a3 + a4
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+m1 = {'a','b'}; m2 = {'c','d'}; m3 = {'e','f'}; m4 = {'g','h'}
+qm = slozh(m1,m2,m3,m4)
+Traceback (most recent call last):
+  File "<pyshell#50>", line 1, in <module>
+    qm = slozh(m1,m2,m3,m4)
+  File "<pyshell#37>", line 3, in slozh
+    return a1 + a2 + a3 + a4
+TypeError: unsupported operand type(s) for +: 'set' and 'set'
+```
+
+## 2.5 На вход функции поступает сигнал x, а на выходе получает сигнал y.
+
+```py
+def inerz(x,T,ypred):
+    ''' Модель устройства с памятью:
+    x- текущее значение вх.сигнала,
+    T -постоянная времени,
+    ypred - предыдущее значение выхода устройства'''
+    y = (x + T*ypred)/(T+1)
+    return y
+
+sps = [0]+[1]*100
+spsy=[]
+TT = 20
+yy = 0
+for xx in sps:
+    yy = inerz(xx,TT,yy)
+    spsy.append(yy)
+
+
+import pylab as plt
+plt.plot(spsy,label = 'Выходной сигнал')
+[<matplotlib.lines.Line2D object at 0x000001D2BEDF2AD0>]
+plt.show()
+```
+
+![рисуночек](ris1.png)
+
+## 3. Функции как объекты.
+
+## 3.1 Получение списка атрибутов объекта-функции.
+
+```py
+dir(inerz)
+['__annotations__', '__builtins__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__getstate__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__type_params__']
+inerz.__doc__
+'Модель устройства с памятью:\nx- текущее значение вх.сигнала,\nT -постоянная времени,\nypred - предыдущее значение выхода устройства'
+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
+```
+
+Программа выводит сообщение "Функция 2", потому что переменная typ_fun не равна 1, и выполняется блок else, в котором функция func определена как выводящая "Функция 2".
+
+## 4. Аргументы функции.
+
+## 4.1 Функция в качестве аргумента другой функции.
+
+```py
+def fun_arg(fff,a,b,c):
+    '''fff-имя функции, используемой 
+    в качестве аргумента функции fun_arg'''
+    return a + fff(c,b)
+
+zz = fun_arg(logistfun,-3,1,0.7)
+zz
+-2.3318122278318336
+```
+
+## 4.2 Обязательные и необязательные аргументы.
+
+```py
+def logistfun(a,b=1):
+    '''Вычисление логистической функции'''
+    import math
+    return b/(1+math.exp(-a))
+
+logistfun(0.7)
+0.6681877721681662
+logistfun(0.7,2)
+1.3363755443363323
+```
+
+## 4.3 Функция с произвольным положением элементов.
+
+```py
+logistfun(b = 0.5, a = 0.8)
+0.34498724056380625
+```
+
+## 4.4 Аргументы функции, содержащиеся в списке или кортеже.
+
+```py
+b1234 = [b1,b2,b3,b4]
+qq = slozh(*b1234)
+qq
+[1, 2, -1, -1, 0, 2, -1, -1]
+```
+
+## 4.5 Аргументы функции, содержащиеся в словаре.
+
+```py
+dic4={"a1":1,"a2":2,"a3":3,"a4":4}
+qqq = slozh(**dic4)
+qqq
+10
+```
+
+## 4.6 Смешанные ссылки.
+
+```py
+e1=(-1,6);dd2={'a3':3,'a4':9}
+qqqq=slozh(*e1,**dd2)
+qqqq
+17
+```
+
+## 4.7 Переменное число аргументов у функции.
+
+```py
+def func4(*kort7):
+    '''Произвольное число аргументов в составе кортежа'''
+    smm = 0
+    for elt in kort7:
+        smm += elt
+    return smm
+
+func4(-1,2)
+1
+func4(-1,2,0,3,6)
+10
+```
+
+## 4.8 Комбинация аргументов.
+
+```py
+def func4(a,b=7,*kort7):
+    '''Кортеж - сборка аргументов - должен быть последним!'''
+    smm = 0
+    for elt in kort7:
+        smm += elt
+    return a*smm + b
+
+func4(-1,2,0,3,6)
+-7
+def func4(a,b=7,**dicc):
+    '''Словарь - сборка аргументов - должен быть последним!'''
+    smm = 0
+    smm = sum(dicc.values())
+    return a*smm + b
+
+func4(-1,2,x=3,y=4,z=5)
+-10
+```
+
+## 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)
+print(sps1)
+[1, 99, 3, 4]
+kort = (1,2,3,4)
+func2(kort)
+Traceback (most recent call last):
+  File "<pyshell#4>", line 1, in <module>
+    func2(kort)
+  File "<pyshell#2>", line 2, in func2
+    sps[1] = 99
+TypeError: 'tuple' object does not support item assignment
+```
+
+## 5. Специальные типы пользовательских функций.
+
+## 5.1 Анонимные функции.
+
+```py
+anfun1 = lambda: 1.5 + math.log10(17.23)
+anfun1()
+2.7362852774480286
+anfun2 = lambda a,b: a+math.log10(b)
+anfun2(17,234)
+19.369215857410143
+anfun3 = lambda a,b = 234: a+math.log10(b)
+anfun3(100)
+102.36921585741014
+```
+
+## 5.2 Функции генераторы.
+
+```py
+def func5(diap,shag):
+    '''Итератор, возвращающий значения
+    из диапазона от 1 до diap с шагом shag'''
+    for j in range(1,diap+1,shag):
+        yield j
+
+        
+for mm in func5(7,3):
+    print(mm)
+
+    
+1
+4
+7
+
+alp=func5(7,3)
+print(alp.__next__())
+1
+print(alp.__next__())
+4
+print(alp.__next__())
+7
+print(alp.__next__())
+Traceback (most recent call last):
+  File "<pyshell#12>", line 1, in <module>
+    print(alp.__next__())
+StopIteration
+```
+
+Функции - генераторы генерируют значения по одному, не храня всё в памяти.
+Генератор можно использовать только один раз - после прохождения всех значений он "опустошается" и больше не производит элементов.
+
+## 6. Локализация объектов в функциях.
+
+## 6.1 Локализация объектов.
+
+```py
+glb = 10
+def func7(arg):
+    locl = 15
+    glb = 8
+    return locl*arg
+
+res = func7(glb)
+res
+150
+glb
+10
+```
+
+Глобальное значение glb не изменилось.
+
+```py
+def func8(arg):
+    locl=15
+    print(glb)
+    glb=8
+    return locl*arg
+
+res = func8(glb)
+Traceback (most recent call last):
+  File "<pyshell#30>", line 1, in <module>
+    res = func8(glb)
+  File "<pyshell#29>", line 3, in func8
+    print(glb)
+UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value
+```
+
+Локальная переменная была инициализирована только после той строки, где функция её выводит.
+
+```py
+glb = 11
+def func7(arg):
+    locl = 15
+    global glb
+    print(glb)
+    glb = 8
+    return locl*arg
+
+res = func7(glb)
+11
+glb
+8
+```
+
+## 6.2 Выявление локализации объекта.
+
+```py
+globals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+locals().keys()
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+```
+
+Различий нет, поскольку эти методы возвращают обхекты на уровне вызова этиъ функций.
+
+```py
+def func8(arg):
+    locl = 15
+    glb = 8
+    print(globals().keys())
+    print(locals().keys())
+    return locl*arg
+
+hh = func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'locl', 'glb'])
+def func8(arg):
+    locl = 15
+    glb = 8
+    print(globals().keys())
+    print(locals().keys())
+    return locl*arg
+
+hh = func8(glb)
+dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8'])
+dict_keys(['arg', 'locl', 'glb'])
+'glb' in globals().keys()
+True
+```
+
+## 6.3 Локализация при использовании вложенных функций.
+
+```py
+def func9(arg2,arg3):
+    def func9_1(arg1):
+        locl = 15
+        glbl = 8
+        print('glob_func9_1:',globals().keys())
+        print('locl_func9_1:',locals().keys())
+        return locl*arg1
+    locl = 5
+    glb = func9_1(locl)
+    print('loc_func9:',locals().keys())
+    print('glob_func9:',globals().keys())
+    return arg2+arg3*glb
+
+kk = func9(10,1)
+glob_func9_1: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9', 'locl'])
+locl_func9_1: dict_keys(['arg1', 'locl', 'glbl'])
+loc_func9: dict_keys(['arg2', 'arg3', 'func9_1', 'locl', 'glb'])
+glob_func9: dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__annotations__', '__builtins__', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9', 'locl'])
+```
+
+## 6.4 
+
+```py
+znach = input('k1,T,k2,Xm,A,F,N=').split(',')
+k1,T,k2,Xm,A,F,N=4,2,8,6,9,0.5,1000
+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)) 
+
+vhod
+[0.0, -9.797174393178826e-16, -1.959434878635765e-15, -2.9391523179536475e-15, -3.91886975727153e-15, -4.898587196589413e-15, -5.878304635907295e-15, -6.858022075225178e-15, -7.83773951454306e-15, -8.817456953860943e-15, -9.797174393178826e-15, -3.919860126290071e-14, -1.175660927181459e-14, 1.5685382719271533e-14, -1.3716044150450356e-14, -4.3117471020172244e-14, -1.567547902908612e-14, 1.1766512962000004e-14, -1.7634913907721887e-14, ...]
+```
+
+Создание функций, реализующих компоненты системы.
+
+```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, 0, 0, -1.0183086292055208, 0, 26.39885775889784, -36.65029553691161, -34.19982663883278, 196.29963397615063, -151.6919482160481, -388.32493988337274, 1057.8073200868555, -308.3186572590445, -2798.051869998873, 5004.749701095182, 1362.331454336744, ...] 
+```

TEMA7/task.md

@@ -0,0 +1,83 @@
+# Общее контрольное задание по теме 7
+
+Лыкова Елизавета, А-01-23
+
+# Задание:
+
+1. Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с задержкой на заданное время Т.
+
+2. Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: выборка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения.
+
+3. Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y линейной регрессии при значении переменной Х Y=b1+b2*X и имеющую аргументы b1, b2 и X.
+
+# Решение
+
+## 1
+
+```py
+def del_signal (signal, T):
+    '''Расчет выхода y(t) для устройства задержки'''
+    output = []
+    for i in range(len(signal)):
+        if i<T:
+            output.append(0)
+        else:
+            output.append(signal[i-T])
+    return output
+
+x = [2,4.6,5.7,1.3,4,2,1.5]
+y = del_signal(x,2)
+y
+[0, 0, 2, 4.6, 5.7, 1.3, 4]
+```
+
+## 2
+
+```py
+import random
+import matplotlib.pyplot as plt
+def hist (vybork,num):
+    min1 = min(vybork)
+    max1 = max(vybork)
+    bins = (max1-min1)/num
+    rows = [0]*num
+    intervals = []
+    for i in range(num):
+        low = min1 + i * bins
+        up = min1 + (i+1) * bins
+        intervals.append((low,up))
+    for x in vybork:
+        i = int((x-min1)/bins)
+        if i == num:
+            i = num - 1
+        rows [i] += 1
+    print('Границы интервала , число элементов')
+    for i in range(num):
+        low,up = intervals[i]
+        print(low,'-',up,',',rows[i])
+    plt.hist(vybork,num)
+    plt.xlabel('Значения выборки')
+    plt.ylabel('Число элементов')
+    plt.title('Гистограмма выборки')
+    plt.show()
+    return rows
+
+data = [random.gauss(1,20) for _ in range(10)]
+hist (data,3)
+Границы интервала , число элементов
+-31.822113509256198 - -11.236815307313815 , 1
+-11.236815307313815 - 9.348482894628567 , 2
+9.348482894628567 - 29.933781096570954 , 7
+[1, 2, 7]
+```
+
+![рисуночек](ris2.png)
+
+## 3
+
+```py
+lin_regression = lambda b1,b2,x: b1+b2*x
+res = lin_regression(2,3,5)
+res
+17
+```

TEMA7/test.md

@@ -0,0 +1,34 @@
+# Индивидуальное контрольное задание по теме 7
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+Разработайте анонимную функцию, вычисляющую значение $a*sin(x)+b*cos(x+T)$ с параметрами х, a, b, T. Рассчитайте значения функции в диапазоне значений х от -4  до 5  с шагом 0.2 при a=2, b=-6, T=1.5 и запишите эти значения в текстовый файл по одному на строке. Пред-ставьте эти значения на графике.
+
+## Решение 
+
+```py
+import os
+os.chdir('C:\\Users\\Home\\Desktop\\python-labs\\TEMA7')
+import numpy as np
+import mat
+import matplotlib.pyplot as plt
+anonym = lambda x,a,b,T: a*np.sin(x) + b*np.cos(x+T)
+a,b,T = 2,-6,1.5
+x = np.arange(-4,5+0.2,0.2)
+yval = anonym(x,a,b,T)
+fl = open('znach.txt','w')
+for y in yval:
+    fl.write(f'{y}\n')
+fl.close()
+plt.plot(x, yval, 'b-')
+plt.grid(True)
+plt.xlabel('x')
+plt.ylabel('f(x)')
+plt.title(f'f(x) = {a}*sin(x) + {b}*cos(x + {T})')
+plt.show()
+plt.savefig('plot.png')
+```
+
+![график](plot.png)

TEMA7/znach.txt

@@ -0,0 +1,46 @@
+6.320466683897459
+5.221371909564382
+3.914117514188847
+2.450819605234679
+0.8898152526283022
+-0.7066632261259589
+-2.2749692720593426
+-3.752579472196401
+-5.080586170726297
+-6.206045931346119
+-7.084090224993606
+-7.679714196510031
+-7.969172197751167
+-7.940924451645072
+-7.596097106688083
+-6.9484373409580185
+-6.023765305505962
+-4.858944756414038
+-3.500413413170742
+-2.002331633337621
+-0.4244232100061891
+1.1704056273633001
+2.718574085798351
+4.158361574389244
+5.432368309478015
+6.489803662897416
+7.2885110240368345
+7.796648450874471
+7.993958107722688
+7.872573881209572
+7.437334977396125
+6.705592997901605
+5.70652018630311
+4.479946422842502
+3.0747713327916175
+1.5470148127043637
+-0.042416306077866534
+-1.6301564205891665
+-3.1529073428676377
+-4.5499617989604495
+-5.765623636363456
+-6.751428253862162
+-7.468074732243268
+-7.886992637922448
+-7.9914810359721695
+-7.777374303694405

TEMA8/MM0.py

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

TEMA8/MM1.py

@@ -0,0 +1,19 @@
+def realdvig(xtt,kk1,TT,yti1,ytin1):
+    yp=kk1*xtt  #усилитель
+    yti1=yp+yti1  #Интегратор
+    ytin1=(yti1+TT*ytin1)/(TT+1)
+    return [yti1,ytin1]
+ 	    
+def tahogen(xtt,kk2,yti2):
+    yp=kk2*xtt   
+    yti2=yp+yti2 
+    return yti2
+	    
+def nechus(xtt,gran):
+    if xtt<gran and xtt>(-gran):
+        ytt=0
+    elif xtt>=gran:
+        ytt=xtt-gran
+    elif xtt<=(-gran):
+        ytt=xtt+gran
+    return ytt

TEMA8/MM2.py

@@ -0,0 +1,23 @@
+znach=input('k1,T,k2,Xm,A,F,N=').split(',')
+k1=float(znach[0])
+T=float(znach[1])
+k2=float(znach[2])
+Xm=float(znach[3])
+A=float(znach[4])
+F=float(znach[5])
+N=int(znach[6])
+
+import math
+vhod=[]
+for i in range(N):
+    vhod.append(A*math.sin((2*i*math.pi)/F))
+
+import MM1 as mod
+yi1=0;yin1=0;yi2=0
+vyhod=[]
+for xt in vhod:
+    xt1=xt-yi2   #отрицательная обратная связь
+    [yi1,yin1]=mod.realdvig(xt1,k1,T,yi1,yin1)
+    yi2=mod.tahogen(yin1,k2,yi2)
+    yt=mod.nechus(yin1,Xm)
+    vyhod.append(yt)

TEMA8/Mod0.py

@@ -1,9 +1,12 @@
 #Модуль Mod0
 import Mod1
 print('perm1=',Mod1.perm1)
+Mod1.perm1 = str(int(Mod1.perm1)*3)
+print('Увеличение perm1 в 3 раза:', Mod1.perm1)
 from Mod2 import alpha as al
 tt=al()
 print('tt=',tt)
 from Mod2 import beta
 qq=beta(float(tt))
 print('qq=',qq)
+

TEMA8/Mod2.py

@@ -7,5 +7,6 @@ def beta(q):
     print('****BETA****')
     import math
     expi=q*math.pi
+    alpha()
     return math.exp(expi)
     

TEMA8/Modul1.py

@@ -0,0 +1,7 @@
+def read (file):
+    '''Чтение данных из файла'''
+    num = []
+    with open(file,'r') as file:
+        for line in file:
+            num.extend(map(float,line.split()))
+        return num

TEMA8/Modul2.py

@@ -0,0 +1,16 @@
+def correl (list1,list2):
+    '''Расчет коэффициента корреляции'''
+    n = min(len(list1),len(list2))
+    list1 = list1[:n]
+    list2 = list2[:n]
+    mean1 = sum(list1)/n
+    mean2 = sum(list2)/n
+    chis = sum((list1[i]-mean1)*(list2[i]-mean2)for i in range(n))
+    znam1 = sum((x-mean1)**2 for x in list1)
+    znam2 = sum((y-mean2)**2 for y in list1)
+    
+    if znam1 == 0 or znam2 == 0:
+        return 0
+
+    return chis/(znam1*znam2)**0.5
+    

TEMA8/Modul3.py

@@ -0,0 +1,8 @@
+import Modul1
+import Modul2
+file1 = input('Введите имя первого файла:')
+file2 = input('Введите имя второго файла:')
+list1 = Modul1.read(file1)
+list2 = Modul1.read(file2)
+corr = Modul2.correl(list1,list2)
+print(f'Коэффициент корреляции: {corr:.3f}')

TEMA8/data1.txt

@@ -0,0 +1,4 @@
+1 2 3
+4 5
+6 7 8
+9

TEMA8/data2.txt

@@ -0,0 +1,3 @@
+2 4 6
+8
+10 11

TEMA8/main.py

@@ -0,0 +1,27 @@
+import slovar
+
+# Пример 1
+
+keys1 = ['A','B','C']
+values1 = [16,7,890]
+
+print(f'Пример 1')
+print(f'Ключи: {keys1}')
+print(f'Значения: {values1}')
+
+result1 = slovar.dictionary(keys1,values1)
+
+print(f'Созданный словарь: {result1}')
+
+# Пример 2
+
+keys2 = ['d','b','x','s']
+values2 = [10.7,-4,5,63]
+
+print(f'Пример 2')
+print(f'Ключи: {keys2}')
+print(f'Значения: {values2}')
+
+result2 = slovar.dictionary(keys2,values2)
+
+print(f'Созданный словарь: {result2}')

TEMA8/report.md

@@ -0,0 +1,376 @@
+# Отчет по теме 8
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os,sys,importlib
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA8")
+os.getcwd()
+'C:\\Users\\Home\\Desktop\\python-labs\\TEMA8'
+```
+
+## 2. Создание и использование модулей.
+
+## 2.1 Запуск модуля на выполнение путем его импорта.
+
+```py
+perm1 = input('Mod1: Введите значение =')
+print('Mod1: Значение perm1 =', perm1)
+import Mod1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+type(Mod1)
+<class 'module'>
+dir(Mod1)
+['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'perm1']
+Mod1.perm1
+'5'
+import Mod1
+importlib.reload(Mod1)
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+<module 'Mod1' from 'C:\\Users\\Home\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+Mod1.perm1
+'3'
+```
+
+## 2.2 Импортированные модули в словаре.
+
+```py
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Home\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+print(sorted(sys.modules.keys()))
+['__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+```
+
+## 2.3 Функция exec.
+
+```py
+exec(open('Mod1.py').read())
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1
+'5'
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1
+'3'
+exec(open('Mod1.py', encoding='utf-8').read())
+Mod1:Введите значение = 1
+Mod1:Значение perm1= 1
+perm1
+'1'
+```
+
+## 2.4 Инструкции from ... import ...
+
+Пример 1
+
+```py
+from Mod1 import perm1
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+print(sorted(sys.modules.keys()))
+['Mod1', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+perm1
+'5'
+```
+
+Пример 2
+
+```py
+С помощью текстового редактора создадим ещё один модуль Mod2, содержащий две функции:
+
+def alpha():
+		print('****ALPHA****')
+		t=input('Значение t=')
+		return t
+
+def beta(q):
+		import math
+		expi=q*math.pi
+		return math.exp(expi)
+
+from Mod2 import beta
+g = beta(2)
+****BETA****
+g
+535.4916555247646
+print(sorted(sys.modules.keys()))
+['Mod1', 'Mod2', '__future__', '__main__', '_abc', '_ast', '_bisect', '_bz2', '_codecs', '_collections', '_collections_abc', '_colorize', '_compat_pickle', '_compression', '_datetime', '_frozen_importlib', '_frozen_importlib_external', '_functools', '_heapq', '_imp', '_io', '_lzma', '_opcode', '_opcode_metadata', '_operator', '_pickle', '_pyrepl', '_pyrepl.pager', '_queue', '_random', '_signal', '_sitebuiltins', '_socket', '_sre', '_stat', '_string', '_struct', '_sysconfig', '_thread', '_tkinter', '_tokenize', '_typing', '_warnings', '_weakref', '_weakrefset', '_winapi', '_wmi', 'abc', 'ast', 'bdb', 'binascii', 'bisect', 'builtins', 'bz2', 'codecs', 'collections', 'collections.abc', 'configparser', 'contextlib', 'copyreg', 'datetime', 'dis', 'encodings', 'encodings.aliases', 'encodings.cp1251', 'encodings.utf_8', 'enum', 'errno', 'fnmatch', 'functools', 'genericpath', 'heapq', 'idlelib', 'idlelib.autocomplete', 'idlelib.autocomplete_w', 'idlelib.calltip', 'idlelib.calltip_w', 'idlelib.config', 'idlelib.debugger', 'idlelib.debugger_r', 'idlelib.debugobj', 'idlelib.debugobj_r', 'idlelib.hyperparser', 'idlelib.iomenu', 'idlelib.macosx', 'idlelib.multicall', 'idlelib.pyparse', 'idlelib.rpc', 'idlelib.run', 'idlelib.scrolledlist', 'idlelib.stackviewer', 'idlelib.tooltip', 'idlelib.tree', 'idlelib.util', 'idlelib.window', 'idlelib.zoomheight', 'importlib', 'importlib._abc', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib.machinery', 'importlib.util', 'inspect', 'io', 'ipaddress', 'itertools', 'keyword', 'linecache', 'lzma', 'marshal', 'math', 'nt', 'ntpath', 'opcode', 'operator', 'os', 'os.path', 'pickle', 'pkgutil', 'platform', 'plistlib', 'posixpath', 'pydoc', 'pyexpat', 'pyexpat.errors', 'pyexpat.model', 'queue', 'random', 're', 're._casefix', 're._compiler', 're._constants', 're._parser', 'reprlib', 'select', 'selectors', 'shlex', 'shutil', 'site', 'socket', 'socketserver', 'stat', 'string', 'struct', 'sys', 'sysconfig', 'tempfile', 'textwrap', 'threading', 'time', 'tkinter', 'tkinter.constants', 'token', 'tokenize', 'traceback', 'types', 'typing', 'urllib', 'urllib.parse', 'warnings', 'weakref', 'winreg', 'xml', 'xml.parsers', 'xml.parsers.expat', 'xml.parsers.expat.errors', 'xml.parsers.expat.model', 'zipimport', 'zlib']
+alpha()
+Traceback (most recent call last):
+  File "<pyshell#35>", line 1, in <module>
+    alpha()
+NameError: name 'alpha' is not defined
+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
+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)
+```
+
+Модуль Mod0
+
+```py
+sys.modules.pop('Mod1')
+<module 'Mod1' from 'C:\\Users\\Home\\Desktop\\python-labs\\TEMA8\\Mod1.py'>
+sys.modules.pop('Mod2')
+<module 'Mod2' from 'C:\\Users\\Home\\Desktop\\python-labs\\TEMA8\\Mod2.py'>
+import Mod0
+Mod1:Введите значение = 3
+Mod1:Значение perm1= 3
+perm1= 3
+****ALPHA****
+Значение t=10
+tt= 10
+****BETA****
+qq= 44031505860631.98
+Mod0.tt,Mod0.qq,Mod0.Mod1.perm1
+('10', 44031505860631.98, '3')
+```
+
+## 3.2 Еще один пример.
+
+```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
+```
+
+Модуль MM1
+
+```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)
+```
+
+Модуль MM2
+
+```py
+import MM2
+print('y=',MM2.vyhod)
+```
+
+Модуль MM0
+
+```py
+import MM0
+k1,T,k2,Xm,A,F,N=7,2,4,9,5,0.5,1000
+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, 0, 0, -1.0183086292055208, 0, 26.39885775889784, -36.65029553691161, -34.19982663883278, 196.29963397615063, -151.6919482160481, -388.32493988337274, 1057.8073200868555, -308.3186572590445, -2798.051869998873, 5004.749701095182, 1362.331454336744, ...]
+```
+
+## 3.3 Области действия объектов в модулях.
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    beta(int(t))
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=q*math.pi
+    return math.exp(expi)
+```
+
+Измененный Mod2.
+
+```py
+ with a value
+from Mod2 import *
+alpha()
+****ALPHA****
+Значение t=2
+****BETA****
+'2'
+```
+
+Далее:
+
+```py
+def alpha():
+    print('****ALPHA****')
+    t=input('Значение t=')
+    return t
+
+def beta(q):
+    print('****BETA****')
+    import math
+    expi=q*math.pi
+    alpha()
+    return math.exp(expi)
+```
+
+Еще раз измененный Mod2.
+
+```py
+beta(6)
+****BETA****
+153552935.39544657
+```
+
+Выполнение.
+
+```py
+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(t,expi)
+```
+
+Измененный Mod0.
+
+```py
+import Mod0
+Mod1:Введите значение = 5
+Mod1:Значение perm1= 5
+perm1= 5
+****ALPHA****
+Значение t=10
+****BETA****
+tt= 10
+****BETA****
+qq= 44031505860631.98
+Traceback (most recent call last):
+  File "<pyshell#62>", line 1, in <module>
+    import Mod0
+  File "C:\Users/Home/Desktop/python-labs/TEMA8\Mod0.py", line 10, in <module>
+    print(t,expi)
+NameError: name 't' is not defined. Did you mean: 'tt'?
+```
+
+Выполнение.
+
+```py
+import Mod1
+print('perm1=',Mod1.perm1)
+Mod1.perm1 = str(int(Mod1.perm1)*3)
+print('Увеличение perm1 в 3 раза:', Mod1.perm1)
+from Mod2 import alpha as al
+tt=al()
+print('tt=',tt)
+from Mod2 import beta
+qq=beta(float(tt))
+print('qq=',qq)
+```
+
+Измененный Mod0.
+
+```py
+import Mod0
+perm1= 5
+Увеличение perm1 в 3 раза: 15
+****ALPHA****
+Значение t=10
+****BETA****
+tt= 10
+****BETA****
+qq= 44031505860631.98
+```
+
+Выполнение.
+
+```py
+import Mod0
+perm1= 15
+Увеличение perm1 в 3 раза: 45
+****ALPHA****
+Значение t=10
+****BETA****
+tt= 10
+****BETA****
+qq= 44031505860631.98
+Mod0.Mod1.perm1=str(int(Mod0.Mod1.perm1)*2)
+Mod0.Mod1.perm1
+'90'
+Mod0.tt = str(int(Mod0.tt)*2)
+Mod0.tt
+'20'
+Mod0.qq=Mod0.qq*2
+Mod0.qq
+88063011721263.95
+```
+
+
+
+
+

TEMA8/slovar.py

@@ -0,0 +1,17 @@
+import os
+import math
+import pickle
+
+def dictionary(keys,values):
+    ''' Создает словарь с ключами из первого списка и значениями из второго'''
+    
+    result = {}
+
+    for i in range(len(keys)):
+        result[keys[i]] = math.log(abs(values[i]))
+
+    fl = open('Slovar.bin','wb')
+    pickle.dump(result,fl)
+    fl.close()
+
+    return result

TEMA8/task.md

@@ -0,0 +1,71 @@
+# Общее контрольное задание по теме 8
+
+Лыкова Елизавета, А-01-23
+
+# Задание:
+
+Разработайте программу, состоящую из трех модулей:
+
+- Модуль 1 содержит функцию считывания числового списка из текстового файла с заданным именем (аргумент функции – имя файла). Элементы в файле могут располагаться по несколько на строке с разделением пробелом. Числа элементов в строках могут быть разными. Полученный список должен возвращаться в вызывающую программу.
+
+- Модуль 2 содержит функцию расчета коэффициента корреляции по двум числовым спискам (аргументы функции – имена двух списков). Числа элементов в списках могут различаться. Значение коэффициента должно возвращаться в вызывающую программу.
+
+- Модуль 3 запрашивает у пользователя и вводит имена двух файлов с исходными данными, дважды вызывает функцию из модуля 1 и считывает два списка из двух текстовых файлов. Затем вызывает функцию расчета коэффициента корреляции с помощью функции из модуля 2 и отображает рассчитанное значение на экране с округлением до трех цифр после точки.
+
+Подготовьте два текстовых  файла с числовыми данными и проверьте по ним работу программы.
+
+# Решение
+
+## Модуль 1
+
+```py
+def read (file):
+    '''Чтение данных из файла'''
+    num = []
+    with open(file,'r') as file:
+        for line in file:
+            num.extend(map(float,line.split()))
+        return num
+```
+
+## Модуль 2
+
+```py
+def correl (list1,list2):
+    '''Расчет коэффициента корреляции'''
+    n = min(len(list1),len(list2))
+    list1 = list1[:n]
+    list2 = list2[:n]
+    mean1 = sum(list1)/n
+    mean2 = sum(list2)/n
+    chis = sum((list1[i]-mean1)*(list2[i]-mean2)for i in range(n))
+    znam1 = sum((x-mean1)**2 for x in list1)
+    znam2 = sum((y-mean2)**2 for y in list1)
+    
+    if znam1 == 0 or znam2 == 0:
+        return 0
+
+    return chis/(znam1*znam2)**0.5
+```
+
+## Модуль 3
+
+```py
+import Modul1
+import Modul2
+file1 = input('Введите имя первого файла:')
+file2 = input('Введите имя второго файла:')
+list1 = Modul1.read(file1)
+list2 = Modul1.read(file2)
+corr = Modul2.correl(list1,list2)
+print(f'Коэффициент корреляции: {corr:.3f}')
+```
+
+## Выполнение
+
+```py
+import Modul3
+Введите имя первого файла:data1.txt
+Введите имя второго файла:data2.txt
+Коэффициент корреляции: 0.847
+```

TEMA8/test.md

@@ -0,0 +1,79 @@
+# Индивидуальное контрольное задание по теме 8
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+По указанному преподавателем варианту контрольного задания обратитесь к индивидуальному заданию с таким номером в теме 7, разработайте функцию, на ее основе создайте модуль. Создайте второй модуль, в котором должны быть инструкции для ввода/создания исходных данных для проверки работы функции, вызов функции и отображение полученных результатов.
+
+Разработайте функцию с двумя аргументами – списками. На их основе в функции должен со-здаваться словарь с ключами из первого списка и со значениями – натуральными логарифмами абсолютных значений соответствующих элементов  из второго списка. Полученный словарь должен записываться в бинарный файл с именем Slovar.bin. Проверьте функцию на двух примерах с разными списками.
+
+## Решение 
+
+```py
+import os
+import math
+import pickle
+
+def dictionary(keys,values):
+    ''' Создает словарь с ключами из первого списка и значениями из второго'''
+    
+    result = {}
+
+    for i in range(len(keys)):
+        result[keys[i]] = math.log(abs(values[i]))
+
+    fl = open('Slovar.bin','wb')
+    pickle.dump(result,fl)
+    fl.close()
+
+    return result
+```
+
+Модуль slovar
+
+```py
+import slovar
+
+# Пример 1
+
+keys1 = ['A','B','C']
+values1 = [16,7,890]
+
+print(f'Пример 1')
+print(f'Ключи: {keys1}')
+print(f'Значения: {values1}')
+
+result1 = slovar.dictionary(keys1,values1)
+
+print(f'Созданный словарь: {result1}')
+
+# Пример 2
+
+keys2 = ['d','b','x','s']
+values2 = [10.7,-4,5,63]
+
+print(f'Пример 2')
+print(f'Ключи: {keys2}')
+print(f'Значения: {values2}')
+
+result2 = slovar.dictionary(keys2,values2)
+
+print(f'Созданный словарь: {result2}')
+```
+
+Модуль main
+
+```py
+import main
+Пример 1
+Ключи: ['A', 'B', 'C']
+Значения: [16, 7, 890]
+Созданный словарь: {'A': 2.772588722239781, 'B': 1.9459101490553132, 'C': 6.7912214627261855}
+Пример 2
+Ключи: ['d', 'b', 'x', 's']
+Значения: [10.7, -4, 5, 63]
+Созданный словарь: {'d': 2.3702437414678603, 'b': 1.3862943611198906, 'x': 1.6094379124341003, 's': 4.143134726391533}
+```
+
+Выполнение

TEMA9/M0.py

@@ -0,0 +1,16 @@
+import M2
+import matplotlib.pyplot as plt
+
+def main():
+    """
+    Главная программа
+    """
+    data = M2.main_M2()
+    
+    if data:
+        plt.plot(data)
+        plt.title('SS3 из модуля M2')
+        plt.show()
+
+if __name__ == "__main__":
+    main()

TEMA9/M1.py

@@ -0,0 +1,44 @@
+import random
+
+def function1(name, TAU,K):
+    '''Чтение сигнала из файла и создание списка'''
+    try:
+        fl = open(name,'r')
+        data = fl.read().strip().split()
+        SPS1 = [float(x) for x in data]
+        fl.close()
+
+        N = len(SPS1)
+        SPS2 = [0]*N
+
+        for i in range (N):
+            if i < TAU - 1:
+                SPS2[i]=0
+            else:
+                SPS2[i]= K * SPS1[i-TAU]
+                
+        return SPS1, SPS2
+    
+    except FileNotFoundError:
+        print(f'Файл {name} не найден')
+        return [],[]
+
+def function2(SS1,SS2,TT):
+    '''Расчет значения D'''
+    if not SS1 or not SS2:
+        return 0
+
+    N = len(SS1)
+
+    if TT<0 or TT>= N:
+        return 0
+
+    SR1 = sum(SS1)/N if N >0 else 0
+    SR2 = sum(SS2)/N if N >0 else 0
+
+    D = 0
+    for i in range(TT,N):
+        if (i-TT)<len(SS2):
+            D += (SS1[i] - SR1) * (SS2[i - TT] - SR2)
+
+    return D

TEMA9/M2.py

@@ -0,0 +1,58 @@
+import random
+import M1
+
+def main():
+    '''Основная функция'''
+    while True:
+        name = input("Введите имя файла с данными: ")
+        try:
+            with open(name, 'r') as test_file:
+                pass
+            break
+        except FileNotFoundError:
+            print(f"Файл '{filename}' не найден. Попробуйте снова.")
+    
+    while True:
+        try:
+            TAU = int(input("Введите значение TAU (>=0): "))
+            if TAU >= 0:
+                break
+            else:
+                print("TAU должно быть >= 0. Попробуйте снова.")
+        except ValueError:
+            print("Некорректный ввод. Введите целое число.")
+    
+    K = random.uniform(2, 7)
+    print(f"\nСлучайное значение K: {K:.2f}")
+    
+    SPS1, SPS2 = M1.function1(name, TAU, K)
+    
+    if not SPS1:
+        print("Не удалось получить данные. Программа завершена.")
+        return
+    
+    print(f"\nДлина списка SPS1: {len(SPS1)}")
+    print("Первые 10 элементов SPS1:", SPS1[:10])
+    print("Первые 10 элементов SPS2:", SPS2[:10])
+    
+    SS3 = []
+    max_TT = TAU + 5
+    
+    for TT in range(max_TT + 1):
+        D = M1.function2(SPS1, SPS2, TT)
+        SS3.append(D)
+        print(f"TT = {TT}: D = {D:.6f}")
+    
+    output_filename = "Res11.bin"
+    try:
+        with open(output_filename, 'w') as file:
+            for value in SS3:
+                file.write(f"{value}\n")
+        print(f"\nРезультаты записаны в файл: {output_filename}")
+    except Exception as e:
+        print(f"Ошибка при записи в файл: {e}")
+    
+    return SS3
+
+if __name__ == "__main__":
+    main_M2()

TEMA9/Mod3.py

@@ -0,0 +1,12 @@
+class Class1:
+    def zad_zn(self,znach):
+        self.data=znach
+    def otobrazh(self):
+        print(self.data)
+class Class2(Class1):
+    def otobrazh(self):
+        print('значение=', self.data)
+def otobrazh(objekt):
+    print('значение объекта=', objekt)
+    
+    

TEMA9/ModH.py

@@ -0,0 +1,4 @@
+import Mod3
+z4 = Mod3.Class2()
+z4.zad_zn("Класс из модуля")
+z4.otobrazh()

TEMA9/SAU.py

@@ -0,0 +1,22 @@
+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]
+        y1=self.param[0]*y0
+        y2=inerz(y1,self.param[1],self.ypr[0])
+        y3=inerz(y2,self.param[2],self.ypr[1])
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+        

TEMA9/main.py

@@ -0,0 +1,26 @@
+from sotrudniki import sotrudniki
+
+sot1 = sotrudniki("Пронин А.Д", "Кафедра Управления и информационных технологий", "Ассистент",60000)
+sot2 = sotrudniki("Бирюков А.М.", "Кафедра Математического и компьютерного моделирования", "Доцент", 75000)
+
+print('=== НАЧАЛЬНЫЕ ДАННЫЕ ===')
+print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
+print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
+
+print("\n=== ОПЕРАЦИИ С СОТРУДНИКАМИ ===")
+
+sot2.salary(20000)
+sot1.department('Кафедра Математического и компьютерного моделирования')
+sot1.position('Старший преподаватель')
+sot2.add_pooshrenia('За преданность делу')
+sot1.add_pooshrenia('За создание позитивной атмосферы')
+
+print("\n=== ИТОГОВЫЕ ДАННЫЕ ===")
+
+print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
+print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
+
+print("\n=== ПЕРЕЧЕНЬ ПООЩРЕНИЙ ===")
+
+print(f"Поощрения {sot1.fio}: {sot1.pooshrenia}")
+print(f"Поощрения {sot2.fio}: {sot2.pooshrenia}")

TEMA9/main_SAU.py

@@ -0,0 +1,14 @@
+###main_SAU
+prm = [2.5,4,1.3,0.8]
+from SAU import*
+xx = [0]+[1]*20
+SAUe = SAU(prm)
+yt=[]
+for xt in xx:
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.show()

TEMA9/report.md

@@ -0,0 +1,271 @@
+# Отчет по теме 9
+
+Лыкова Елизавета, А-01-23
+
+## 1. Запуск IDLE, привязка католога, создание файла отчета.
+
+```py
+import os
+os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA9")
+```
+
+## 2. Создание классов и их наследников.
+
+## 2.1 Автономный класс.
+
+```py
+class Class1:
+    def zad_zn(self,znach):
+        self.data = znach
+    def otobrazh(self):
+        print(self.data)
+
+        
+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
+```
+
+## 2.2 Класс-наследник.
+
+```py
+class Class2(Class1):
+    def otobrazh(self):
+        print('значение=', self.data)
+
+        
+z3 = Class2()
+dir(z3)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_zn']
+z3.zad_zn('Совсем новое')
+z3.otobrazh()
+значение= Совсем новое
+z1.otobrazh()
+Новое значение атрибута у экз.1
+del z1,z2,z3
+```
+
+Метод с одинаковым именем в разных классах будет вести себя по-разному, т.к. в дочернем классе методы могут быть переопределены.
+
+## 3. Использование классов, содержащихся в модулях.
+
+```py
+class Class1:
+    def zad_zn(self,znach):
+        self.data=znach
+    def otobrazh(self):
+        print(self.data)
+class Class2(Class1):
+    def otobrazh(self):
+        print('значение=', self.data)
+    def otobrazh(objekt):
+        print('значение объекта=', objekt)
+```
+
+Модуль 
+
+```py
+Traceback (most recent call last):
+  File "<pyshell#33>", line 1, in <module>
+    z4.otobrazh()
+  File "C:\Users\Home\Desktop\python-labs\TEMA9\Mod3.py", line 5, in otobrazh
+    print(self.data)
+AttributeError: 'Class1' object has no attribute 'data'
+```
+
+Ошибка произошла из-за того, что мы пытаемся напечатать значение несуществующего объекта.
+
+```py
+from Mod3 import Class1
+z4 = Class1()
+z4.data = 'значение данного data у экз.4'
+z4.otobrazh()
+значение данного data у экз.4
+del z4
+import Mod3
+z4 = Mod3.Class2()
+z4.zad_zn("Класс из модуля")
+z4.otobrazh()
+значение= Класс из модуля
+Mod3.otobrazh('Объект')
+значение объекта= Объект
+```
+
+В первом случае ototbrazh - это метод класса Class2 и соответсвующего ему экземпляра класса z2. Он не принимает значимых параметров, кроме формального self. Во втором же ototbrazh - это просто функция, что глобально определена в Mod3.
+
+## 4. Специальные методы.
+
+```py
+class Class3(Class2):
+    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
+
+        
+z5 = Class3('abc')
+z5.otobrazh()
+значение= abc
+z6 = z5+'def'
+z6.otobrazh()
+значение= abcdef
+z6.zad_dr_zn(3)
+z6.otobrazh()
+значение= abcdefabcdefabcdef
+```
+
+## 5. Присоединение атрибутов к классу.
+
+```py
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+Class3.fio = 'Иванов.И.И.'
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+z7 = Class3(123)
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+dir(z7)==dir(Class3)
+False
+z7.rozden='1987'
+dir(z7)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'data', 'fio', 'otobrazh', 'rozden', 'zad_dr_zn', 'zad_zn']
+dir(Class3)
+['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__firstlineno__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__static_attributes__', '__str__', '__subclasshook__', '__weakref__', 'fio', 'otobrazh', 'zad_dr_zn', 'zad_zn']
+```
+
+## 6. Выявление родительских классов.
+
+```py
+Class3.__bases__
+(<class '__main__.Class2'>,)
+Class2.__bases__
+(<class '__main__.Class1'>,)
+Class1.__bases__
+(<class 'object'>,)
+object.__bases__
+()
+Class3.__mro__
+(<class '__main__.Class3'>, <class '__main__.Class2'>, <class '__main__.Class1'>, <class 'object'>)
+ZeroDivisionError.__mro__
+(<class 'ZeroDivisionError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)
+```
+
+## 7. Создание свойства класса.
+
+```py
+class Class4:
+    def __init__(sam,znach):
+        sam.__prm=znach
+    def chten(sam):
+        return sam.__prm
+    def zapis(sam,znch):
+        sam.__prm=znch
+    def stiran(sam):
+        del sam.__prm
+    svojstvo=property(chten,zapis,stiran)
+
+    
+exempl=Class4(12)
+exempl.svojstvo
+12
+exempl.svojstvo=45
+print(exempl.svojstvo)
+45
+del exempl.svojstvo
+exempl.svojstvo
+Traceback (most recent call last):
+  File "<pyshell#56>", line 1, in <module>
+    exempl.svojstvo
+  File "<pyshell#50>", line 5, in chten
+    return sam.__prm
+AttributeError: 'Class4' object has no attribute '_Class4__prm'
+```
+
+Такой вывод, потому что атрибут уже удален.
+
+## 8. Пример представления в виде класса модели системы автоматического регулирования (САР), состоящей из последовательного соединения усилителя и двух инерционных звеньев, охваченных отрицательной обратной связью с усилителем.
+
+```py
+class SAU:
+    def __init__(self,zn_param):
+        self.param=zn_param
+        self.ypr=[0,0]
+
+    def zdn_zn(self,upr):
+        self.x=upr
+
+    def model(self):
+        def inerz(x,T,yy):
+            return(x+T*yy)/(T+1)
+
+        y0=self.x-self.ypr[1]*self.param[3]
+        y1=self.param[0]*y0
+        y2=inerz(y1,self.param[1],self.ypr[0])
+        y3=inerz(y2,self.param[2],self.ypr[1])
+        self.ypr[0]=y2
+        self.ypr[1]=y3
+
+    def otobraz(self):
+        print('y=',self.ypr[1])
+        
+```
+
+Модуль SAU
+
+```py
+###main_SAU
+prm = [2.5,4,1.3,0.8]
+from SAU import*
+xx = [0]+[1]*20
+SAUe = SAU(prm)
+yt=[]
+for xt in xx:
+    SAUe.zdn_zn(xt)
+    SAUe.model()
+    SAUe.otobraz()
+    yt.append(SAUe.ypr[1])
+import pylab
+pylab.plot(yt)
+pylab.show()
+```
+
+Модуль main_SAU
+
+```py
+import main_SAU.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
+```
+
+![рисуночек](ris1.png)
+

TEMA9/signal.txt

@@ -0,0 +1 @@
+0.497 2.127 1.452 2.602 4.794 -1.905 0.085 -2.629 0.252 2.689 2.474 3.816 -2.189 -1.768 2.77 -2.433 -1.041 -2.445 2.476 4.147 -0.049 4.456 -0.775 4.662 -1.757 4.352 -1.168 -2.37 4.542 -1.175 3.69 -3.318 -2.284 4.73 -1.774 1.809 -3.342 -4.543 -2.636 2.474 4.302 -0.962 -0.86 4.75 -0.829 -4.45 -1.604 -3.344 -4.06 -2.0

TEMA9/sotrudniki.py

@@ -0,0 +1,30 @@
+class sotrudniki:
+    def __init__(self, fio, otdel, dolzhnost, oklad):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self._pooshrenia = []
+
+    def salary(self,summa):
+        if summa > 0:
+            self.oklad += summa
+            print(f"Оклад сотрудника {self.fio} увеличен на {summa}. Новый оклад: {self.oklad}")
+        else:
+            print("Сумма для повышения оклада должна быть больше нуля.")
+
+    def department(self,new_department):
+        print(f"Сотрудник {self.fio} переведен из отдела {self.otdel} в отдел {new_department}.")
+        self.otdel = new_department
+
+    def 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_pooshrenia(self,tekst):
+        self._pooshrenia.append(tekst)
+        print(f"Сотрудник {self.fio} теперь имеет поощрение: {tekst}")

TEMA9/sygnals.py

@@ -0,0 +1,10 @@
+import random
+
+data = []
+for i in range(50):
+    data.append(str(round(random.uniform(-5, 5), 3)))
+
+with open("signal.txt", 'w') as file:
+    file.write(" ".join(data))
+
+print("Файл 'signal.txt' готов к использованию")

TEMA9/task.md

@@ -0,0 +1,107 @@
+# Общее контрольное задание по теме 9
+
+Лыкова Елизавета, А-01-23
+
+# Задание:
+
+Создайте и запишите в модуль класс, содержащий следующие компоненты:
+- конструктор, задающий четырем атрибутам (fio, otdel, dolzhnost, oklad), представляющим фамилии сотрудников, название отделов, названия должностей сотрудников и размеры их окладов,  некоторые начальные значения;
+- метод для обеспечения операции повышения оклада сотрудника на заданное значение;
+- метод для обеспечения перевода сотрудника из одного отдела в другой;
+- метод для изменения должности сотрудника;
+- свойство, содержащее перечень (список) поощрений сотрудника.
+Создайте 2 экземпляра класса, задайте им некоторые значения атрибутов и свойства. Отобразите эти значения. Попробуйте с этими экземплярами операции перевода из отдела в отдел, изменения должности и оклада, объявления благодарности.
+
+# Решение
+
+```py
+class sotrudniki:
+    def __init__(self, fio, otdel, dolzhnost, oklad):
+        self.fio = fio
+        self.otdel = otdel
+        self.dolzhnost = dolzhnost
+        self.oklad = oklad
+        self._pooshrenia = []
+
+    def salary(self,summa):
+        if summa > 0:
+            self.oklad += summa
+            print(f"Оклад сотрудника {self.fio} увеличен на {summa}. Новый оклад: {self.oklad}")
+        else:
+            print("Сумма для повышения оклада должна быть больше нуля.")
+
+    def department(self,new_department):
+        print(f"Сотрудник {self.fio} переведен из отдела {self.otdel} в отдел {new_department}.")
+        self.otdel = new_department
+
+    def 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_pooshrenia(self,tekst):
+        self._pooshrenia.append(tekst)
+        print(f"Сотрудник {self.fio} теперь имеет поощрение: {tekst}")
+```
+
+Модуль sotrudniki
+
+```py
+from sotrudniki import sotrudniki
+
+sot1 = sotrudniki("Пронин А.Д", "Кафедра Управления и информационных технологий", "Ассистент",60000)
+sot2 = sotrudniki("Бирюков А.М.", "Кафедра Математического и компьютерного моделирования", "Доцент", 75000)
+
+print('=== НАЧАЛЬНЫЕ ДАННЫЕ ===')
+print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
+print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
+
+print("\n=== ОПЕРАЦИИ С СОТРУДНИКАМИ ===")
+
+sot2.salary(20000)
+sot1.department('Кафедра Математического и компьютерного моделирования')
+sot1.position('Старший преподаватель')
+sot2.add_pooshrenia('За преданность делу')
+sot1.add_pooshrenia('За создание позитивной атмосферы')
+
+print("\n=== ИТОГОВЫЕ ДАННЫЕ ===")
+
+print(f"{sot1.fio}, {sot1.otdel}, {sot1.dolzhnost}, оклад: {sot1.oklad}")
+print(f"{sot2.fio}, {sot2.otdel}, {sot2.dolzhnost}, оклад: {sot2.oklad}")
+
+print("\n=== ПЕРЕЧЕНЬ ПООЩРЕНИЙ ===")
+
+print(f"Поощрения {sot1.fio}: {sot1.pooshrenia}")
+print(f"Поощрения {sot2.fio}: {sot2.pooshrenia}")
+```
+
+Модуль main
+
+```py
+import os
+os.chdir('C:\\Users\\Home\\Desktop\\python-labs\\TEMA9')
+import main
+=== НАЧАЛЬНЫЕ ДАННЫЕ ===
+Пронин А.Д, Кафедра Управления и информационных технологий, Ассистент, оклад: 60000
+Бирюков А.М., Кафедра Математического и компьютерного моделирования, Доцент, оклад: 75000
+
+=== ОПЕРАЦИИ С СОТРУДНИКАМИ ===
+Оклад сотрудника Бирюков А.М. увеличен на 20000. Новый оклад: 95000
+Сотрудник Пронин А.Д переведен из отдела Кафедра Управления и информационных технологий в отдел Кафедра Математического и компьютерного моделирования.
+Должность сотрудника Пронин А.Д изменена с Ассистент на Старший преподаватель.
+Сотрудник Бирюков А.М. теперь имеет поощрение: За преданность делу
+Сотрудник Пронин А.Д теперь имеет поощрение: За создание позитивной атмосферы
+
+=== ИТОГОВЫЕ ДАННЫЕ ===
+Пронин А.Д, Кафедра Математического и компьютерного моделирования, Старший преподаватель, оклад: 60000
+Бирюков А.М., Кафедра Математического и компьютерного моделирования, Доцент, оклад: 95000
+
+=== ПЕРЕЧЕНЬ ПООЩРЕНИЙ ===
+Поощрения Пронин А.Д: ['За создание позитивной атмосферы']
+Поощрения Бирюков А.М.: ['За преданность делу']
+```
+
+

TEMA9/test.md

@@ -0,0 +1,37 @@
+# Тест 3 Вариант 3
+
+Лыкова Елизавета, А-01-23
+
+## Задание
+
+1) Создайте модуль М1, содержащий две функции: 
+
+- функция 1: аргументы - имя текстового файла, содержащего некоторое число отсчетов  сигнала, целочисленный параметр TAU и числовой параметр К; в функции считывается сигнал из файла в список SPS1 и формируется второй список SPS2, элементы которого определяются по правилу: первые (TAU-1) элементов равны 0, а последующие определяются по формуле: SPS2[i]=K*SPS1[i-TAU]; оба списка возвращаются в качестве результатов работы функции;
+
+- функция 2: аргументы - два числовых списка SS1 и SS2, а также целочисленный параметр ТТ; в функции рассчитывается и возвращается значение
+
+D= (SS1[TT]-SR1)*(SS2[0] - SR2)+ (SS1[TT+1]-SR1)*(SS2[1] - SR2)+:+
+
+(SS1[i]-SR1)*(SS2[i-TT] - SR2)+:+ (SS1[N]-SR1)*(SS2[N-TT] - SR2),
+
+где N - длина списка SS1, SR1, SR2 - средние значения соответствующих списков.
+
+2) Создайте еще один модуль М2, в котором должны выполняться операции: 
+
+- запрашивается и вводится имя текстового файла с данными; проверяется наличие файла и при отсутствии - повторение запроса;
+
+- запрашивается значение параметра TAU и проверяется TAU >=0;
+
+- вызывается функция 1 с указанными именем файла и параметром TAU, и случайным значением К из диапазона значений от 2 до 7; отображаются рассчитанные списки;
+
+- вызывается функция 2 в цикле со значениями TT от 0 до TAU+5; результаты записываются в список SS3;
+
+- список SS3 записывается в текстовый файл с именем Res11.bin.
+
+3) Создайте модуль М0 - главную программу, которая вызывает М2 и отображает в виде графика  список SPS3.
+
+4) Подготовьте  файл с исходными данными - 50 отсчетов случайного нормально распределенного с некоторыми параметрами сигнала. Проведите по программе расчеты  со значениями TAU, равными 0, 5 и 10.
+
+## Решение
+
+Всё в модулях в гите.