Tema3/task.md

TEMA1/Pr0.py

@@ -0,0 +1,5 @@
+#Программа по Теме 1 Филиппов Даниил Юрьевич
+print('Hello')
+h=input('Your name=')
+import os
+os.chdir('C:\\Users\\danii\\Desktop\\Filippov\\Tema1\\')

TEMA1/report.md

@@ -0,0 +1,149 @@
+# Отчёт по теме 1: Знакомство с интерпретатором и интерактивной оболочкой IDLE
+
+Филиппов Даниил Юрьевич, А-01-23
+
+# 1. Создание рабочей папки и подкаталогов
+# 2. Запуск на выполнение программы-интерпретатора
+# 3. Изучение содержания открывшегося окна
+# 4. Ввод инструкции 
+```py
+     >>>print('Hello')
+     Hello
+```
+
+# 5. Ввод ещё одной инструкции
+```py
+     >>>h=input('Your name=')
+     Your name=Daniil
+```
+
+# 6. Завершение работы с интерпретатором
+```py
+     >>>exit()
+```
+
+
+# 7. Запуск интерактивной графической оболочки IDLE 
+# 8. Введение инструкции настройки рабочего каталога среды
+```py
+     >>>import os
+     >>>os.chdir('C:\\Users\\danii\\Desktop\\Filippov\\Tema1\\')
+```
+
+# 9. Изучение выпадающих меню, изменение типа, размера шрифта; изменение размера начального окна; изменение цвета комментариев
+
+Шрифт изменен на Arial CYR, размер 11, размер начального окна 50*100 символов,
+комментарии подсвечиваются коричневым
+
+# 10. Создание программного файла Pr0.py в рабочем каталоге, и вставка в него использованных ранее инструкций. Запуск инструкций на выполнение.
+```py
+            #Программа по Теме 1 Филиппов Даниил Юрьевич
+            >>>print('Hello')
+            >>>h=input('Your name=')
+            >>>import os
+            >>>os.chdir('C:\\Users\\danii\\Desktop\\Filippov\\Tema1\\')
+```
+
+# 11. Рассмотрение других способов запуска программы на выполнение:
+     с помощью инструкции import Pr0
+```py
+	>>>import Pr0
+	     
+	hello
+
+	Your name = 
+```
+
+    c помощью клавиши F5:
+```py
+	======= RESTART: C:\Users\Danii\Рабочий стол\FilippovDY\python-labs\TEMA1\Pr0.py ======
+
+	hello
+
+	Your name = 
+```
+
+# 12. Запуск программы prb1.py
+Из консоли вызван файл prb1.py
+```py
+       >>>import prb1
+       Как Вас зовут? Daniil
+       Привет, Daniil
+```
+
+# 13. Изучение каталога `__pycache__`. Открытие файла Pr0.cpython-34.pyc в текстовом редакторе - этот файл результат работы компилятора среды.
+Содержание файла Pr0.cpython-34.pyc:
+
+              у
+    nEµhѕ   г                   уP   • \ " S 5
        \
" S
5
      rSSKr\R                  " S5
        g)ЪHelloz
+    Your name=й    Nz&C:\Users\danii\Desktop\Filippov\Tema1\)   ЪprintЪinputЪ
hЪosЪchdir© у    Ъ,C:\Users/danii/Desktop/Filippov/Tema1    \Pr0.pyЪ<module>r    
   s&   р


б Ђg„Щ €    УЂ
Ы 	Ш ‡‚Р	7Х 8r
+   
+Это скомпилированный байт-код. При выполнении скрипта Python сначала
+преобразовывает его в байт-код (.рус), а затем уже он выполняется с
+помощью виртуальный машины. Это ускорит повторную загрузку программы, так как будет пропущен этап преобразования в байт-код.
+
+
+# 14. Открытие нового окна в текстовом редакторе IDLE. Сохранение в него всех корректно выполненных инструкций из командного окна
+
+# 15. Изучение раздела помощи Help
+
+# 16. Ввод инструкции обращения к оперативной помощи по функции print() - вывод значений указываемого объекта на заданное устройство.
+```py
+        >>>help (print)
+	     
+		Help on built-in function print in module builtins:
+
+		print(...) 
+			print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+			Prints the values to a stream, or to sys.stdout by default.
+			Optional keyword arguments:
+			file:  a file-like object (stream); defaults to the current sys.stdout.
+			sep:   string inserted between values, default a space.
+			end:   string appended after the last value, default a newline.
+			flush: whether to forcibly flush the stream.
+```
+
+# 17. Убедился в том, что можно в одной строке ввести несколько инструкций, разделяя их запятыми
+```py
+	>>>help(print), help(input)
+	     
+		Help on built-in function print in module builtins:
+
+		print(...)
+    			print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+    			Prints the values to a stream, or to sys.stdout by default.
+    			Optional keyword arguments:
+    			file:  a file-like object (stream); defaults to the current sys.stdout.
+    			sep:   string inserted between values, default a space.
+    			end:   string appended after the last value, default a newline.
+    			flush: whether to forcibly flush the stream.
+
+		Help on built-in function input in module builtins:
+
+		input(prompt=None, /)
+    			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)
+```
+
+К оперативной помощи также можно обращаться через клавишу F1, в разделе "Указатель" находится список терминов языка. Нахождение в этом списке строки print() (built-in function), изучение справки.
+
+
+# 18. Последовательное выполнение следующих действий
+Открытие в текстовом редакторе файла prb1.py
+Изучение поочередной активации окон в среде
+Запуск программы prb1.py
+Используя инструкцию import, запуск программы из файла
+
+
+```py
+       >>>import tdemo_chaos
+```
+
+Демонстрация различных примеров программ, текст программы - слева, результат - справа.
+
+# 19. Завершение работы со средой

TEMA1/test.md

@@ -0,0 +1,8 @@
+ # Вопрос
+Можно ли создавать программы для среды Python с помощью других текстовых редакторов?
+
+ # Ответ
+Программы для среды Python можно создавать и с помощью других текстовых редакторов, например:
+Visual Studio Code (VS Code), PyCharm, Jupyter Notebook. Также можно использовать простой текстовый редактор - блокнот, но в отличии от предыдущих текстовых редакторов в нём нет подсветки синтаксиса, автодополнения и отладки.
+
+В данной лабораторной работе мы пользовались IDLE Python и её встроенным редактором.

TEMA2/report.md

@@ -0,0 +1,603 @@
+ # Отчёт по теме 2: Базовые типы объектов
+
+ Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск оболочки IDLE и установка рабочего каталога
+```py
+        >>> import os
+        >>> os.chdir('C:\\Users\\danii\\Desktop\\FilippovDY\\python-labs\\TEMA2\\')
+```
+
+ # 2. Изучение простых объектов. Операции присваивания значения объектам-переменным
+Операция присваивания
+```py
+        >>> f1=16; f2=3
+```
+
+Какое значение имеет переменная:
+```py
+        >>> f1,f2
+        (16, 3)
+        >>> f1;f2
+        16
+        3
+```
+
+Какие объекты существуют в данный момент в среде:
+```py
+        >>> dir()
+        ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
+```
+
+`__annotations__` — хранит аннотации типов переменных, функций и классов в модуле
+`__builtins__` — список строенных идентификаторов 
+`__doc__` — строка документации модуля 
+`__loader__` — объект, который загрузил модуль
+`__name__` — имя модуля 
+`__package__` — имя пакета, к которому принадлежит модуль
+ 
+Получение списка атрибутов любого объекта, например f1:
+```py
+        >>> dir(f1)
+        ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
+```
+
+Определение классовой принадлежности объекта
+```py
+        >>> type(f2)
+        <class 'int'>
+```
+
+Удаление объекта из оперативной памяти:
+```py
+        >>> del f1,f2
+        >>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
+```
+
+ # 3. Правила именования объектов
+Правила именования: 
+ имена должны состоять из латинских букв, цифр и символов подчеркивания;
+ имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
+ имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
+ большие и малые буквы в именах различаются (имена – чувствительные к регистру)!
+```py
+        >>> gg1=1.6  #значение в виде вещественного числа
+        >>> hh1='Строка'  #значение в виде символьной строки
+        >>> 73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
+        SyntaxError: invalid decimal literal
+        >>> and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!
+        SyntaxError: invalid syntax
+```
+
+ # 4. Вывод списка ключевых слов 
+```py
+        >>> import keyword
+        >>> keyword.kwlist
+        ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```py
+        >>> s=keyword.kwlist #Сохранение списка в переменной s
+        >>> s
+        ['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']
+```
+
+ # 5. Вывод списка встроенных идентификаторов
+```py
+        >>> import builtins
+        >>> dir(builtins)
+        ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '_IncompleteInputError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',   'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+
+ # 5.1 Изучение назначения функций: abs, len, max, min, pow, round, sorted, sum, zip
+
+Взятие модуля:
+```py
+        >>> abs(-6)
+	6
+```
+
+Длина списка:
+```py
+	>>> len([1, 2, 3])
+	3
+```
+
+Выбор максимального и минимального значения:
+```py
+	>>> max(5, 15)
+	15
+	>>> min (15, 12)
+	12
+```
+
+Возведение в степень:
+```py
+	>>> pow (5, 2)
+	25
+```
+
+Округление до целого:
+```py
+	>>> round (3,1514)
+	3
+```
+
+Сортировка по возрастанию (можно применить reverse = True для сортировки по убыванию):
+```py
+	>>> sorted ([1,2,8,-5,3])
+        [-5, 1, 2, 3, 8]
+        >>> sorted ([1,2,8,-5,3], reverse=True)
+        [8, 3, 2, 1, -5]
+```
+
+Суммирование:
+```py
+	>>> sum ([7, 3, 5])
+	15
+```
+
+Объединение последовательности объектов в последовательность кортежей:
+```py
+        >>> list1=[1,2,5]
+        >>> list1
+        [1, 2, 5]
+        >>> list2=[5,6,10]
+        >>> zip(list1,list2)
+        <zip object at 0x000002A0E60631C0>
+```
+
+
+ # 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
+        >>> ii1
+        -1234567890
+        >>> ff1=-8.9876e-12  #экспоненциальная форма записи вещественного числа
+        >>> dv1=0b1101010 #Это – двоичное число.
+        >>> type(dv1)
+        <class 'int'>
+        >>> vsm1=0o52765   #Это – восьмеричное число
+        >>> shest1=0x7109af6  #Это – шестнадцатеричное число
+        >>> cc1=2-3j
+        >>> a=3.67; b=-0.45
+        >>> cc2=complex(a,b)  #Создается комплексное число
+        >>> cc2
+        (3.67-0.45j)
+```
+
+ ## 7.3 Строка символов
+```py
+        >>>ss1='Это - строка символов'
+        >>>ss1
+        'Это - строка символов'
+```
+
+Строки можно записать и в двойные кавычки
+```py
+        >>>ss1="Это - строка символов"
+        >>>ss1
+        'Это - строка символов'
+```
+
+Внутри строк можно использовать экранированные последовательности, начинающиеся со знака \
+```py
+        >>>ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
+        >>>print(ss1a)
+        Это - " строка символов ", 
+ 	       выводимая на двух строках
+```
+
+Создание строки по шаблону:
+```py
+        >>>ss1b= 'Меня зовут: \n FilippovDY'
+        >>>print(ss1b)
+        Меня зовут: 
+        FilippovDY
+        >>>ss1b
+        'Меня зовут: \n FilippovDY'
+```
+
+Многострочные строки можно задавать в виде объекта с использованием тройных кавычек:
+```py
+        >>>mnogo="""Нетрудно заметить , что в результате операции
+        над числами разных типов получается число,
+        имеющее более сложный тип из тех, которые участвуют в операции."""
+        >>>print(mnogo)
+        Нетрудно заметить , что в результате операции
+        над числами разных типов получается число,
+        имеющее более сложный тип из тех, которые участвуют в операции.
+```
+
+Обращение к частям строки символов с использованием индексов символов по их порядку в строке. Нумерация символов начинается с 0.
+```py
+        >>> ss1[0]   #Это – символ «Э»
+        'Э'
+        >>> ss1[8]   #Это – символ «р»
+        'р'
+        >>> ss1[-2]  #А это – символ «о» (при знаке «-»(минус) отсчет от конца строки)
+        'о'
+        >>> ss1[6:9]  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)
+        'стр'
+        >>> ss1[13:]  #Это часть строки – с 13-го индекса и до конца
+        'символов'
+        >>> ss1[:13]  #Это часть строки – с начала и до 12-го индекса включительно
+        'Это - строка '
+        >>> ss1[5:-8]  #Это часть строки – с 5-го индекса и до 8-го от конца
+        ' строка '
+        >>> ss1[3:17:2]  #Часть строки – с 3-го по 16-й индексы с шагом 2
+        '  тоасм'
+```
+
+Указываемая правая граница в срез не включается, при отрицательном значении шага получается следующее
+```py
+        >>> ss1[17:3:-2]
+        'омсаот '
+        >>> ss1[-4:3:-2]
+        'омсаот '
+        >>> ss1
+        'Это - строка символов'
+```
+
+Строка является неизменяемым объектом
+```py
+        >>> ss1[4]='='  # Будет диагностика!
+        TypeError: 'str' object does not support item assignment
+```
+
+Однако, можно переопределить строку
+```py
+        >>> ss1=ss1[:4]+'='+ss1[5:]
+        >>> ss1
+        'Это = строка символов'
+```
+
+Создание объекта с разными срезами исходной строки
+```py
+        >>>ss1b_1=ss1b[::-1]
+        >>>print(ss1b_1)
+        >ылаицини и юилимаф юовс етьватсв адюс< 
+         :тувоз янеМ
+```
+
+Создание объектов разных типов
+```py
+        >>> number1=45
+        >>> type(number1)
+        <class 'int'>
+        >>> number2='Число'
+        >>> type(number2)
+        <class 'str'>
+```
+
+ # 8. Изучение более сложных типов объектов
+ ## 8.1 Список
+Список – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания.
+```py
+        >>> spis1=[111,'Spisok',5-9j] #Список с тремя элементами рахных типов
+        >>> spis1
+        [111, 'Spisok', (5-9j)]
+        >>> stup=[0,0,1,1,1,1,1,1,1] #Список, содержащий последовательность отсчётов сигнала в виде "единичной ступеньки"
+        >>> spis=[1,2,3,4,
+        ...       5,6,7,
+        ...       8,9,10] #Список можно вводить на нескольких строках
+```
+
+Можно использовать индексы точно также, как и с элементами символьной строки
+```py
+        >>> spis1[-1]
+        (5-9j)
+        >>> stup[-8::2]
+        [0, 1, 1, 1]
+        >>> spis1[1]='Список'
+        >>> spis1
+        [111, 'Список', (5-9j)]
+```
+
+Текущее число элементов
+```py
+        >>> len(spis1)
+        3
+```
+
+С помощью методов объектов-списков можно добавлять и удалять элементы:
+```py
+        >>> 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')  # В конец списка добавлен элемент «New item»
+        >>> spis1
+        [111, 'Список', (5-9j), 'New item']
+```
+
+Или по-другому конкатенация (в этой инструкции список отображается, но не сохраняется):
+```py
+        >>> spis1+['New item']
+        [111, 'Список', (5-9j), 'New item', 'New item']
+```
+
+Добавление в конец списка spis1 строку ss1b:
+```py
+        >>> spis1.append(ss1b)
+        >>> spis1
+        [111, 'Список', (5-9j), 'New item', 'Меня зовут: \n <сюда вставьте свою фамилию и  инициалы>']
+        >>> spis1 += ss1b
+        >>> spis1
+        [111, 'Список', (5-9j), 'New item', 'Меня зовут: \n <сюда вставьте свою фамилию и инициалы>', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', '<', 'с', 'ю', 'д', 'а', ' ', 'в', 'с', 'т', 'а', 'в', 'ь', 'т', 'е', ' ', 'с', 'в', 'о', 'ю', ' ', 'ф', 'а', 'м', 'и', 'л', 'и', 'ю', ' ', 'и', ' ', 'и', 'н', 'и', 'ц', 'и', 'а', 'л', 'ы', '>']
+```
+
+Удаление элемента из списка:
+```py
+        >>> spis1.pop(1)   #Из списка удален элемент с индексом 1
+        'Список'
+```
+
+Вставка элемента в определенное место по индексу:
+```py
+        >>> spis1.insert(1, "hello")
+        >>> spis1
+        [111, 'hello', (5-9j), 'New item', 'Меня зовут: \n FilippovDY', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', '<', 'с', 'ю', 'д', 'а', ' ', 'в', 'с', 'т', 'а', 'в', 'ь', 'т', 'е', ' ', 'с', 'в', 'о', 'ю', ' ', 'ф', 'а', 'м', 'и', 'л', 'и', 'ю', ' ', 'и', ' ', 'и', 'н', 'и', 'ц', 'и', 'а', 'л', 'ы', '>']
+```
+
+Удаление элемента по значению:
+```py
+        >>> spis1.remove(5-9j)
+        >>> spis1
+        ['hello', 'New item', 'Меня зовут: \n FilippovDY', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', '<', 'с', 'ю', 'д', 'а', ' ', 'в', 'с', 'т', 'а', 'в', 'ь', 'т', 'е', ' ', 'с', 'в', 'о', 'ю', ' ', 'ф', 'а', 'м', 'и', 'л', 'и', 'ю', ' ', 'и', ' ', 'и', 'н', 'и', 'ц', 'и', 'а', 'л', 'ы', '>']
+```
+
+Добавление элементов объекта в конец другого объекта:
+```py
+        >>> spis2=['hello', 255, 5-10j]
+        >>> spis1.extend(spis2)
+        >>> spis1
+        ['hello', 'New item', 'Меня зовут: \n FilippovDY', 'М', 'е', 'н', 'я', ' ', 'з', 'о', 'в', 'у', 'т', ':', ' ', '\n', ' ', '<', 'с', 'ю', 'д', 'а', ' ', 'в', 'с', 'т', 'а', 'в', 'ь', 'т', 'е', ' ', 'с', 'в', 'о', 'ю', ' ', 'ф', 'а', 'м', 'и', 'л', 'и', 'ю', ' ', 'и', ' ', 'и', 'н', 'и', 'ц', 'и', 'а', 'л', 'ы', '>', 'hello', 255, (5-10j)]
+```
+
+Полное очищение списка:
+```py
+       >>> spis1.clear()
+       >>> spis1
+       []
+```
+
+Сортировка списка без создания нового объекта:
+```py
+       >>> spis3=[4,-3,5,-7,10]
+       >>> spis3.sort(key=abs, reverse=False)
+       >>> spis3
+       [-3, 4, 5, -7, 10]
+       >>> spis3.sort(key=abs, reverse=True)
+       >>> spis3
+       [10, -7, 5, 4, -3]
+```
+
+Создание копии списка:
+```py
+       >>> spis4=spis3.copy()
+       >>> spis4
+       [10, -7, 5, 4, -3]
+```
+
+Подсчет количества элементов по значению:
+```py
+       >>> spis4.count(-7)
+       1
+```
+
+Поиск индекса по значению:
+```py
+       >>> spis4.index(5)
+       2
+```
+
+Списки могут быть вложенными
+```py
+       >>> spis1
+       [10, -7, 5, 4, -3]
+       >>> spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
+       >>> spis2
+       [[10, -7, 5, 4, -3], [4, 5, 6, 7]]
+```
+
+Обращение к элементам вложенного списка:
+```py
+       >>> spis2[0][1]  #обращение к элементу списка spis1
+       -7
+```
+
+Изменение элемента вложенного списка:
+```py
+       >>> spis2[0][1]=78  
+       >>> spis2
+       [[10, 78, 5, 4, -3], [4, 5, 6, 7]]
+       >>> spis1
+       [10, 78, 5, 4, -3]
+```
+Видим, что spis1 тоже изменился. Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]] мы не создаем копию spis1, поэтому его изменения в составе spis2 отображаются на исходном spis1.
+
+
+Создание объекта-списка, элементами которого будут объекты разных типов
+```py
+       >>> spis5 = [100, 'Test', True, spis1]
+       >>> spis5
+       [100, 'Test', True, [10, 78, 5, 4, -3]]
+```
+
+ ## 8.2 Кортежи
+Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддерживают включение в них объектов различных типов и операции, типичные для последовательностей.
+
+Создание кортежа:
+```py
+      >>> kort1=(222,'Kortezh',77+8j)
+```
+
+Кортеж нельзя изменить, но можно переопределить
+```py
+      >>> kort1= kort1+(1,2)
+      >>> kort1
+      (222, 'Kortezh', (77+8j), 1, 2)
+      >>> kort1= kort1+(ss1b,)
+      >>> kort1
+      (222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n FilippovDY')
+```
+
+Переопределение кортежа с удалением комплексного элемента:
+```py
+      >>> kort2=kort1[:2]+kort1[3:]
+      >>> kort2
+      (222, 'Kortezh', 1, 2, 'Меня зовут: \n FilippovDY')
+```
+
+Определение индекса заданного элемента:
+```py
+      >>> kort1.index(2)  # Будет получено значение 4
+      4
+```
+
+Подсчёт числа вхождений заданного элемента:
+```py
+      >>> kort1.count(222)   #Будет получено значение 1
+      1
+```
+
+Операция замены элемента в кортеже:
+```py
+      >>> kort1[2]=90   #Будет получена диагностика о невозможности изменения кортежа
+      TypeError: 'tuple' object does not support item assignment
+```
+
+Создание объекта-кортежа с элементами разных типов:
+```py
+      >>> kort3 = ("h","True", 54)
+      >>> kort3
+      ('h', 'True', 54)
+```
+
+ ## 8.3 Словарь
+Объект-словарь похож на ассоциативные массивы в других языках программирования. Его содержанием является совокупность пар: «ключ (key)»:«значение (value)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений.
+
+Создание словаря:
+```py
+      >>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+```
+
+Обращение к элементам словаря (не по индексам, а по ключам):
+```py
+      >>> dic1['Orel']
+      56
+```
+
+Пополнение словаря:
+```py
+      >>> dic1['Pskov']=78
+      >>> dic1
+      {'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+```
+-В силу неупорядоченности словаря при его выводе элементы могут располагаться не в том порядке, в каком они задавались при его формировании.
+Для того, чтобы получить перечень ключей или значений из словаря следует использовать методы keys или values, создающие списки, соответственно, ключей или значений из словаря.
+
+Упорядочение списка по ключам или по значениям:
+```py
+      >>> sorted(dic1.keys())
+      ['Orel', 'Pskov', 'Saratov', 'Vologda']
+      >>> dic1
+      {'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
+      >>> sorted(dic1.values())
+      [45, 56, 78, 145]
+```
+
+Элементы словаря, могут быть любого типа, в том числе и словарями:
+```py
+      >>> dic2={1:'mean',2:'standart deviation',3:'correlation'}
+      >>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
+```
+
+Создание более сложного словаря из списка с элементами-кортежами:
+```py
+      >>> 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 FilippovDY'}
+```
+
+Создание словаря из двух списков (одного для ключей, другой для значений):
+```py
+      >>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
+      >>> dic5
+      {'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n <сюда вставьте свою фамилию и инициалы>'}
+```
+
+Создание объекта-кортежа из 7 элементов и объекта-списка с 5 элементами, создание из них словаря:
+```py
+      >>> kort6=('f', 'd', 's', 'a', 'l', 'k', 'j')
+      >>> spis6=[2,5,6,8,3]
+      >>> dic6=dict(zip(spis6,kort6))
+      >>> dic6
+```
+Как мы видим длина словаря составляет 5 объектов. Это связано с функцией zip, которая делает так, что длина итогового объекта будет соответствовать минимальной длине составляющего.
+
+
+ ## 8.4 Множество
+Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).
+
+Создание множества:
+```py
+      >>> mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
+      >>> mnoz1
+      {'двигатель', 'датчик', 'линия связи', 'микропроцессор'}
+```
+-Повторяющееся элементы были удалены
+
+Определение числа элементов:
+```py
+      >>> len(mnoz1)
+      4
+```
+Проверка наличия элемента во множестве:
+```py
+      >>> 'датчик' in mnoz1
+      True
+```
+Добавление элемента:
+```py
+      >>> mnoz1.add('реле')
+```
+Удаление элемента:
+```py
+      >>> mnoz1.remove('линия связи')
+      >>> mnoz1
+      {'датчик', 'реле', 'микропроцессор', 'двигатель'}
+```
+Создание объекта-множества с элементами разных типов и выполнение различных операций с ним:
+```py
+      >>> mnoz2 = {'реле', 20, False}
+      >>> mnoz2.add(60)
+      >>> mnoz2
+      {False, 'реле', 20, 60}
+      >>> mnoz2.remove(False)
+      >>> mnoz2
+      {'реле', 20, 60}
+```
+ # 9. Завершение работы в среде IDLE.
+

TEMA2/task.md

@@ -0,0 +1,82 @@
+ # Общее контрольное задание по теме 2
+
+**Филиппов Даниил Юрьевич, А-01-23**
+
+ # Задание
+Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
+
+1. Создать переменную с именем familia и со значением - символьной строкой – своей фамилией в латинской транскрипции.
+
+2. Создать переменную со значением, совпадающим с первой буквой из familia.
+
+3. Создать переменную с именем sp_kw со значением – списком всей ключевых слов языка Python.
+
+4. Удалите из списка sp_kw значение 'nonlocal'. Выводом списка в командном окне IDLE убедитесь, что это значение удалено из списка.
+
+5. Создайте кортеж kort_nam с именами: вашим и еще 3-х студентов из вашей группы. 
+
+6. Напишите инструкцию, позволяющую убедиться, что тип переменной – это tuple.
+
+7. Напишите инструкцию, добавляющую в kort_nam имена еще двух студентов. 
+
+8. Напишите инструкцию, позволяющую определить, сколько раз в кортеже присутствуют студенты с именем «Дима».
+
+9. Создайте словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные переменные, соответствующие этим типам.
+
+    
+ # Решение
+1. Создаю переменную familia:
+```py
+     >>> familia='Filippov'
+```
+2. Создаю переменную, которая равна первой букве familia:
+```py
+     >>> first=familia[0]
+     >>> first
+     'F'
+```
+
+3. Создаю переменную с именем sp_kw, значение – списк всех ключевых слов Python:
+```py
+     >>> import keyword
+     >>> sp_kw=keyword.kwlist
+     >>> sp_kw
+     ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+     >>> type(sp_kw)
+     <class 'list'>
+```
+
+4. Удаляю из списка sp_kw значение 'nonlocal', затем убедился, что это значение удалено из списка.
+```py
+     >>> sp_kw.remove('nonlocal')
+     >>> sp_kw
+     ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
+```
+
+5. Создаю кортеж kort_nam с моим и еще 3-х студентов из группы именами. Проверяю, что тип переменной – это tuple.
+```py
+     >>> kort_nam=('Daniil', 'Dima', 'Vanya', 'Dima')
+     >>> type(kort_nam)
+     <class 'tuple'>
+```
+
+6. Добавляю в kort_nam имена двух студентов.
+```py
+     >>> kort_nam=kort_nam+('Dima', 'Liza')
+     >>> kort_nam
+     ('Daniil', 'Dima', 'Vanya', 'Dima', 'Dima', 'Liza')
+```
+
+7. Определяю, сколько раз в кортеже присутствуют студенты с именем «Дима».
+```py
+     >>> kort_nam.count('Dima')
+     3
+```
+
+8. Создаю словарь dict_bas, в котором ключами являются русские названия типов переменных, использованных в предыдущих операторах, а значениями – ранее созданные перемен-ные, соответствующие этим типам.
+```py
+     >>> dict_bas={"строка" : familia, "символ" : first, "список" : sp_kw,  "кортеж" : kort_nam}
+     >>> dict_bas
+     {'строка': 'Filippov', 'символ': 'F', 'список': ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'], 'кортеж': ('Daniil', 'Dima', 'Vanya', 'Dima', 'Dima', 'Liza')}
+```
+

TEMA2/test.md

@@ -0,0 +1,33 @@
+ # Задание
+Пусть предполагается выполнить инструкции
+```py
+>>> u=[1,2,3,4,5]
+>>> v=['a',u,'v',[11,12]]
+>>> print(v[1][3])
+```
+Не выполняя эти инструкции, подумайте, какое значение будет выведено на экран? Проверьте свое предположение вводом инструкций.
+
+ # Решение
+У нас есть список u и список v. Список u является вложенным списком списка v. Если мы выведем список v:
+```py
+>>> print(v)
+['a', [1,2,3,4,5], 'v', [11,12]]
+```
+То мы увидим внутри списка v список u. Тогда при выполнении инструкции:
+```py
+>>> print(v[1][3])
+```
+Мы получим следующий ответ: 
+```py
+4
+```
+
+Так как индексация в Python начинается с 0.
+
+Теперь проверим решение вводом инструкций:
+```py
+>>> u=[1,2,3,4,5]
+>>> v=['a',u,'v',[11,12]]
+>>> print(v[1][3])
+4
+```

TEMA3/report.md

@@ -0,0 +1,846 @@
+  # Отчёт по теме 3: "Операции с объектами"
+Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск интерактивной оболочки IDLE
+ # 2. Преобразование простых базовых типов объектов
+ ## 2.1 Преобразование в логический тип с помощью функции bool(<Объект>)
+
+Выполним следующие инструкции и после каждой из них проверим получившееся значение:
+```py
+>>> logiz1=bool(56)
+>>> logiz1
+True
+>>> type(logiz1)
+<class 'bool'>
+>>> 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 Преобразование в целое десятичное число объекта с заданной системой счисления 
+
+Осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.
+```py
+>>> tt1=int(198.6) #Отбрасывается дробная часть
+>>> tt1
+198
+>>> tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
+>>> tt2
+-76
+>>> tt3=int("B",16)
+>>> tt3
+11
+>>> tt4=int("71",8)
+>>> tt4
+57
+>>> tt5=int("98.76")
+Traceback (most recent call last):
+  File "<pyshell#20>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+При выполнении последней инструкции выдано диагностическое сообщение, это происходит
+потому, что команда int ожидает, что ей сообщат строку, похожую на тип int
+(только цифры, может быть знак в начале). Здесь есть точка, поэтому вознакает
+несоответствие.
+
+
+Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>)
+```py
+>>> flt1=float(789)
+>>> flt1
+789.0
+>>> flt2=float(-6.78e2)
+>>> flt2
+-678.0
+>>> flt3=float("Infinity")
+>>> flt3
+inf
+>>> flt4=float("-inf")
+>>> flt4
+-inf
+```
+
+ ## 2.3 Преобразование десятичных чисел в другие системы счисления
+```py
+>>> hh=123
+>>> dv1=bin(hh)   #Преобразование в строку с двоичным представлением
+>>> dv1
+'0b1111011'
+>>> vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
+>>> vos1
+'0o173'
+>>> shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
+>>> shs1
+'0x7b'
+```
+
+Теперь выполним обратные преобразования:
+```py
+>>> int(dv1,2)
+123
+>>> int(vos1,8)
+123
+>>> int(shs1,16)
+123
+```
+
+
+ # 3. Преобразование более сложных базовых объектов
+ ## 3.1 Преобразование в строку символов с помощью функции str(<Объект>)
+```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
+>>> spis4 = list({"A":1,"B":2,"C":9}.values())
+>>> spis4
+[1, 2, 9]
+```
+
+ ## 3.3 Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>)
+```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 Удаление объектов
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del
+```py
+>>> del strk5, kort8
+```
+
+Проверим, остались ли после этой операции объекты в оперативной памяти:
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+
+
+Создадим строку с моей фамилией и инициалами. Преобразуем её в список, затем список - в кортеж, затем кортеж - в строку.
+```py
+>>> strk1='FilippovDY'
+>>> spis11=list(strk1)
+>>> spis11
+['F', 'i', 'l', 'i', 'p', 'p', 'o', 'v', 'D', 'Y']
+>>> kort11=tuple(spis11)
+>>> kort11
+('F', 'i', 'l', 'i', 'p', 'p', 'o', 'v', 'D', 'Y')
+>>> strk2=str(kort11)
+>>> strk2
+"('F', 'i', 'l', 'i', 'p', 'p', 'o', 'v', 'D', 'Y')"
+```
+
+
+ # 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  #Деление двух целых чисел
+>>> type(a)
+<class 'float'>
+>>> a
+3.9555555555555557
+```
+Результатом деления всегда будет вещественное число.
+
+
+ ## 4.4 Деление с округлением вниз (//)
+
+```py
+>>> b=178//45   #Деление двух целых чисел
+>>> type(b)
+<class 'int'>
+>>> b
+3
+>>> c=-24.6//12.1  #Деление двух вещественных чисел
+>>> type(c)
+<class 'float'>
+>>> c
+-3.0
+```
+Здесь результат может быть целым или вещественным.
+Попробуем смешанные комбинации типов чисел:
+
+```py
+>>> d=178//24.6
+>>> type(d)
+<class 'float'>
+>>> d
+7.0
+```
+
+ ## 4.5 Получение остатка от деления (%)
+
+```py
+>>> 148%33   #Остаток от деления двух целых чисел
+16
+>>> 12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+>>> 36%2.6
+2.199999999999999
+>>> 52.06%2
+0.060000000000002274
+```
+
+ ## 4.6 Возведение в степень (**)
+
+```py
+>>> 14**3  #Целое число возводится в целую степень
+2744
+>>> e=2.7**3.6  #Вещественное число возводится в вещественную степень
+>>> e
+35.719843790663525
+>>> 2.7**3
+19.683000000000003
+>>> 3**5.2
+302.71261832657075
+```
+
+Попробуем операции с участием комплексных чисел:
+```py
+>>> comp1 = (5 + 7j) #Создадим первое комплексное число
+>>> type(comp1)
+<class 'complex'>
+>>> comp2=(6-4j) #Создадим второе комплексное число
+>>> comp1+comp2 #Сумма комплексных чисел
+(11+3j)
+
+>>> comp1-comp2 #Разность комплексных чисел
+(-1+11j)
+
+>>> comp1*comp2 #Произведение комплексных чисел
+(58+22j)
+
+>>> comp1/comp2 #Частное комплексных чисел
+(0.03846153846153853+1.1923076923076923j)
+
+>>> comp1//comp2 #Частное комплексных чисел с округлением вниз
+Traceback (most recent call last):
+  File "<pyshell#108>", line 1, in <module>
+    comp1//comp2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+
+comp1%comp2 #Получение остатка от деления комплексных чисел
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    comp1%comp2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+
+>>> comp1**comp2 #Возведение комплексного числа в комплексную степень
+(-17647296.212723836-4257726.663737518j)
+```
+
+
+ # 5. Операции с двоичными представлениями целых чисел
+ ## 5.1 Двоичная инверсия (~)
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+
+```py
+>>> dv1=9
+>>> dv2=~dv1
+>>> dv2
+-10
+>>> dv1
+9
+>>> bin(dv1)
+'0b1001'
+>>> bin(dv2)
+'-0b1010'
+```
+
+Результат не совсем совпадает с ожидаемым видом "0110". Это происходит, потому что в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака, а знак
+в двоичных числах записывается с помощью дополнительного кода. 
+Было число 9 (1001), меняем все значения на противоположные (0110), затем надо поменять знак (это значит, что надо инвертировать все значения разрядов - будет 1001) и прибавить к полученному числу единицу (которая отвечает за знак), получаем число 1010.
+  
+Двоичная инверсия делает из числа n число -(n+1).
+
+
+ ## 5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```py
+>>> 7&9    # 111 и 1001 = 0001
+1
+>>> bin(7&9)
+'0b1'
+7&8    # 111 и 1000 = 0000
+0
+bin(7&8)
+'0b0'
+```
+7 в двоичной системе счисления - 0111, а 9 в двоичной системе счисления - 1001. Совпадение единиц только в первом разряде, поэтому итог - 0001 или 1.
+
+8 в двоичной системе счисления - 1000, совпадений единиц нет, итог - 0000 или 0.
+
+
+ ## 5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
+
+```py
+>>> 7|9     # 111 или 1001 = 1111
+15
+>>> bin(7|9)
+'0b1111'
+>>> 7|8     # 111 или 1000 = 1111
+15
+>>> bin(7|8)
+'0b1111'
+>>> 14|5   # 1110 или 0101 = 1111
+15
+>>> bin(14|5)
+'0b1111'
+```
+
+7 в двоичной системе счисления - 0111, 9 в двоичной системе счисления - 1001.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+8 в двоичной системе счисления - 1000.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+
+ ## 5.4 Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+
+```py
+>>> 14^5  # 1110 исключающее или 0101 = 1011
+11
+>>> bin(14^5)
+'0b1011'
+```
+
+14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
+Возвращается 1, если оба разряда разные, поэтому итог - 1011
+
+
+ ## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева
+
+```py
+>>> h=14   #Двоичное представление = 1110
+>>> bin(h)
+'0b1110'
+>>> g=h<<2  # Новое двоичное представление = 111000, сдвиг на два разряда влево
+>>> bin(g)
+'0b111000'
+>>> g1=h>>1  # Новое двоичное представление = 0111, сдвиг на один разряд вправо
+>>> bin(g1)
+'0b111'
+>>> g2=h>>2  # Новое двоичное представление = 0011, сдвиг на два разряда вправо
+>>> bin(g2)
+'0b11'
+```
+Слева можно добавить сколько угодно незначащих нулей.
+
+Возьмём два любых числа 52 и 30. Проведём с ними двоичные операции:
+```py
+>>> bin(52)
+'0b110100'
+>>> bin(30)
+'0b11110'
+>>> dv3=~52 # Инверсия числа 52
+>>> bin(dv3)
+'-0b110101'
+>>> bin(52|30) # Двоичное или
+'0b111110'
+>>> bin(52>>2) # сдвиг двоичного представления числа 52 на два разряда вправо
+'0b1101'
+```
+
+ # 6. Операции при работе с последовательностями (строками, списками, кортежами)
+ ## 6.1 Объединение последовательностей (конкатенация)(+)
+
+```py
+>>> 'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+Конкатенировать словари и множества нельзя. Так как у словарей ключи должны быть
+уникальными.
+```py
+>>> {'one':1 , 'two':2} + {'three':3}
+Traceback (most recent call last):
+  File "<pyshell#90>", line 1, in <module>
+    {'one':1 , 'two':2} + {'three':3}
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+```
+
+ ## 6.2 Повторение (*)
+```py
+>>> 'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+
+>>> signal1=[0]*3+[1]*99 # Создание списка со 100 отсчётами сигнала-ступеньки
+>>> 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 Проверка наличия заданного элемента в последовательности (in)
+```py
+>>> stroka='Система автоматического управления'
+>>> 'автомат' in stroka  #Наличие подстроки в строке
+True
+>>> 'ку' in ['ку','-']*3  #Наличие контекста в списке
+True
+>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
+False
+```
+
+ ## 6.4 Подстановка значений в строку с помощью оператора «%»
+Пример 1:
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> stroka
+'Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+Пример 2:
+```py
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+Подстановка возвращает новую строку, но не перезаписывает исходную.
+Типы вставок для оператора %:
+    %s - строка
+    %d и %i - целое число (d - всегда десятичное, а i - десятичное или переведенное
+         в десятичное из другой системы счисления)
+    %f - число с плавающей точкой
+    %e - экспоненциальная форма записи числа
+    %g - автовыбор между e и f  
+    %.nf - число с плавающей точкой, но конкретным количеством знаков после запятой
+
+
+ # 7. Оператор присваивания
+ ## 7.1 Обычное присваивание значения переменной (=)
+```py
+>>> zz=-12
+>>> zz
+-12
+```
+
+ ## 7.2 Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```py
+>>> zz+=5   # Значение zz увеличивается на 5
+>>> zz
+-7
+>>> zz-=3  # Значение уменьшается на 3
+>>> zz
+-10
+```
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+```py
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+```
+
+ ## 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+>>> zz/=2
+>>> zz
+-5.0
+>>> zz*=5
+>>> zz
+-25.0
+```
+Для строк операция (*=) означает повторение текущего значения объекта заданное число раз.
+```py
+>>> stroka = 'Система'
+>>> stroka *= 3
+>>> stroka
+'СистемаСистемаСистема'
+```
+
+ ## 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+```py
+>>> zz
+-0.5
+>>> zz//=4
+>>> zz
+-1.0
+>>> zz%=-0.2
+>>> zz
+-0.19999999999999996
+>>> zz**=5
+>>> zz
+-0.00031999999999999965
+```
+
+ ## 7.5 Множественное присваивание
+```py
+>>> w=v=10  # Переменным присваивается одно и то же значение
+>>> w
+10
+>>> v
+10
+>>> n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+>>> n1,n2,n3
+(11, -3, 'all')
+>>> n1
+11
+```
+Проверим, можно ли использовать так строку, список, словарь, множество:
+```py
+>>> a1, a2, a3 = "a", "b", "c" # Строка
+>>> a1, a2, a3
+('a', 'b', 'c')
+>>> b1, b2, b3 = ["a", 1, None] # Список
+>>> b1
+'a'
+>>> b3
+>>> c1, c2, c3 = {"one": 1, "two": 2, "three": 3} # Словарь
+>>> c1, c2, c3
+('one', 'two', 'three')
+>>> m1, m2, m3 = {52, 0, 3} # Множество
+>>> m1, m2, m3
+```
+
+
+ # 8. Логические операции – при создании логических выражений, дающих в результате вычисления значения True или False.
+ ## 8.1 Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=)
+```py
+>>> w
+10
+>>> v
+10
+>>> w==v # Равенство
+True
+>>> w!=v # Не равно
+False
+>>> w<v # Меньше
+False
+>>> w<=v # Меньше или равно
+True
+```
+
+ ## 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in)
+Операции с множеством 
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+```
+
+Операции со словарем
+```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 Cоздание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Пример сложного логического выражения:
+```py
+>>> (len(dic1) == 3) or (sum(dic1.values()) > 300) or ('IVTI' in dct1['Depart'])
+True
+```
+
+ ## 8.4 Проверка ссылок переменных на один и тот же объект (is)
+```py
+>>> w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+>>> w is v
+True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> w1 is v1
+False
+>>> w1 == v1
+True
+```
+Оператор is проверяет, ссылаются ли объекты на один и тот же адрес в памяти. Переменные
+целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти.
+Списки были созданы в разных строках, и адреса у них разные, т.е. они ссылаются на разные
+участки в памяти, поэтому is возвращает False. 
+```py
+>>> w2=20
+>>> v2=20
+>>> w2 is v2
+True
+
+>>> a=10002
+>>> b=10002
+>>> a is b
+False
+
+>>> a=b=10002
+>>> a is b
+True
+```
+В Python возможности в плане оперирования памятью сведены к минимуму, и иногда использование памяти оптимизировано. Например, числа от -5 до 256 python подвергает интернированию, т.е. делает так, чтобы они ссылались на один участок памяти. Но с числами, не попадающими в этот диапазон, это не работает.
+
+
+ # 9. Операции с объектами, выполняемые с помощью методов
+Полный список всех атрибутов любого объекта можно получить с использованием функции dir
+```py
+>>> stroka='Микропроцессорная система управления'
+>>> dir(stroka)
+['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+```
+
+ ## 9.1 Методы для работы со строками
+```py
+>>> stroka.find('пр')  #Возвращает номер позиции первого вхождения указанного контекста или значение -1
+5
+
+>>> stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
+4
+
+>>> stroka.replace(' у',' автоматического у') #Замена подстроки, не перезаписывает исходную строку
+'Микропроцессорная система автоматического управления'
+
+>>> spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
+>>> spis22
+['Микропроцессорная', 'система', 'управления']
+
+>>> stroka.upper()   #Возвращает строку со всеми заглавными буквами
+'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
+
+>>> stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
+>>> stroka3
+'Микропроцессорная система управления'
+
+>>> stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
+('Микропроце', 'с', 'сорная система управления')
+
+>>> stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола.
+```py
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1
+'Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+```
+
+Можно указать порядок. Здесь цифры в фигурных скобках – это индексы, определяющие порядок использования аргументов формата. Поэтому такой способ называют основанным на позиционных аргументах.
+```py
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+```
+
+Можно подставить имена аргументов-вставок, и тогда порядок подстановки может быть
+произвольным:
+```py
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3
+'Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+
+ ## 9.2 Методы для работы со списками
+```py
+>>> spsk = [10, 'd', (1, 2), 'a', 3] # Создание списка
+>>> spsk
+[10, 'd', (1, 2), 'a', 3]
+
+>>> spsk.pop(2) # Удаление элемента по индексу
+(1, 2)
+>>> spsk
+[10, 'd', 'a', 3]
+
+>>> spsk.append('c') # Вставка элемента в конец
+>>> spsk
+[10, 'd', 'a', 3, 'c']
+
+>>> spsk.insert(2,'a') # Вставка элемента в конкретное место по индексу
+>>> spsk
+[10, 'd', 'a', 'a', 3, 'c']
+
+>>> spsk.count('a') # Подсчет количества элементов по значению
+2
+>>> spsk
+[10, 'd', 'a', 'a', 3, 'c']
+```
+
+ ## 9.3 Методы для работы с кортежами
+Кортежи неизменяемы, поэтому методов, связанных с удалением или добавлением элементов, нет.
+```py
+>>> cor = (1, 'a', 'b', 0.05, 10+3j) # Создание кортежа
+
+>>> cor.count(1) # Подсчет количества элементов по значению
+1
+
+>>> cor.index(0.05) # Поиск индекса первого вхождения
+3
+>>> cor.index('d') 
+Traceback (most recent call last):
+  File "<pyshell#172>", line 1, in <module>
+    cor.index('d')
+ValueError: tuple.index(x): x not in tuple
+```
+
+ ## 9.4 Методы для работы со словарями и множествами
+Методы словарей:
+```py
+>>> dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+
+>>> new_dct1=dct1.copy() # Создается копия, но новые значения ссылаются на предыдущие
+>>> new_dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+
+>>> dct1.get('Depart') # Возвращение значения по ключу
+['UII', 'PM', 'VMSS', 'MM']
+
+>>> dct1.keys() # Возвращение объекта только из ключей
+dict_keys(['Institut', 'Depart', 'gruppa'])
+
+>>> dct1.values() # Возвращение объекта только из значений
+dict_values([['AVTI', 'IEE', 'IBB'], ['UII', 'PM', 'VMSS', 'MM'], ['A-01-15', 'A-02-15']])
+```
+Возвращаемые объекты dict_keys, dict_values, dict_items - объекты-итераторы. Они ссылаются на адреса ключей или значений в памяти, но не хранят значения. Также эти объекты автоматически обновляются при обновлении словаря.
+```py
+>>> new_dct1.clear() # Полное очищение списка
+>>> new_dct1
+{}
+
+>>> dct1.pop('Depart') # Удаление ключа и возвращение значения
+['UII', 'PM', 'VMSS', 'MM']
+>>> dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'gruppa': ['A-01-15', 'A-02-15']}
+```
+Методы множеств:
+```py
+>>> mnoz1={1, 'датчик', False, 256, 'двигатель'}
+>>> mnoz1
+{False, 256, 1, 'двигатель', 'датчик'}
+
+>>> mnoz1.add(10+7j) # Добавление элемента
+>>> mnoz1
+{False, 256, 1, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz2=mnoz1.copy() # Создание копии
+>>> mnoz2
+{False, 256, 1, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz1.remove(1) # Удаление элемента по значению
+>>> mnoz1
+{False, 256, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz2.clear() # Очищение множества
+>>> mnoz2
+set()
+
+>>> mnoz1.pop() # Удаление случайного элемента из множества
+False
+>>> mnoz1
+{256, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz1.update({True, 'b'}) # Добавление элементов
+>>> mnoz1
+{256, True, 'b', 'двигатель', 'датчик', (10+7j)}
+```
+
+
+ # 10. Завершение сеанса работы со средой
+
+
+

TEMA3/task.md

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