doc: уточнено оформление тестов по модулям

README.md

@@ -1,6 +1,7 @@
 # Программное обеспечение автоматизированных систем: лабораторные работы
 
 [Репозиторий с методическими указаниями и заданиями.](http://uit.mpei.ru/git/main/python)
+Обратите внимание на файл с комментариями в репозитории по ссылке.
 
 ## Работа с Git
 
@@ -86,7 +87,7 @@
 
     ## 1.1 Настройка текущего каталога
 
-    ```
+    ```py
     >>> import os
     >>> os.chdir(r"C:\users\u111-19\Desktop\python\TEMA1")
     >>> os.getcwd()
@@ -109,7 +110,7 @@
 
 ### Оформление решений
 
-Решение всех заданий оформляется по образцу:
+Решение всех заданий и тестов оформляется по образцу:
 
     # Общее контрольное задание по теме 2
 
@@ -129,5 +130,8 @@
 
 Для темы 1 вместо «Задания» — «Вопрос», вместо «Решения» — «Ответ».
 
+Для тем 3, 6 и 9 вместо «Индивидуального контрольного задания по теме 3 (6, 9)» —
+«Тест по модулю 1 (2, 3)».
+
 Для тем 8 и 9 раздела «Решение» не нужно,
 вместо этого решение размещается в отдельных файлах `*.py`.

TEMA0/report.md

@@ -6,7 +6,7 @@
 
 ## 1.1 Настройка текущего каталога
 
-```
+```py
 >>> import os
 >>> os.chdir(r"C:\users\u111-19\Desktop\python\TEMA1")
 >>> os.getcwd()

TEMA1/Pr0.py

@@ -1,5 +0,0 @@
-#Программа по Теме 1 Степанищев Виктор Романович
-print('Hello')
-h=input('Your name=')
-import os
-os.chdir(r"/home/byvs/MPEI/Programming Python/Stepanishchev/TEMA1/")

TEMA1/report.md

@@ -1,96 +0,0 @@
-# Отчёт по теме 1
-
-Степанищев Виктор, А-03-23
-
-## 1 Знакомство с интерпретатором 
-
-Введение инструкций в окно интерпретатора
-```py
->>>print('Hello')
-Hello
->>>h=input('Your name=')
-Your name=Viktor
->>>exit()
-```
-
-## 2 Знакомство с интерактивной оболочкой IDLE 
-
-Настройка текущего каталога
-```py
-import os
-os.chdir(r"/home/byvs/MPEI/Programming Python/python-labs/TEMA1/")
-```
-
-Создание Pr0.py в рабочем каталоге и его запуск тремя способами: import Pr0, F5, 'Запустить модуль'
-
-```py
-#Программа по Теме 1 Степанищев Виктор Романович
-print('Hello')
-h=input('Your name=')
-import os
-os.chdir(r"/home/byvs/MPEI/Programming Python/Stepanishchev/TEMA1/")
-```
-
-Запуск prb1.py 
-```py
->>> import prb1
-Как Вас зовут? Viktor
-Привет, Viktor
-```
-
-В папке _pycache_ хранится двоичный скомпилированный код, который нужен для оптимизации загрузки и запуска программы
-
-Раздел помощи help в главном меню IDLE предлагает следующие виды помощи: документацию по IDLE, доку по Python
-и наглядную демонстрацию работы модуля Turtle
-
-```py
->>>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)
-```
-
-Результат работы программы tdemo_chaos.py : 
-<image src="figure0.png">
-
-Демонстрация работы модуля Turtle на примере clock из Turtle Demo в выпадающем меню help:
-<image src="figure1.png">

TEMA2/report.md

@@ -1,492 +0,0 @@
-# Отчёт по теме 2
-Выполнил Степанищев Виктор, А-03-23
-
-# 1. Начало работы
-Запуск IDLE, установление рабочего каталога
-
-# 2. Изучение простых объектов
-```py
->>f1=16; f2=3
->>f1,f2
-(16, 3)
->>f1;f2
-16
-3
->>dir()
-['__annotations__', '__builtins__', '__doc__', '__file__', '__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_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
->>type(f2)
-<class 'int'>
->>del f1,f2
->>dir(f1)
-Traceback (most recent call last):
-  File "<pyshell#7>", line 1, in <module>
-    dir(f1)
-NameError: name 'f1' is not defined
-#Объектов не осталось после del
-```
-# 3. Изучение правил именования объектов
-```py
->>gg1=1.6  
->>hh1='Строка'  
->>73sr=3  
-SyntaxError: invalid decimal literal
->>and=7     
-SyntaxError: invalid syntax
-```
-
-# 4. Просмотр ключевых слов в Python 
-```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']
->>list_keyword = keyword.kwlist
-```
-# 5. Просмотр встроенных идентификаторов 
-```py
->>import builtins
->>dir(builtins)
-['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', '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', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
-```
-Изучение функций **abs**, **len**, **max**, **min**, **pow**, **round**, **sorted**, **sum**, **zip**
-1) abs - возвращает абсолютное значение передаваемого числа 
-```py
->>help(abs)
-Help on built-in function abs in module builtins:
-
-abs(x, /)
-    Return the absolute value of the argument.
->>abs(-4.5)
-4.5
-```
-2) len - возвращает длину (количество элементов) объекта
-```py
->>help(len)
-Help on built-in function len in module builtins:
-
-len(obj, /)
-    Return the number of items in a container.
-
->>len([1, 2, 3])
-3
-```
-3) max -  возвращает наибольший элемент в итерируемом объекте или из нескольких аргументов
-```py
->>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.
-
->>max([1, 2, 3])
-3
-```
-4) min - возвращает наименьший элемент в итерируемом объекте или из нескольких аргументов
-```py
->>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.
-
->>min([1, 2, 3])
-1
-```
-5) pow - возвращает x в степени y, если указан z, возвращает результат по модулю z
-```py
->>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.
-
->>pow(2, 3)
-8
->>pow(2, 3, 3)
-2
-```
-6) 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(14.0214, 2)
-14.02
-```
-7) sorted - возвращает новый отсортированный список из элементов итерируемого объекта
-```py
->>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.
-
->>sorted([3, 2, 1])
-[1, 2, 3]
-```
-8) sum - возвращает сумму всех элементов итерируемого объекта
-```py
->>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.
-
->>sum([1, 2, 3])
-6
-```
-9) zip - объединяет элементы из нескольких итерируемых объектов в кортежи
-```py
->>help(zip)
-Help on class zip in module builtins:
-
-class zip(object)
- |  zip(*iterables, strict=False) --> Yield 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.
- |  
- |  If strict is true and one of the arguments is exhausted before the others,
- |  raise a ValueError.
- |  
- |  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.
- |  
- |  __setstate__(...)
- |      Set state information for unpickling.
- |  
- |  ----------------------------------------------------------------------
- |  Static methods defined here:
- |  
- |  __new__(*args, **kwargs) from builtins.type
- |      Create and return a new object.  See help(type) for accurate signature.
-
->>students = ['Viktor', 'Alexandr']
->>ages = [20, 20]
->>list(zip(students, ages))
-[('Viktor', 20), ('Alexandr', 20)]
-```
-# 6. Малые и большие буквы различаются 
-```py
->>Gg1=45
->>gg1
-1.6
->>Gg1
-45
-```
-# 7. Изучение базовых типов объектов
-## 7.1 Логический тип
-```py
->>bb1=True; bb2=False
->>bb1;bb2
-True
-False
->>type(bb1)   
-<class 'bool'>
-```
-## 7.2 Другие простые типы
-```py
-ii1=-1234567890
-ff1=-8.9876e-12  
-dv1=0b1101010 
-type(dv1)
-<class 'int'>
-vsm1=0o52765  
-shest1=0x7109af6  
-cc1=2-3j
-a=3.67; b=-0.45
-cc2=complex(a,b) 
-```
-
-## 7.3 Строка символов
-```py
-ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
-print(ss1a)
-```
-
-```py
-ss1b= 'Меня зовут: \n Степанищев В.Р.'
-print(ss1b)
-```
-```py
-mnogo="""Нетрудно заметить , что в результате операции
-над числами разных типов получается число,
-имеющее более сложный тип из тех, которые участвуют в операции."""
-print(mnogo)
-```
-```py
->>ss1[17:3:-2]
-'омсаот '
->>ss1[-4:3:-2]
-'омсаот '
-```
-```py
->>ss1[4]='='  
-Traceback (most recent call last):
-  File "<pyshell#95>", line 1, in <module>
-    ss1[4]='='  
-TypeError: 'str' object does not support item assignment
->>ss1=ss1[:4]+'='+ss1[5:]
->>ss1
-'Это = строка символов'
-```
-```py
->>ss1b
-'Меня зовут: 
- Степанищев В.Р.'
->>ss1b[:3]
-'Мен'
->>ss1b[::-1]
-'.Р.В вещинапетС 
- :тувоз янеМ'
-```
-Самостоятельно придумал значения и создал объекты разных типов
-```py
-my_int = 42
-my_float = 3.14159
-my_complex = 2 + 3j
-my_string = "Hello, Python!"
-my_list = [1, 2, "три", 4.0]
-my_tuple = (10, 20, "тридцать")
-my_set = {1, 2, 3, 2, 1}  
-my_dict = {"имя": "Виктор", "возраст": 20, "город": "Москва"}
-my_bool = True
-my_bytes = b"hello"
-my_range = range(5)
-```
-
-# 8. Типы объектов: списки, кортежи, словари, множества
-```py
->>spis1=[111,'Spisok',5-9j]
->>stup=[0,0,1,1,1,1,1,1,1]
->>spis1[-1]
-(5-9j)
-```
-```py
->>stup[-8::2]
-[0, 1, 1, 1]
->>stup
-[0, 0, 1, 1, 1, 1, 1, 1, 1]
-```
-*Сколько элементов вошло в этот новый список и какие индексы они имели в исходном списке?*   
-Ответ: количество эл-ов в новом списке 4, индексы в исходном списке 1, 3, 5, 7
-```py
->>spis1[1]='Список'
->>spis1
-[111, 'Список', (5-9j)]
-len(spis1)
-3
-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.append(ss1b)
->>spis1
-[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Степанищев В.Р.']
->>spis1.pop(1)
-'Список'
->>spis1
-[111, (5-9j), 'New item', 'Меня зовут: \n Степанищев В.Р.']
-```
-*Использование insert, remove, extend, clear, sort, reverse, copy, count, index*
-```py
->>spis1.insert(1, 'string')
->>spis1
-[111, 'string', (5-9j), 'New item', 'Меня зовут: \n Степанищев В.Р.']
-
->>spis1.remove(111)
->>spis1
-['string', (5-9j), 'New item', 'Меня зовут: \n Степанищев В.Р.']
-
->>new_list = [1, 2, 3]
->>spis1.extend(new_list)
->>spis1
-['string', (5-9j), 'New item', 'Меня зовут: \n Степанищев В.Р.', 1, 2, 3]
-
->>new_list.clear()
->>new_list
-[]
-
->>new_list = [3, 1, 2]
->>new_list.sort()
->>new_list
-[1, 2, 3]
-
->>new_list.reverse()
->>new_list
-[3, 2, 1]
-
->>new_list2 = new_list.copy()
->>new_list2
-[1, 2, 3]
-
->>new_list = [1, 2, 2, 2, 3, 3]
->>new_list.count(2)
-3
-
->>new_list = ['one', 'two', 'three']
->>new_list.index('three')
-2
-``` 
-
-```py
->>spis1
-['string', (5-9j), 'New item', 'Меня зовут: \n Степанищев В.Р.', 1, 2, 3]
->>spis2=[spis1,[4,5,6,7]]
->>spis2[0][1]
-(5-9j)
->>spis2[0][1]=78
->>spis2
-[['string', 78, 'New item', 'Меня зовут: \n Степанищев В.Р.', 1, 2, 3], [4, 5, 6, 7]]
->>spis1
-['string', 78, 'New item', 'Меня зовут: \n Степанищев В.Р.', 1, 2, 3]
-```
-*Почему spis1 отличается от изначально заданного?*
-Ответ: spis1 претерпел изменения потому что spis2[0] не является копией spis1, а представляет 
-собой ссылку на тот же самый объект в памяти 
-
-Придумал и создал свой объект-список, элементами которого объекты разных типов: 
-число, строка, логическое значение, список.
-```py
-my_list = [12, 'str', True, [1, 2, 3]]
-my_list
-[12, 'str', True, [1, 2, 3]]
-```
-
-## 8.2 Кортежи
-```py
->>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
->>kort1[2]=90
-Traceback (most recent call last):
-  File "<pyshell#264>", line 1, in <module>
-    kort1[2]=90
-TypeError: 'tuple' object does not support item assignment
->>my_kort = (12, 'str', [1, 2, 3], (222, 'str'))
->>my_kort
-(12, 'str', [1, 2, 3], (222, 'str'))
-```
-## 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 deviation',3:'correlation'}
->>dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
->>dic3['statistics'][2]
-'standart deviation'
->>dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
->>dic4
-{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n Степанищев В.Р.'}
->>dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
->>dic5
-{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Степанищев В.Р.'}
-```
-
-*Создал объект-кортеж с 7 элементами и объект-список с 5 элементами, также из них словарь с помощью функций dict и zip*
-```py
->>t = ("a", "b", "c", "d", "e", "f", "g")
->>l = [1, 2, 3, 4, 5]
->>d = dict(zip(t, l))
->>d
-{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
-```
-Элементов в получившимся словаре - 5, т.к. zip() работает до конца самого короткого объекта (в нашем случае этот объект l)
-
-```py
->>AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,], 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12], 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
->>AVTI['Курс III'][5]
-15
-```
-
-## 8.4 Множества 
-```py
->>mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
->>mnoz1
-{'датчик', 'микропроцессор', 'двигатель', 'линия связи'}
->>len(mnoz1)
-4
->>'датчик' in mnoz1
-True
->>mnoz1.add('реле')
->>mnoz1.remove('линия связи')
-```
-
-```py
->>s = {1, "hello", True, 3.14, (2, 5)}
->>s.add("Python")
->>s
-{1, 3.14, 'hello', (2, 5), 'Python'}
->>s.remove(3.14)
->>s
-{1, 'hello', (2, 5), 'Python'}
-```

TEMA2/task.md

@@ -1,24 +0,0 @@
-# Общее контрольное задание по теме 2
-
-Степанищев Виктор, А-03-23
-
-## Задание
-Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкции
-
-## Решение
-```py
-import keyword
-familia = 'Stepanishchev'
-first_word = familia[0]
-sp_kw = keyword.kwlist
-print('nonlocal' in sp_kw)
-sp_kw.remove('nonlocal')
-print('nonlocal' in sp_kw)
-kort_nam = ('Viktor', 'Alexander', 'Ilya', 'Nikita')
-print(type(kort_nam))
-kort_nam += ('Emil', 'Zahar')
-print(kort_nam)
-print(kort_nam.count('Дима'))
-dict_bas = {'Список':[1,2,4], 'Множество':{1,2,3,4},'Словарь':{'key':'value'}}
-print(dict_bas)
-```

TEMA3/report.md

@@ -1,716 +0,0 @@
-# Отчёт по теме 3
-Выполнил Степанищев Виктор, А-03-23
-
-## 1. Начало работы
-Запуск IDLE, установление рабочего каталога
-
-## 2. Преобразование простых базовых типов объектов
-### 2.1 Преобразование в логический тип с помощью функции bool
-```py
->>> logiz1=bool(56) # 56 не ноль, поэтому True (любое число не равное нулю - True)
->>> logiz2=bool(0) # 0 - ноль, поэтому False 
->>> logiz3=bool("Beta") # строка не пустая (имеет длину не равную нулю) - True 
->>> logiz4=bool("")  # строка пустая, кол-во символов 0 - False
->>> logiz1
-True
->>> logiz2
-False
->>> logiz3
-True
->>> logiz4
-False
-```
-### 2.2 Преобразование в целое десятичное число / в вещественное число
-```py
->>> tt1=int(198.6) # отбрасывается дробная часть (без округления)
->>> tt2=int("-76") # число в строке символов (-76), система счисления не указана как параметр - по дефолту десятичная
->>> tt3=int("B",16) # перевод в 16-ричную
->>> tt4=int("71",8) # перевод в 8-ричную
-
->>> tt1
-198
->>> tt2
--76
->>> tt3
-11
->>> tt4
-57
-```
-Диагностическая ошибка 
-```py
->>> 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() ожидает увидеть целочисленное значение в строке, решение проблемы - 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'
-```
-Обратное преобразование: 
-```py
->>> int(dv1, 2)
-123
->>> int(vos1, 8)
-123
->>> int(shs1, 16)
-123
-```
-
-## 3. Преобразование более сложных базов типов объектов
-### 3.1 Преобразование в строку
-```py
->>> strk1=str(23.6)
->>> strk2=str(logiz3)
->>> strk3=str(["A","B","C"])
->>> strk4=str(("A","B","C"))
->>> strk5=str({"A":1,"B":2,"C":9})
-```
-Вывод
-```py
->>> strk1
-'23.6'
->>> strk2
-'True'
->>> strk3
-"['A', 'B', 'C']"
->>> strk4
-"('A', 'B', 'C')"
->>> strk5
-"{'A': 1, 'B': 2, 'C': 9}"
-```
-
-### 3.2 Преобразование эл-ов объекта в список с помощью list()
-```py
->>> spis1=list("Строка символов")
->>> spis2=list((124,236,-15,908))
->>> spis3=list({"A":1,"B":2,"C":9})
-```
-Вывод
-```py
->>> spis1
-['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в']
->>> spis2
-[124, 236, -15, 908]
->>> spis3
-['A', 'B', 'C']
-```
-Задание:
-
- Придумайте инструкцию, обеспечивающую создание из того же словаря списка с другими его частями.
-
-Решение: 
-```py
->>> spis3=list({"A":1,"B":2,"C":9}.values())
->>> spis3
-[1, 2, 9]
-```
-### 3.3 Преобразование элементов объектов в кортеж 
-```py
->>> kort7=tuple('Строка символов')
->>> kort8=tuple(spis2)
->>> kort9=tuple({"A":1,"B":2,"C":9})
-```
-Вывод 
-```py
->>> kort7
-('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
->>> kort8
-(124, 236, -15, 908)
->>> kort9
-('A', 'B', 'C')
-```
-```py
->>> kort9=tuple({"A":1,"B":2,"C":9}.values()) # уже по значениям
-```
-Вывод
-```py
->>> kort9
-(1, 2, 9)
-```
-### 3.4 Удаление объектов
-```py
->>> del strk5, kort8
-```
-Проверка на наличие переменных после удаления
-```py
->>> strk5
-Traceback (most recent call last):
-  File "<pyshell#150>", line 1, in <module>
-    strk5
-NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
->>> kort8
-Traceback (most recent call last):
-  File "<pyshell#151>", line 1, in <module>
-    kort8
-NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
-```
-Задание: 
-
-Создайте строку со своей фамилией и инициалами, преобразуйте её в список, затем список – в кортеж и, наконец, кортеж – в строку
-
-Ответ: 
-
-```py
->>> fio = 'Stepanishchev V.R.'
->>> list_fio = list(fio)
->>> cort_fio = tuple(list_fio)
->>> str_fio = str(cort_fio)
-```
-Вывод:
-```py
->>> list_fio
-['S', 't', 'e', 'p', 'a', 'n', 'i', 's', 'h', 'c', 'h', 'e', 'v', ' ', 'V', '.', 'R', '.']
->>> cort_fio
-('S', 't', 'e', 'p', 'a', 'n', 'i', 's', 'h', 'c', 'h', 'e', 'v', ' ', 'V', '.', 'R', '.')
->>> str_fio
-"('S', 't', 'e', 'p', 'a', 'n', 'i', 's', 'h', 'c', 'h', 'e', 'v', ' ', 'V', '.', 'R', '.')"
-```
-
-## 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
->>> c=-24.6//12.1
-```
-Вывод результата и типа каждого объекта
-```py
->>> type(b)
-<class 'int'>
->>> b
-3
-
->>> type(c)
-<class 'float'>
->>> c
--3.0
-```
-Если в целочисленном делении используется хотя бы один объект вещественного типа - результат будет вещественным,
-если оба целых объекта - результат целый
-
-Самостоятельно попробовал смешанные комбинации типов чисел в этой операции:
-```py
->>> lol = 145.2 // 2
-```
-Вывод: 
-```py
->>> type(lol)
- <class 'float'>
->>> lol
-72.0
-```
-### 4.5 Получение остатка от деления
-```py
->>> 148%33
-16
->>> 12.6%3.8
-1.2000000000000002
-```
-Самостоятельно попробовал смешанные комбинации типов чисел в этой операции:
-```py
->>> 158.6 % 6
-2.5999999999999943
-```
-Если в остатке от деления используется хотя бы один объект вещественного типа - результат будет вещественным,
-если оба целых объекта - результат целый
-## 4.6 Возведение в степень 
-```py
->>> 14**3
-2744
->>> e=2.7**3.6
->>> e
-35.719843790663525
-```
-Самостоятельно попробовал смешанные комбинации типов чисел в этой операции:
-```py
->>> 5**3.2
-172.4662076826519
-```
-Вопрос:
-
- Какие из приведенных выше операций можно применять к комплексным числам, а какие – нет?
-
-Ответ:
-
-К комплексным числам можно применять следующие операции:
-1) сложение
-2) вычитание
-3) умножение
-4) деление
-5) возведение в степень 
-
-и нельзя следующие: 
-1) целочисленное деление
-```py
->>> z1 = 3 + 4j
->>> z2 = 1 + 2j
->>> z1 // z2
-Traceback (most recent call last):
-  File "<pyshell#255>", line 1, in <module>
-    z1 // z2
-TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
-```
-(целочисленное деление требует целой части, не мнимой)
-
-2) остаток от деления
-```py
->>> z1 = 3 + 4j
->>> z2 = 1 + 2j
->>> z1 % z2
-Traceback (most recent call last):
-  File "<pyshell#257>", line 1, in <module>
-    z1 % z2
-TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
-```
-(остаток от деления по сути основан на целочисленном делении, также работа с мнимой частью не предусмотрена)
-
-## 5. Операции с двоичными представлениями целых чисел
-### 5.1 Двоичная инверсия ~
-```py
->>> dv1=9
->>> dv2=~dv1
->>> dv2
--10
-```
-Почему результат отрицательный - используется дополнительный код (two's complement) для представления отрицательных чисел. Формула результата:
-
-**~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 #Двоичное представление = 1110
->>> g=h<<2 # Новое двоичное представление = 111000
->>> g1=h>>1 # Новое двоичное представление = 0111
->>> g2=h>>2 # Новое двоичное представление = 0011
-```
-Задание: 
-
-Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.
-
-Ответ: 
-```py
->>> a = 181 
->>> b = 108
->>> a & b
-36
->>> a | b
-253
->>> a ^ b
-217
-```
-По условию минимум 7 знаков:
-```py
->>> bin(a)[2:]
-'10110101'
->>> bin(b)[2:]
-'1101100'
-```
-
-## 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=-12
->>> zz
--12
->>> zz+=5
->>> zz-=3
->>> stroka='Система'
->>> stroka+=' регулирования'
->>> zz
--10
->>> stroka
-'Система регулирования'
-```
-### 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
-```py
->>> zz/=2
->>> zz*=5
-```
-Попробовал самостоятельно 
-
-```py
->>> aaa = 5
->>> aaa *= 3
->>> aaa
-15
->>> aaa /= 5
->>> aaa
-3.0
-```
-### 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
-```py
->>> aaa = 5
->>> aaa //= 2
->>> aaa
-2
-
->>> aaa = 5
->>> aaa %= 2
->>> aaa
-1
-
->>> aaa=5
->>> aaa **= 3
->>> aaa
-125
-```
-### 7.5.	 Множественное присваивание
-```py
->>> w=v=10
->>> n1,n2,n3=(11,-3,'all')
-
->>> n1,n2,n3
-(11, -3, 'all')
->>> w,v
-(10, 10)
-```
-Задание: 
-
-Самостоятельно проверьте, можно ли вместо кортежа справа использовать строку, список, словарь, множество?
-
-Ответ:
-
-Со списком работает поэлементно, со строками посимвольно, с множествами работает, но не в той очередности присваивания, со словарем работает, но нужно знать что присваивать - ключи либо значения
-
-## 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
-```
-Задание: 
-
-Придумайте самостоятельно еще 2-3 примера сложных логических выражений. 
-
-Ответ: 
-```py
->>> (a == b) and ('Vologda' in dic1) or ('Pskov' in dic1)
-False
->>> (a > b) or 'book' in mnoz1
-True
->>> 'cap' in mnoz1 or a >= b
-True
-```
-### 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.find('пр')
-5
->>> stroka
-'Микропроцессорная система управления'
->>> stroka.count("с")
-4
->>> stroka.replace(' у',' автоматического у')
-'Микропроцессорная система автоматического управления'
->>> spis22=stroka.split(' ')
->>> spis22
-['Микропроцессорная', 'система', 'управления']
->>> stroka.upper()
-'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
->>> stroka3=" ".join(spis22)
->>> stroka3.partition("с")
-('Микропроце', 'с', 'сорная система управления')
->>> stroka3.rpartition("с")
-('Микропроцессорная си', 'с', 'тема управления')
->>> dont_shout_please = stroka.lower()
-```
-```py
->>> strk1='Момент времени {}, значение = {}'
->>> strk1.format(1,89.7)
-'Момент времени 1, значение = 89.7'
->>> strk2='Момент времени {1}, значение = {0}:{2}'
->>> strk2.format(36.7,2,'норма!')
-'Момент времени 2, значение = 36.7:норма!'
-# порядки расставлены так, как указаны индексы в строке strk2 - на позицию 0 ставится самый первый эл-нт передаваемый в format() и т.д.
-```
-```py
->>> strk3='Момент времени {num}, значение = {znch}'
->>> strk3.format(znch=89.7,num=2)
-'Момент времени 2, значение = 89.7'
-```
-### 9.2. Методы для работы со списками. 
-```py 
->>> spsk = [1, 'A-03-23', 5.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)
-5.0
->>> spsk
-[1, 'A-03-23', (1, 2, 3), True]
->>> spsk.append('c')
->>> spsk
-[1, 'A-03-23', (1, 2, 3), True, 'c']
->>> spsk.insert(2,'a')
->>> spsk
-[1, 'A-03-23', 'a', (1, 2, 3), True, 'c']
->>> spsk.count('a')
-1
->>> spsk
-[1, 'A-03-23', 'a', (1, 2, 3), True, 'c']
-```
-Задание: 
-
-Проанализируйте смысл операций, выполненных с помощью этих методов
-
-Ответ:
-
-1) методом pop() удалили 2-ой эл-т списка (2-ой начиная с нуля)
-2) добавили 'c' в конец списка (метод append() всегда добавляет элемент в конец списка)
-3) методом insert() на позицию 2 (также начиная с нуля) вставили строку 'a'
-4) методом count() посчитали количество вхождений элемента 'a' в список 
-
-### 9.3. Самостоятельно создайте кортеж и изучите применение его методов.
-```py
->>> my_tuple = ('str', 20, (1, 2, 3), True) 
->>> my_tuple.count(20) 
-1
->>> my_tuple.index(True) # позиция True в кортеже
-3
-```
-### 9.4.Также самостоятельно изучите методы словарей и множеств.
-**Словари**
-
-```py
->>> student = {
-    "name": "Viktor",
-    "age": 20,
-    "city": "Moscow",
-    "courses": ["Math", "Physics"],
-    "gpa": 2.85
-}
->>> student.get("name")
-'Viktor'
->>> student.keys()
-dict_keys(['name', 'age', 'city', 'courses', 'gpa'])
->>> student.values()
-dict_values(['Viktor', 20, 'Moscow', ['Math', 'Physics'], 2.85])
->>> student.update({"gpa": 4.5, "lazy": True})
->>> student
-{'name': 'Viktor', 'age': 20, 'city': 'Moscow', 'courses': ['Math', 'Physics'], 'gpa': 4.5, 'Lazy': True}
->>> student.pop("Lazy")
-True
->>> student
-{'name': 'Viktor', 'age': 20, '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(6)
->>> A
-{1, 2, 3, 4, 5}
->>> A.pop() 
-1
->>> A
-{2, 3, 4, 5}
->>> A.clear()
->>> A
-set()
-```

TEMA3/task.md

@@ -1,106 +0,0 @@
-# Общее контрольное задание по теме 3
-
-Степанищев Виктор, А-03-23
-
-## Задание
-Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
-
-•	Преобразовать восьмеричное значение 45 в целое число.
-
-•	Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
-
-•	Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
-
-•	Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
-
-•	Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
-
-•	Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
-
-•	Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
-
-## Решение
-
-**1.**
-```py
-task1 = int('45', 8)
-print(task1)
-```
-Вывод
-```py
-37
-```
-
-
-**2.**
-```py
-D = {"усиление":23, "запаздывание":12, "постоянная времени":78}
-D_keys, D_values = list(D.keys()), list(D.values())
-D_cort = tuple(D_keys + D_values)
-print(D_cort)
-```
-Вывод
-```py
-('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
-```
-*Вопрос:*
-
-Чем отличается кортеж от списка?
-
-*Ответ:*
-
-Список изменяемый, кортеж неизменяемый
-
-**3.**
-```py
-task3 = ((1768 // 24.8) % 3)**2.4
-print(task3)
-```
-Вывод
-```py
-5.278031643091577
-```
-**4.**
-```py
-task4 = (~(13 & 27)^14) << 2
-print(task4)
-```
-Вывод
-```py
--32
-```
-**5.**
-```py
-task5 = ['колебат', 'колебат', 'колебат', 'колебат']
-check = 'аткол' in (task5[2] + task5[3])
-print(check)    
-```
-Вывод
-```py
-True
-```
-**6.**
-```py
-task6 = dir(D)
-D_values, D_keys = D.values(), D.keys() 
-print(D_values)
-print(D_keys)
-```
-Вывод
-```py
-dict_values([23, 12, 78])
-dict_keys(['усиление', 'запаздывание', 'постоянная времени'])
-```
-**7.**
-```py
-task7 = "Создать объект - символьную строку с текстом данного предложения"
-only_words = task7.split(' ')
-index_of_replace_symbol = only_words.index('-')
-only_words[index_of_replace_symbol] = ','
-only_words.remove('данного')
-print(only_words)
-```
-Вывод
-```py
-['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения']
-```

ТЕМА1/test.md

@@ -1,11 +0,0 @@
-# Общее контрольное задание по теме 1
-
-Степанищев Виктор, А-03-23
-
-## Вопрос
-
-Что означает название интерактивной оболочки IDLE?
-
-## Ответ
-
-IDLE - Integrated Development and Learning Environment (интегрированная среда для разработки и обучения на ЯП python)