report is done

TEMA1/Pr0.py

@@ -0,0 +1,4 @@
+#Программа по Теме 1 Марков Никита Сергеевич
+print('Hello')
+h=input('Your name=')
+import os

TEMA1/report.md

@@ -0,0 +1,72 @@
+# Отчет по теме 1
+
+Марков Никита, А-03-23
+
+## 1 Изучение среды IDLE
+
+## Выполнение 3-8 пунктов
+
+```
+>>> print('Hello')
+Hello
+>>> h=input('Your name=')
+Your name=Nikita
+>>> exit()
+
+>>> import os
+>>> os.chdir('C:\\Users\\u111-06\\Desktop\\python-labs\\TEMA1\\')
+```
+
+## Выполнение 10-14 пунктов
+
+```
+Hello
+Your name=Nikita
+import Pr0
+Hello
+Your name=Nikita
+import prb1
+Как Вас зовут? Nikita
+Привет, Nikita
+help(print),help(input)
+Help on built-in function print in module builtins:
+
+print(*args, sep=' ', end='\n', file=None, flush=False)
+    Prints the values to a stream, or to sys.stdout by default.
+    
+    sep
+      string inserted between values, default a space.
+    end
+      string appended after the last value, default a newline.
+    file
+      a file-like object (stream); defaults to the current sys.stdout.
+    flush
+      whether to forcibly flush the stream.
+
+Help on built-in function input in module builtins:
+
+input(prompt='', /)
+    Read a string from standard input.  The trailing newline is stripped.
+    
+    The prompt string, if given, is printed to standard output without a
+    trailing newline before reading input.
+    
+    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+    On *nix systems, readline is used if available.
+
+(None, None)
+
+```
+
+## Выполнение 15 пункта 
+
+```py
+import tdemo_chaos
+```
+
+<image src="turtle.png">
+
+<image src="clock.png">
+
+
+

TEMA1/test.md

@@ -0,0 +1,11 @@
+# Общее контрольное задание по теме 1
+
+Марков Никита, А-03-23
+
+## Задание
+
+Если требуется повторить с небольшим изменением ранее введенную инструкцию, работая в командном окне IDLE, как это лучше сделать?
+
+## Решение
+
+Кликнуть мышкой на строку, которую мы написали ранее и прожать Enter. Ранее введенная строка повторится и мы сможем ее отредактировать и выполнить.

TEMA2/okr.md

@@ -0,0 +1,26 @@
+# Протокол по Теме 2 
+
+Марков Никита Сергеевич, А-03-23
+
+
+## Выполнение ОКР
+
+```py
+>>> import keyword
+>>> familia='markov'
+>>> first_word = familia[0]
+>>> sp_kw=keyword.kwlist
+>>> sp_kw.remove('nonlocal')
+>>> sp_kw
+['False', 'None', 'True', '__peg_parser__', '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=('nikita','sasha','victor','dima')
+>>> type(kort_nam)
+<class 'tuple'>
+>>> kort_nam=kort_nam + ('egor','misha')
+>>> kort_nam
+('nikita', 'sasha', 'victor', 'dima', 'egor', 'misha')
+>>> dict_bas={'Список':[1,2,4], 'Множество':{1,2,3,4},'Словарь':{'key':'value'}}
+>>> dict_bas
+{'Список': [1, 2, 4], 'Множество': {1, 2, 3, 4}, 'Словарь': {'key': 'value'}}
+
+```

TEMA2/report.md

@@ -0,0 +1,360 @@
+# Протокол по Теме 2 
+
+Марков Никита Сергеевич, А-03-23
+
+
+## Выполнение пункта 2
+
+```py
+>>> f1=16; f2=3
+>>> f1,f2
+(16, 3)
+>>> f1;f2
+16
+3
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
+>>> dir(f1)
+['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__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_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
+>>> type(f2)
+<class 'int'>
+>>> del f1,f2
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
+```
+Как видим, после применения del ммы удалили f1 и f2 из оперативной памяти 
+
+
+## Выполнение пункта 3
+
+
+```py
+>>> gg1=1.6
+>>> hh1='Строка'
+>>> 73sr=3
+SyntaxError: invalid syntax
+>>> and=7
+SyntaxError: invalid syntax
+```
+
+## Выполнение пункта 4
+
+```py
+>>> import keyword
+>>> keyword.kwlist
+['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+## Выполнение пункта 5
+
+```py
+>>> import builtins
+>>> dir(builtins)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+>>> help(abs)
+Help on built-in function abs in module builtins:
+
+abs(x, /)
+    Return the absolute value of the 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(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 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 arguments, return the smallest argument.
+
+>>> 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(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(*iterables) --> A zip object yielding tuples until an input is exhausted.
+ |  
+ |     >>> list(zip('abcdefg', range(3), range(4)))
+ |     [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+ |  
+ |  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.
+ |  
+ |  Methods defined here:
+ |  
+ |  __getattribute__(self, name, /)
+ |      Return getattr(self, name).
+ |  
+ |  __iter__(self, /)
+ |      Implement iter(self).
+ |  
+ |  __next__(self, /)
+ |      Implement next(self).
+ |  
+ |  __reduce__(...)
+ |      Return state information for pickling.
+ |  
+ |  ----------------------------------------------------------------------
+ |  Static methods defined here:
+ |  
+ |  __new__(*args, **kwargs) from builtins.type
+ |      Create and return a new object.  See help(type) for accurate signature.
+```
+
+## Выполнение пункта 6
+
+```py
+>>> Gg1=45
+>>> Gg1;gg1
+45
+1.6
+```
+
+## Изучение простых базовых типов объектов(пункт 7)
+
+```py
+>>> bb1=True; bb2=False
+>>> bb1;bb2
+True
+False
+>>> type(bb1)
+<class 'bool'>
+>>> ii1=-1234567890
+>>> ff1=-8.9876e-12
+>>> dv1=0b1101010
+>>> vsm1=0o52765
+>>> shest1=0x7109af6
+>>> cc1=2-3j
+>>> a=3.67; b=-0.45
+>>> cc2=complex(a,b)
+>>> type(ii1)
+<class 'int'>
+>>> type(ff1)
+<class 'float'>
+>>> type(dv1)
+<class 'int'>
+>>> type(vsm1)
+<class 'int'>
+>>> type(shest1)
+<class 'int'>
+>>> type(cc1)
+<class 'complex'>
+
+>>> ss1='Это - строка символов'
+>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+>>> print(ss1)
+Это - строка символов
+>>> print(ss1a)
+Это - " строка символов ", 
+ 	 выводимая на двух строках
+     
+>>> ss1b= 'Меня зовут: \n Марков Н.С.'
+>>> print(ss1b)
+Меня зовут: 
+ Марков Н.С.
+
+>>> mnogo="""Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции."""
+>>> print(mnogo)
+Нетрудно заметить , что в результате операции
+над числами разных типов получается число,
+имеющее более сложный тип из тех, которые участвуют в операции.
+
+>>> ss1[0]
+'Э'
+>>> ss1[-2]
+'о'
+>>> ss1[6:9]
+'стр'
+>>> ss1[13:]
+'символов'
+>>> ss1[5:-8]
+' строка '
+>>> ss1[3:17:2]
+'  тоасм'
+>>> ss1[17:3:-2]
+'омсаот '
+>>> ss1[-4:3:-2]
+'омсаот '
+
+>>> ss1=ss1[:4]+'='+ss1[5:]
+>>> print(ss1)
+Это = строка символов
+
+```
+
+## Изучение более сложных типов объектов(пункт 8)
+
+```py
+>>> spis1=[111,'Spisok',5-9j]
+>>> print(spis1)
+[111, 'Spisok', (5-9j)]
+>>> stup=[0,0,1,1,1,1,1,1,1]
+>>> print(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]
+>>> spis1[-1]
+(5-9j)
+>>> stup[-8::2]
+[0, 1, 1, 1]
+>>> spis1[1]='Список'
+>>> spis1
+[111, 'Список', (5-9j)]
+>>> len(spis1)
+3
+>>> spis1.append('New item')
+>>> spis1
+[111, 'Список', (5-9j), 'New item']
+>>> spis1+['New item 2']
+[111, 'Список', (5-9j), 'New item', 'New item 2']
+>>> spis1+[ss1b]
+[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Марков Н.С.']
+>>> spis2=[spis1,[4,5,6,7]]
+>>> spis2
+[[111, (5-9j), 'New item'], [4, 5, 6, 7]]
+>>> spis2[0][1]
+(5-9j)
+>>> spis2[0][1]=78
+>>> spis2
+[[111, 78, 'New item'], [4, 5, 6, 7]]
+
+>>> kort1=(222,'Kortezh',77+8j)
+>>> kort1= kort1+(1,2)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2)
+>>> kort1= kort1+(ss1b,)
+>>> kort1
+(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Марков Н.С.')
+>>> kort2=kort1[:2]+kort1[3:]
+>>> kort2
+(222, 'Kortezh', 1, 2, 'Меня зовут: \n Марков Н.С.')
+>>> kort1.index(2)
+4
+>>> kort1.count(222)
+1
+>>> kort3=(21, 'wqasf') + kort1 + (ss1b,)
+>>> kort3
+(21, 'wqasf', 222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Марков Н.С.', 'Меня зовут: \n Марков Н.С.')
+
+>>> 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]
+>>> a = ("a", "b", "c", "d", "e", "f", "g")
+>>> b = [1, 2, 3, 4, 5]
+>>> d = dict(zip(a,b))
+>>> d
+{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
+```
+Элементов в получившимся словаре - 5, т.к. zip() работает до конца b
+
+```py
+>>> AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
+>>> AVTI[' Курс III '][5]
+>>> AVTI['Курс III'][5]
+15
+```
+
+```py
+mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+mnoz1
+{'датчик', 'линия связи', 'микропроцессор', 'двигатель'}
+```
+
+```py
+>>> mnoz2={'тетрадь','тетрадь',32, complex(2.242 , 12), 32}
+>>> mnoz2
+{32, 'тетрадь', (2.242+12j)}
+>>> mnoz2.add('asasdads')
+>>> mnoz2.remove(32)
+>>> mnoz2
+{'тетрадь', (2.242+12j), 'asasdads'}
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 

TEMA3/report.md

@@ -0,0 +1,791 @@
+# Протокол по Теме 2 
+
+Марков Никита Сергеевич, А-03-23
+
+## 1. Начало работы
+
+Запуск IDLE, установление рабочего каталога
+
+## 2. Преобразование простых базовых типов объектов
+
+### 2.1 Преобразование в логический тип с помощью функции bool
+
+```py
+
+>>> logiz1=bool(56)
+>>> type(logiz1)
+<class 'bool'>
+>>> logiz1
+True
+>>> logiz2=bool(0)
+>>> logiz2
+False
+>>> type(logiz2)
+<class 'bool'>
+>>> logiz3=bool("Beta")
+>>> logiz3
+True
+>>> type(logiz3)
+<class 'bool'>
+>>> logiz4=bool("")
+>>> logiz4
+False
+>>> type(logiz4)
+<class 'bool'>
+```
+
+### 2.2 Преобразование в целое десятичное число / в вещественное число
+```py
+>>> tt1=int(198.6)
+>>> tt1
+198
+>>> tt2=int("-76")
+>>> tt2
+-76
+>>> tt3=int("B",16)
+>>> tt3
+11
+>>> tt4=int("71",8)
+>>> tt4
+57
+>>> tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#21>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+Объяснение:
+
+int() ожидает увидеть целочисленное значение в строке, решение проблемы - int(float("98.76"))
+
+
+```py
+
+>>> flt1=float(789)
+>>> flt2=float(-6.78e2)
+>>> flt3=float("Infinity")
+>>> flt4=float("-inf")
+>>> flt1
+789.0
+>>> flt2
+-678.0
+>>> flt3
+inf
+>>> flt4
+-inf
+
+```
+
+### 2.3 Преобразование десятичных чисел в другие системы счисления
+
+```py
+
+>>> hh=123 
+>>> dv1=bin(hh) # двоичная сс
+>>> vos1=oct(hh) # 8-ричная сс
+>>> shs1=hex(hh) # 16-ричная сс
+>>> dv1
+'0b1111011'
+>>> vos1
+'0o173'
+>>> shs1
+'0x7b'
+
+>>> int(dv1, 2)
+123
+>>> int(vos1, 8)
+123
+>>> int(shs1, 16)
+123
+
+```
+
+## 3. Преобразование более сложных базов типов объектов
+
+### 3.1 Преобразование в строку
+
+```py
+
+>>> strk1=str(23.6)
+>>> strk1
+'23.6'
+>>> strk2=str(logiz3)
+>>> strk2
+'True'
+>>> strk3=str(["A","B","C"])
+>>> strk3
+"['A', 'B', 'C']"
+>>> strk4=str(("A","B","C"))
+>>> strk4
+"('A', 'B', 'C')"
+>>> strk5=str({"A":1,"B":2,"C":9})
+>>> strk5
+"{'A': 1, 'B': 2, 'C': 9}"
+
+```
+
+### 3.2 Преобразование эл-ов объекта в список с помощью list()
+
+```py
+
+>>> spis1=list("Строка символов")
+>>> spis1
+['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
+>>> spis2=list((124,236,-15,908))
+>>> spis2
+[124, 236, -15, 908]
+>>> spis3=list({"A":1,"B":2,"C":9})
+>>> spis3
+['A', 'B', 'C']
+
+```
+
+Решение задания:
+
+```py
+
+>>> spis3=list({"A":1,"B":2,"C":9}.values())
+>>> spis3
+[1, 2, 9]
+
+```
+
+### 3.3 Преобразование элементов объектов в кортеж
+
+```py
+
+>>> kort7=tuple('Строка символов')
+>>> kort7
+('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
+>>> kort8=tuple(spis2)
+>>> kort8
+(124, 236, -15, 908)
+>>> kort9=tuple({"A":1,"B":2,"C":9})
+>>> kort9
+('A', 'B', 'C')
+
+```
+
+### 3.4 Удаление объектов
+
+```py
+
+>>> del strk5, kort8
+>>> strk5
+Traceback (most recent call last):
+  File "<pyshell#52>", line 1, in <module>
+    strk5
+NameError: name 'strk5' is not defined
+>>> kort8
+Traceback (most recent call last):
+  File "<pyshell#53>", line 1, in <module>
+    kort8
+NameError: name 'kort8' is not defined
+
+```
+
+Решение задания:
+
+```py
+
+>>> fio = 'Markov N.S.'
+>>> listfio=list(fio)
+>>> listfio
+['M', 'a', 'r', 'k', 'o', 'v', ' ', 'N', '.', 'S', '.']
+>>> cortfio = tuple(listfio)
+>>> cortfio
+('M', 'a', 'r', 'k', 'o', 'v', ' ', 'N', '.', 'S', '.')
+>>> strfio = str(cortfio)
+>>> strfio
+"('M', 'a', 'r', 'k', 'o', 'v', ' ', 'N', '.', 'S', '.')"
+
+```
+
+## 4. Арифметические операции
+
+### 4.1 Сложение и вычитание
+
+```py
+
+>>> 12+7+90
+109
+>>> 5.689e-1 - 0.456
+0.11289999999999994
+>>> 23.6+54
+77.6
+>>> 14-56.7+89
+46.3
+
+```
+
+### 4.2 Умножение
+
+```py
+
+>>> -6.7*12
+-80.4
+
+```
+
+### 4.3 Деление
+
+Результатом деления всегда будет вещественное число
+
+```py
+
+>>> -234.5/6
+-39.083333333333336
+>>> a=178/45
+>>> a
+3.9555555555555557
+>>> type(a)
+<class 'float'>
+
+```
+
+### 4.4 Деление с округлением вниз (целочисленное деление)
+
+```py
+
+>>> b=178//45
+>>> b
+3
+>>> c=-24.6//12.1
+>>> c
+-3.0
+>>> type(b)
+<class 'int'>
+>>> type(c)
+<class 'float'>
+
+```
+Если в целочисленном делении используется хотя бы один объект вещественного типа - результат будет вещественным, если оба целых объекта - результат целый
+
+```py
+
+>>> asas= 123.4 // 3
+>>> asas
+41.0
+>>> type(asas)
+<class 'float'>
+
+```
+
+### 4.5 Получение остатка от деления
+
+```py
+
+>>> 148%33
+16
+>>> 12.6%3.8
+1.2000000000000002
+
+>>> 1245.4 % 4
+1.400000000000091
+
+```
+Если в остатке от деления используется хотя бы один объект вещественного типа - результат будет вещественным, если оба целых объекта - результат целый
+
+### 4.6 Возведение в степень
+
+```py
+
+>>> 14**3
+2744
+>>> e=2.7**3.6
+>>> e
+35.719843790663525
+>>> 3**2.3
+12.513502532843182
+
+```
+
+К комплексным числам можно применять следующие операции:
+
+сложение
+вычитание
+умножение
+деление
+возведение в степень
+
+и нельзя следующие:
+
+целочисленное деление
+остаток от деления
+
+## 5. Операции с двоичными представлениями целых чисел
+
+### 5.1 Двоичная инверсия (~)
+
+```py
+
+>>> dv1=9
+>>> dv2=~dv1
+>>> dv2
+-10
+
+```
+
+~x = -x - 1
+
+### 5.2 Двоичное "И"
+
+```py
+
+>>> 7&9
+1
+>>> 7&8
+0
+
+```
+
+### 5.3 Двоичное "Или"
+
+```py
+
+>>> 7|9
+15
+>>> 7|8
+15
+>>> 14|5
+15
+
+```
+
+### 5.4 Двоичное исключающее "Или"
+
+```py 
+
+>>> 14^5
+11
+
+```
+
+### 5.5 Двоичное исключающее "Или" (Влево или вправо)
+
+```py
+
+>>> h=14
+>>> g=h<<2
+>>> g
+56
+>>> g1=h>>1
+>>> g1
+7
+>>> g2=h>>2
+>>> g2
+3
+
+```
+
+Решение задания
+
+```py
+
+>>> a = 197
+>>> b = 154
+>>> bin(a)[2:]
+'11000101'
+>>> bin(b)[2:]
+'10011010'
+>>> a & b
+128
+>>> a | b
+223
+>>> a ^ b
+95
+
+```
+
+## 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 % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+
+```
+
+%g - placeholder для чисел
+
+%s - placeholder для строк
+
+```py
+
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+
+```
+
+## 7. Оператор присваивания
+
+### 7.1 Обычное присваивание значения переменной
+
+```py
+
+>>> zz=-12
+>>> zz
+-12
+
+```
+
+### 7.2 Увеличение/уменьшение значения переменной на заданную величину
+
+```py
+
+>>> zz+=5
+>>> zz-=3
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> zz
+-10
+>>> stroka
+'Система регулирования'
+
+```
+
+### 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+
+```py
+
+>>> qw = 8
+>>> qw *= 3
+>>> qw
+24
+>>> qw /= 4
+>>> qw
+6.0
+
+```
+
+### 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+
+```py
+
+>>> qw
+6.0
+>>> qw //=2
+>>> qw
+3.0
+>>> qw = 8
+>>> qw%=2
+>>> qw
+0
+>>> qw=4
+>>> qw **= 3
+>>> qw
+64
+
+```
+
+### 7.5. Множественное присваивание
+
+```py
+
+>>> w=v=10
+>>> w,v
+(10, 10)
+>>> n1,n2,n3=(11,-3,'all')
+>>> n1,n2,n3
+(11, -3, 'all')
+
+```
+
+Решение задания: 
+
+Со списком работает поэлементно, со строками посимвольно, с множествами работает, но не в той очередности присваивания, со словарем работает, но нужно знать что присваивать - ключи либо значения
+
+## 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'}
+>>> '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
+
+```
+
+Решение задания:
+
+```py
+
+>>> (a == b) and ('Orel' in dic1) or ('Pskov' in dic1)
+False
+>>> (a > b) or 'pen' in mnoz1
+True
+>>> 'cap' in mnoz1 or a == b
+False
+
+```
+
+### 8.4. Проверка ссылок переменных на один и тот же объект
+
+```py
+
+>>> w=v=10
+>>> w is v
+True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> w1 is v1
+False
+
+```
+
+В начале присваивания двум переменным w и v значения 10 мы храним обе переменные в одной ячейке памяти, затем мы по отдельности присвоили двум этим переменным списки, они хоть и одинаковые, но всё равно переменные по отдельности претерпели изменения -> хранятся в разных ячейках памяти
+
+## 9. Операции с объектами, выполняемые с помощью методов
+
+```py
+
+>>> stroka='Микропроцессорная система управления'
+>>> dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__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("с")
+4
+>>> stroka.replace(' у',' автоматического у')
+'Микропроцессорная система автоматического управления'
+>>> spis22=stroka.split(' ')
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+>>> stroka.upper()
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+>>> stroka3=" ".join(spis22)
+>>> stroka3.partition("с")
+('Микропроце', 'с', 'сорная система управления')
+>>> stroka3.rpartition("с")
+('Микропроцессорная си', 'с', 'тема управления')
+
+```
+
+```py
+
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+
+```
+
+### 9.2. Методы для работы со списками.
+
+```py
+
+>>> spsk = [1, 'blablabla', 7.0, (1, 2, 3), True]
+>>> dir(spsk)
+['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__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)
+7.0
+>>> spsk.append('c')
+>>> spsk
+[1, 'blablabla', (1, 2, 3), True, 'c']
+>>> spsk.insert(2,'a')
+>>> spsk
+[1, 'blablabla', 'a', (1, 2, 3), True, 'c']
+>>> spsk.count('a')
+1
+
+```
+
+1.методом pop() удалили 2-ой эл-т списка (2-ой начиная с нуля)
+2.добавили 'c' в конец списка (метод append() всегда добавляет элемент в конец списка)
+3.методом insert() на позицию 2 (также начиная с нуля) вставили строку 'a'
+4.методом count() посчитали количество вхождений элемента 'a' в список
+
+### 9.3. Самостоятельно создайте кортеж и изучите применение его методов.
+
+```py
+
+>>> mytuple = ('abc', 23, (1, 2, 3), True)
+>>> mytuple.count(23)
+1
+>>> mytuple.index(23)
+1
+
+```
+
+### 9.4.Cамостоятельно изучите методы словарей и множеств.
+
+Словари
+
+```py
+
+>>> student = {
+    "name": "Nikita",
+    "age": 19,
+    "city": "Moscow",
+    "courses": ["Math", "Physics"],
+    "gpa": 2.74
+}
+>>> student
+{'name': 'Nikita', 'age': 19, 'city': 'Moscow', 'courses': ['Math', 'Physics'], 'gpa': 2.74}
+>>> student.get("name")
+'Nikita'
+>>> student.keys()
+dict_keys(['name', 'age', 'city', 'courses', 'gpa'])
+>>> student.values()
+dict_values(['Nikita', 19, 'Moscow', ['Math', 'Physics'], 2.74])
+>>> student.update({"gpa": 4.5, "lazy": True})
+>>> student
+{'name': 'Nikita', 'age': 19, 'city': 'Moscow', 'courses': ['Math', 'Physics'], 'gpa': 4.5, 'lazy': True}
+>>> student.pop("lazy")
+True
+>>> student
+{'name': 'Nikita', 'age': 19, 'city': 'Moscow', 'courses': ['Math', 'Physics'], 'gpa': 4.5}
+>>> student.clear()
+>>> student
+{}
+
+```
+
+Множества
+
+```py
+
+>>> A = {1, 2, 3, 4, 5}
+>>> A.add(6)
+>>> A
+{1, 2, 3, 4, 5, 6}
+>>> A.remove(4)
+>>> A
+{1, 2, 3, 5, 6}
+>>> A.pop()
+1
+>>> A
+{2, 3, 5, 6}
+>>> A.clear()
+>>> A
+set()
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA3/task.md

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

TEMA3/task_module1.md

@@ -0,0 +1,69 @@
+# Тест по модулю 1
+
+Марков Никита Сергеевич, А-03-23
+
+## 7 вариант
+
+### 1)Можно ли работать со средой без использования интерактивной оболочки IDLE?
+
+Да можно работать без IDLE.
+В первой лабораторной работе мы работали в командной строке.
+
+### 2)Создайте объект-словарь с 7 элементами: ключи - названия (аббревиатура) вузов, значения - число студентов (задать произвольно). Напишите инструкцию,  доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта.
+
+```py
+
+>>> msk={
+	"МЭИ" : 52146,
+	"МГУ" : 54831,
+	'МФТИ': 7500,
+	'ВШЭ': 42000,
+	'МГТУ': 18500,
+	'РУДН': 29500,
+	'МИФИ': 8200
+}
+>>> msk
+{'МЭИ': 52146, 'МГУ': 54831, 'МФТИ': 7500, 'ВШЭ': 42000, 'МГТУ': 18500, 'РУДН': 29500, 'МИФИ': 8200}
+>>> type(msk)
+<class 'dict'>
+>>> dir(msk)
+['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__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
+
+>>> total=msk["МФТИ"] + msk["МЭИ"]
+>>> total
+59646
+
+```
+
+### 4)Преобразуйте значения из словаря в список и, затем, список - в строку. Отобразите полученные объекты. Получите новый список, разделением строки на части по разделителю: ",".
+
+```py
+
+>>> strk = ', '.join(str(x) for x in spismsk)
+>>> strk
+'52146, 54831, 7500, 42000, 18500, 29500, 8200, МЭИ, МГУ, МФТИ, ВШЭ, МГТУ, РУДН, МИФИ'
+
+```
+
+### 5) Используя операцию подстановки, отобразить рассчитанное число студентов в 2-х вузах по шаблону: "Число студентов в <название вуза 1> и <название вуза 2> =:". 
+
+```py
+
+print(f"Число студентов в {spismsk[7]} и {spismsk[8]} = {spismsk[0] + spismsk[1]}")
+Число студентов в МЭИ и МГУ = 106977
+
+```
+
+
+
+
+
+
+
+

TEMA4/report.md

@@ -0,0 +1,347 @@
+# Протокол по Теме 4 
+
+Марков Никита Сергеевич, А-03-23
+
+## 1. Начало работы
+
+Запуск IDLE, установление рабочего каталога
+
+## 2. Стандартные функции
+
+### 2.1 Функция round – округление числа с заданной точностью
+
+```py
+
+>>> round(123.456,1)
+123.5
+>>> round(123.456,0)
+123.0
+>>> round(123.456)
+123 
+
+```
+
+
+### 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)
+>>> list(range(23))
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
+
+```
+
+### 2.3. Функция zip
+
+```py
+
+>>> qq = ['Markov','Butko','Ogarkov','Krishtul']
+>>> ff=zip(gg,qq)
+>>> ff
+<zip object at 0x0000026369CB4400>
+>>> tuple(ff)
+((76, 'Markov'), (85, 'Butko'), (94, 'Ogarkov'), (103, 'Krishtul'))
+>>> ff[0]
+Traceback (most recent call last):
+  File "<pyshell#13>", line 1, in <module>
+    ff[0]
+TypeError: 'zip' object is not subscriptable
+
+```
+Нельзя обращаться с указанием индекса, т.к. объект является итерируемым класса zip
+
+### 2.4 Функция eval
+
+```py
+
+>>> fff=float(input('коэффициент усиления=')); dan=eval('5*fff-156')
+коэффициент усиления=5
+>>> dan
+-131.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, divmod, len, map
+
+```py
+
+>>> abs(-14)
+14
+>>> pow(2, 3)
+8
+>>> max(1, 2, 3)
+3
+>>> min(1, 2, 3)
+1
+>>> sum([1, 2, 3])
+6
+>>> divmod(5, 3)
+(1, 2)
+>>> len(range(0, 15+1))
+16
+>>> map_test = map(lambda x: round(x, 1), [12.1245, 14.125234, 534.222])
+>>> list(map_test)
+[12.1, 14.1, 534.2]
+
+```
+
+## 3. Функции из стандартного модуля math
+
+```py
+
+>>> import math
+>>> dir(math)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
+>>> help(math.factorial)
+Help on built-in function factorial in module math:
+
+factorial(x, /)
+    Find x!.
+    
+    Raise a ValueError if x is negative or non-integral.
+
+>>> math.factorial(5)
+120
+>>> math.sin(90)
+0.8939966636005579
+>>> math.acos(0)
+1.5707963267948966
+>>> math.degrees(math.pi)
+180.0
+>>> math.radians(180)
+3.141592653589793
+>>> math.exp(1)
+2.718281828459045
+>>> math.log(10)
+2.302585092994046
+>>> math.log10(100)
+2.0
+>>> math.sqrt(16)
+4.0
+>>> math.ceil(3.14)  # округление вверх
+4
+>>> math.floor(3.14)  # округление вниз
+3
+>>> math.pi
+3.141592653589793
+>>> math.sin((2*math.pi/7) + math.exp(0.23))
+0.8334902641414562
+
+```
+
+## 4. Функции из модуля cmath, c комплексными числами 
+
+```py
+
+>>> import cmath
+>>> dir(cmath)
+['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
+>>> cmath.sqrt(1.2-0.5j)
+(1.118033988749895-0.22360679774997896j)
+>>> cmath.phase(1-0.5j)
+-0.4636476090008061
+
+```
+
+## 5. random
+
+```py
+
+>>> import random
+>>> dir(random)
+['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']
+>>> help(random.seed)
+Help on method seed in module random:
+
+seed(a=None, version=2) method of random.Random instance
+    Initialize internal state from a seed.
+    
+    The only supported seed types are None, int, float,
+    str, bytes, and bytearray.
+    
+    None or no argument seeds from current time or from an operating
+    system specific randomness source if available.
+    
+    If *a* is an int, all bits are used.
+    
+    For version 2 (the default), all of the bits are used if *a* is a str,
+    bytes, or bytearray.  For version 1 (provided for reproducing random
+    sequences from older versions of Python), the algorithm for str and
+    bytes generates a narrower range of seeds.
+
+```
+
+```py
+
+>>> random.random() # вещественное число от 0.0 до 1.0
+0.12874671061082976
+>>> random.uniform(5, 15) # вещественное число от 5.0 до 15.0
+13.134575401523493
+>>> random.randint(1, 100) # целое число от 1 до 100 
+32
+>>> random.gauss(0, 1) # mu - среднее значение, sigma - стандартное отклонение
+-0.07800637063087972
+>>> random.choice([1, 2, 3, 4]) # случайный выбор элемента из списка, кортежа, строки и т.д.
+3
+>>> My_Numbers = [1, 2, 3, 4]
+>>> random.shuffle(My_Numbers)
+>>> My_Numbers
+[1, 2, 4, 3]
+>>> random.sample(My_Numbers, 2) # случайный выбор двух элементов из My_Numbers
+[4, 1]
+>>> random.betavariate(2, 5)
+0.16541871582286427
+>>> random.gammavariate(2, 1)
+0.6551814424330216
+
+```
+
+## 6. time - работа с календарем и временем
+
+```py
+
+>>> import time
+>>> dir(time)
+['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']
+>>> c1=time.time()
+>>> c1
+1760283309.499735
+>>> c2=time.time()-c1
+>>> c2
+10.906989812850952
+>>> dat=time.gmtime()
+>>> dat
+time.struct_time(tm_year=2025, tm_mon=10, tm_mday=12, tm_hour=15, tm_min=35, tm_sec=35, tm_wday=6, tm_yday=285, tm_isdst=0)
+>>> dat.tm_mon
+10
+>>> time.asctime((2024, 12, 10, 18, 7, 14, 1, 345, 0)) #год, месяц, день, час, минута, секунда, день недели, день года, летнее время
+'Tue Dec 10 18:07:14 2024'
+>>> time.ctime(time.time())
+'Sun Oct 12 18:36:59 2025'
+>>> time.mktime((2025, 12, 25, 15, 30, 0, 0, 0, 0))
+1766665800.0
+
+```
+
+## 7. Графические функции
+
+```py
+
+>>> import pylab
+>>> x=list(range(-3,55,4))
+>>> x
+[-3, 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53]
+>>> t=list(range(15))
+>>> 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 0x000002630D20D340>]
+>>> pylab.title('Первый график')
+Text(0.5, 1.0, 'Первый график')
+>>> pylab.xlabel('время')
+Text(0.5, 0, 'время')
+>>> pylab.ylabel('сигнал')
+Text(0, 0.5, 'сигнал')
+>>> pylab.show()
+
+```
+
+**Результат:** 
+
+<image src="Figure_1.png">
+
+```py
+
+>>> X1=[12,6,8,10,7]
+>>> X2=[5,7,9,11,13]
+>>> pylab.plot(X1)
+[<matplotlib.lines.Line2D object at 0x0000026312246130>]
+>>> pylab.plot(X2)
+[<matplotlib.lines.Line2D object at 0x00000263122463D0>]
+>>> pylab.show()
+
+```
+
+**Результат:** 
+
+<image src="Figure_2.png">
+
+```py
+
+>>> region=['Центр','Урал','Сибирь','Юг']
+>>> naselen=[65,12,23,17]
+>>> pylab.pie(naselen,labels=region)
+([<matplotlib.patches.Wedge object at 0x000002631062D130>, <matplotlib.patches.Wedge object at 0x000002631062D1F0>, <matplotlib.patches.Wedge object at 0x000002631063B970>, <matplotlib.patches.Wedge object at 0x000002631063BDF0>], [Text(-0.191013134139045, 1.0832885038559115, 'Центр'), Text(-0.861328292412156, -0.6841882582231001, 'Урал'), Text(0.04429273995539947, -1.0991078896938387, 'Сибирь'), Text(0.9873750693480946, -0.48486129194837324, 'Юг')])
+>>> pylab.show()
+
+```
+
+**Результат:** 
+
+<image src="diag.png">
+
+```py
+
+>>> pylab.bar(region, naselen)
+<BarContainer object of 4 artists>
+>>> pylab.title('Население по регионам')
+Text(0.5, 1.0, 'Население по регионам')
+>>> pylab.ylabel('Население (млн)')
+Text(0, 0.5, 'Население (млн)')
+>>> pylab.show()
+
+```
+
+**Результат:** 
+
+<image src="hist.png">
+
+```py
+
+>>> pylab.hist(naselen)
+(array([2., 0., 1., 0., 0., 0., 0., 0., 0., 1.]), array([12. , 17.3, 22.6, 27.9, 33.2, 38.5, 43.8, 49.1, 54.4, 59.7, 65. ]), <BarContainer object of 10 artists>)
+>>> pylab.title('Гистограмма распределения населения')
+Text(0.5, 1.0, 'Гистограмма распределения населения')
+>>> pylab.xlabel('Население (млн)')
+Text(0.5, 0, 'Население (млн)')
+>>> pylab.ylabel('Частота')
+Text(0, 0.5, 'Частота')
+>>> pylab.show()
+
+```
+
+**Результат:** 
+
+<image src="hist2.png">
+
+## 8. Статистический модуль statistics
+```py
+
+>>> import statistics
+>>> numbers = [1,2,3,4,5,6,7,8,9]
+>>> statistics.mean(numbers)
+5
+>>> statistics.median(numbers)
+5
+>>> statistics.mode(numbers)
+1
+
+```
+

TEMA4/task.md

@@ -0,0 +1,64 @@
+# Общее контрольное задание по теме 4
+
+Марков Никита Сергеевич, А-03-23
+
+## Задание
+
+1.Напишите и исполните единое выражение, реализующее последовательное выполнение следующих операций: вычисление фазы комплексного числа 0.2+0.8j, округление результата до двух знаков после запятой, умножение полученного значения на 20, получение кортежа из двух значений: округленное вниз значение от деления результата на 3 и остатка от этого деления.
+
+2.Создайте объект класса struct_time с временными параметрами для текущего московского времени. Создайте строку с текущим часом и минутами.
+
+3.Создайте список с элементами – названиями дней недели. Сделайте случайную выборку из этого списка с тремя днями недели. 
+
+4.Напишите инструкцию случайного выбора числа из последовательности целых чисел от 14 до 32 с шагом 3.
+
+5.Сгенерируйте нормально распределенное число N с математическим ожиданием 15 и стандартным отклонением 4 и округлите его до целого значения. Создайте список с N элементами – случайно выбранными буквами латинского алфавита.
+
+6.Напишите инструкцию для определения временного интервала в минутах, прошедшего с момента предыдущего (из п.2) определения временных параметров.
+
+## Решение
+
+```py
+
+import cmath 
+import math
+import time
+import random
+import string
+
+# 1
+>>> first = round(cmath.phase(0.2+0.8j), 2) * 20
+>>> divmod(math.floor(first), 3)
+(8, 2)
+
+# 2
+>>> moscow_time = time.localtime()
+>>> string_with_time = f"{moscow_time.tm_hour}:{moscow_time.tm_min}"
+>>> print(string_with_time, type(moscow_time))
+19:1 <class 'time.struct_time'>
+# 3
+>>> days_of_week = ['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']
+>>> random.sample(days_of_week, 3)
+['Четверг', 'Среда', 'Понедельник']
+
+# 4
+>>> numbers = list(range(14, 32+1, 3))
+>>> random.choice(numbers)
+20
+
+#5
+>>> N = round(random.normalvariate(15, 4))
+>>> N
+14
+>>> gen_list = random.choices(string.ascii_uppercase, k=N)
+>>> gen_list
+['A', 'N', 'V', 'L', 'N', 'U', 'O', 'V', 'N', 'R', 'L', 'Z', 'Q', 'R']
+
+#6
+>>> current_time = time.time()
+>>> previous_time = time.mktime(moscow_time)
+>>> time_interval_minutes = (current_time - previous_time) / 60
+>>> time_interval_minutes
+1.379131011168162
+
+```

TEMA4/test.md

@@ -0,0 +1,26 @@
+# Индивидуальное контрольное задание
+
+Марков Никита Сергеевич, А-03-23
+
+## 1 вариант
+
+### Задание
+
+Создайте список1 со значениями от 45 до 235 с шагом 5. Создайте список2 с элементами: 1,2,3,…(число элементов в списке2 должно быть таким же, как и в списке1). Напишите инструкцию создания с использованием двух ранее созданных списков общего списка с элементами- кортежами по образцу: (45,1), (50, 2),… . Выполните эту инструкцию с помощью функции eval.
+
+```py
+
+>>> spis1=list(range(45,235,5))
+>>> spis1
+[45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220, 225, 230]
+>>> len(spis1)
+38
+>>> spis2=list(range(1,len(spis1) + 1))
+>>> spis2
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38]
+>>> instr="list(zip(spis1,spis2))"
+>>> spis12 = eval(instr)
+>>> spis12
+[(45, 1), (50, 2), (55, 3), (60, 4), (65, 5), (70, 6), (75, 7), (80, 8), (85, 9), (90, 10), (95, 11), (100, 12), (105, 13), (110, 14), (115, 15), (120, 16), (125, 17), (130, 18), (135, 19), (140, 20), (145, 21), (150, 22), (155, 23), (160, 24), (165, 25), (170, 26), (175, 27), (180, 28), (185, 29), (190, 30), (195, 31), (200, 32), (205, 33), (210, 34), (215, 35), (220, 36), (225, 37), (230, 38)]
+
+```

TEMA5/report.md

@@ -0,0 +1,324 @@
+# Протокол по Теме 5\ 
+
+Марков Никита Сергеевич, А-03-23
+
+## 1. Начало работы
+
+Запуск IDLE, установление рабочего каталога
+
+## 2. Управляющая инструкция if
+```py
+
+>>> porog = 12
+>>> rashod1 = 10
+>>> rashod2 = 7
+>>> if rashod1>=porog:
+		dohod=12
+elif rashod2==porog:
+		dohod=0
+else:
+		dohod=-8
+
+		
+>>> dohod
+-8
+>>> if rashod1>=3 and rashod2==4:
+		dohod=rashod1
+		if rashod2==porog or rashod1<rashod2:
+			dohod=porog
+
+			
+>>> dohod
+-8
+>>> porog
+12
+```
+### Операция с множественным ветвлением линий потока
+
+```py
+>>> if porog==3:
+		dohod=1
+elif porog==4:
+		dohod=2
+elif porog==5:
+		dohod=3
+else:
+		dohod=0
+
+		
+>>> dohod
+0
+
+```
+
+### Условные инструкции в одну строку
+
+```py
+
+>>> dohod=2 if porog>=4 else 0
+>>> dohod
+2
+>>> if porog>=5 : rashod1=6; rashod2=0
+
+>>> rashod1
+6
+>>> rashod2
+0
+
+```
+
+## 3.Управляющая инструкция for
+
+### 3.1 Простой цикл.
+
+```py
+
+>>> temperatura=5
+>>> for i in range(3,18,3):
+	temperatura+=i
+
+	
+>>> temperatura
+50
+
+```
+
+### 3.2 Более сложный цикл
+
+```py 
+
+>>> sps=[2,15,14,8]
+>>> for k in sps:
+	if len(sps)<=10:sps.append(sps[0])
+	else:break
+
+	
+>>> sps
+[2, 15, 14, 8, 2, 2, 2, 2, 2, 2, 2]
+>>> 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)
+
+	
+>>> ss
+531
+>>> sps5
+[16, 30, 74, 91, 77, 97, 40, 38, 8, 60]
+>>> for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+>>> ss
+578
+>>> for i in range(10):
+	sps5.append(rn.randint(1,100))
+	ss=sum(sps5)
+	if ss>500: break
+else:
+	print(ss)
+
+	
+>>> ss
+607
+>>> sps5
+[16, 30, 74, 91, 77, 97, 40, 38, 8, 60, 47, 29]
+
+```
+
+### 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)]
+>>> sps2
+[0.9092974268256817, 0.49103209793281005, -0.11479080280322804, -0.6767675184643197, -0.9802420445539634, -0.9092974268256817, -0.49103209793281016, 0.11479080280322791, 0.6767675184643196, 0.9802420445539634, 0.9092974268256818, 0.4910320979328103, -0.1147908028032278, -0.6767675184643196, -0.9802420445539632, -0.9092974268256818, -0.4910320979328104, 0.11479080280322768, 0.6767675184643195, 0.9802420445539632, 0.9092974268256819, 0.4910320979328105, -0.11479080280322579, -0.6767675184643194, -0.9802420445539632, -0.9092974268256819, -0.4910320979328106, 0.11479080280322743, 0.6767675184643193, 0.9802420445539632, 0.909297426825682, 0.49103209793281066, -0.1147908028032273, -0.6767675184643192, -0.9802420445539632, -0.909297426825682, -0.4910320979328108, 0.11479080280322719, 0.6767675184643192, 0.9802420445539631, 0.9092974268256822, 0.491032097932814, -0.11479080280322707, -0.676767518464319, -0.9802420445539625, -0.9092974268256822, -0.491032097932811, 0.11479080280323047, 0.6767675184643189, 0.9802420445539625, 0.9092974268256822, 0.4910320979328142, -0.11479080280322682, -0.6767675184643215, -0.9802420445539631, -0.9092974268256808, -0.4910320979328112, 0.11479080280322317, 0.6767675184643187, 0.9802420445539624, 0.9092974268256823, 0.4910320979328082, -0.11479080280322658, -0.6767675184643213, -0.980242044553963, -0.9092974268256838, -0.49103209793281144, 0.11479080280322293, 0.6767675184643186, 0.9802420445539637, 0.9092974268256824, 0.49103209793280844, -0.11479080280322633, -0.6767675184643158, -0.980242044553963, -0.9092974268256839, -0.49103209793281166, 0.11479080280322974, 0.6767675184643184, 0.9802420445539637, 0.9092974268256825, 0.4910320979328149, -0.11479080280321903, -0.6767675184643209, -0.9802420445539629, -0.909297426825681, -0.4910320979328119, 0.11479080280322244, 0.6767675184643129, 0.9802420445539636, 0.9092974268256826, 0.49103209793281505, -0.11479080280322584, -0.6767675184643155, -0.9802420445539644, -0.9092974268256812, -0.49103209793281205, 0.1147908028032222, 0.6767675184643127, 0.980242044553965]
+
+```
+
+## 4.Управляющая инструкция while
+
+### 4.1. Цикл со счетчиком.
+```py
+
+>>> rashod=300
+>>> while rashod:
+	print("Расход=",rashod)
+	rashod-=50
+
+	
+Расход= 300
+Расход= 250
+Расход= 200
+Расход= 150
+Расход= 100
+Расход= 50
+
+```
+
+### 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
+
+```
+
+сигнал на выходе инерционного звена из списка sps2
+
+```py
+
+>>> pylab.figure(figsize=(10, 5))
+<Figure size 1000x500 with 0 Axes>
+>>> pylab.plot(sps2, 'b-', linewidth=2, label='Выходной сигнал')
+[<matplotlib.lines.Line2D object at 0x000002630D0A6760>]
+>>> pylab.title('Сигнал на выходе инерционного звена')
+Text(0.5, 1.0, 'Сигнал на выходе инерционного звена')
+>>> pylab.xlabel('Время (дискретные моменты i)')
+Text(0.5, 0, 'Время (дискретные моменты i)')
+>>> pylab.ylabel('Значение сигнала')
+Text(0, 0.5, 'Значение сигнала')
+>>> pylab.grid(True)
+>>> pylab.legend()
+<matplotlib.legend.Legend object at 0x000002630D08B4C0>
+>>> pylab.show()
+
+```
+
+**Результат:** 
+
+<image src="Figure_1.png">
+
+###  4.3 Определение, является ли число простым
+
+```py
+
+>>> chislo=267
+>>> kandidat =chislo // 2
+>>> while kandidat > 1:
+	if chislo%kandidat == 0: 	# Остаток от деления
+		print(chislo, ' имеет множитель ', kandidat)
+		break 		# else выполняться не будет
+	kandidat -= 1
+else: 			# При завершении цикла без break
+	print(chislo, ' является простым!')
+
+	
+267  имеет множитель  89
+
+```
+
+### 4.4 Инструкция continue
+
+```py
+
+>>> number = 0
+>>> while number < 10:
+    number += 1
+    if number % 2 == 0:  # Если число четное
+        continue        # Пропускаем оставшуюся часть цикла
+    print(f"Нечетное число: {number}")
+
+    
+Нечетное число: 1
+Нечетное число: 3
+Нечетное число: 5
+Нечетное число: 7
+Нечетное число: 9
+
+```
+
+
+
+
+
+
+

TEMA5/task.md

@@ -0,0 +1,35 @@
+# Общее контрольное задание по теме 4
+
+Марков Никита Сергеевич, А-03-23
+
+## Задание
+
+1.Для заданной символьной строки с англоязычным текстом (его можно заимствовать из помощи) определите порядковый номер каждой буквы в английском алфавите.
+
+2.Создайте список со словами из задания данного пункта. Для этого списка – определите, есть ли в нем некоторое заданное значение, и выведите соответствующее сообщение: либо о нахождении элемента, либо о его отсутствии в списке (проверить как с имеющимся, так и с отсутствующим словом).
+
+3.Создайте список студентов вашей группы (3-4 фамилии) и список их средних баллов в летней сессии – в порядке перечисления студентов в первом списке. Создайте еще 2 аналогичных списка для тех же студентов, но в другом порядке, по зимней сессии. Напишите инструкции, позволяющие по указанной (запрошенной и введенной) фамилии студента вывести его средние баллы по двум сессиям.
+
+## Решение
+
+```py
+
+
+
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

TEMA7/report.md

@@ -0,0 +1 @@
+dsfsdfsdfsdsd