From abed8344ec4d3d8cffe174f651ffa1a9aa16c95d Mon Sep 17 00:00:00 2001 From: Katerina Date: Wed, 17 Sep 2025 18:04:00 +0300 Subject: [PATCH] one commit --- TEMA2/report.md | 802 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 802 insertions(+) create mode 100644 TEMA2/report.md diff --git a/TEMA2/report.md b/TEMA2/report.md new file mode 100644 index 0000000..62c8a85 --- /dev/null +++ b/TEMA2/report.md @@ -0,0 +1,802 @@ +# Отчёт по теме 2 «Зеленкина Катерина» + +## Пункт 1. Запуск оболочки IDLE + +Установим рабочий каталог: + +```py +>>> import os +>>> os.chdir(r'C:\Users\user\python-labs\TEMA2') +``` +## Пункт 2. Простые объекты +Рассмотрела операции присваивания: + +```py +f1=16; f2=3 +f1,f2 +(16, 3) +f1;f2 +16 +3 +``` + +Просмотрела уже существующие объекты в данный момент в среде Python: + +```py +>>> dir() +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os'] +``` + +Просмотрела список атрибутов объекта 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'] +``` + +Определила классовую принадлежность объекта f2: + +```py +>>> type(f2) + +``` + +Удалила объекты f1 и f2: + +```py +>>> del f1,f2 +>>> f1;f2 +Traceback (most recent call last): + File "", line 1, in + f1;f2 +NameError: name 'f1' is not defined +``` + +## Пункт 3. Правила именования объектов в Python. + +Выполнила следующие предложенные операции. Последние две из них имели недопустимые имена: + +```py +>>> gg1=1.6 +>>> gg1 +1.6 +>>> hh1='Строка' +>>> hh1 +'Строка' +>>> 73sr=3 - неправильное именование +SyntaxError: invalid decimal literal +>>> and=7 - неправильное именование +SyntaxError: invalid syntax +``` + +## Пункты 4-5. Список ключевых слов и встроенных идентификаторов + +Вывела список ключевых слов и сохранила его в переменную + +```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'] +>>> a = keyword.kwlist +>>> a +['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 +>>> 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'] +``` + +### Функция abs() + +```py +>>> help (abs) +Help on built-in function abs in module builtins: + +abs(x, /) + Return the absolute value of the argument. + +>>> abs(-1) +1 +``` + +### Функция len() + +```py +>>> help (len) +Help on built-in function len in module builtins: + +len(obj, /) + Return the number of items in a container. + +>>> b=[0,1,2,3,4,5,6,7,8,9,10] +>>> b +[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +>>> len(b) +11 +``` + +### Функции max()/min() + +```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 positional arguments, return the largest argument. + +>>> help(min) +Help on built-in function min in module builtins: + +min(...) + min(iterable, *[, default=obj, key=func]) -> value + min(arg1, arg2, *args, *[, key=func]) -> value + + With a single iterable argument, return its smallest item. The + default keyword-only argument specifies an object to return if + the provided iterable is empty. + With two or more positional arguments, return the smallest argument. + +>>> max(b) +10 +>>> min(b) +0 +``` + +### Функция pow() + +```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(6,2) +36 +``` + +### Функция 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(3.8) +4 +``` + +### Функция 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. + +>>> c=[10, 4, 9, 1, 23] +>>> c +[10, 4, 9, 1, 23] +>>> sorted(c) +[1, 4, 9, 10, 23] +``` + +### Функция 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(c) +47 +``` + +### Функция zip() + +```py +>>> help(zip) +Help on class zip in module builtins: + +class zip(object) + | zip(*iterables, strict=False) + | + | The zip object yields n-length tuples, where n is the number of iterables + | passed as positional arguments to zip(). The i-th element in every tuple + | comes from the i-th iterable argument to zip(). This continues until the + | shortest argument is exhausted. + | + | If strict is true and one of the arguments is exhausted before the others, + | raise a ValueError. + | + | >>> list(zip('abcdefg', range(3), range(4))) + | [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)] + | + | Methods defined here: + | + | __getattribute__(self, name, /) + | Return getattr(self, name). + | + | __iter__(self, /) + | Implement iter(self). + | + | __next__(self, /) + | Implement next(self). + | + | __reduce__(self, /) + | Return state information for pickling. + | + | __setstate__(self, object, /) + | Set state information for unpickling. + | + | ---------------------------------------------------------------------- + | Static methods defined here: + | + | __new__(*args, **kwargs) + | Create and return a new object. See help(type) for accurate signature. + +>>> c +[10, 4, 9, 1, 23] +>>> d=[1,2,3,4,5] +>>> d +[1, 2, 3, 4, 5] +>>> h=zip(c,d) +>>> h + +>>> list(h) +[(10, 1), (4, 2), (9, 3), (1, 4), (23, 5)] +``` + +## Пункт 6. Регистр букв +Проверила влияние больших и малых букв в имени переменных + +```py +>>> Gg1=45 +>>> gg1 +1.6 +>>> Gg1 +45 +``` + +## Пункт 7. Простые базовые типы объектов +### 7.1 Логический тип (bool) + +```py +>>> bb1=True; bb2=False +>>> bb1;bb2 +True +False +>>> type(bb1) + +``` + +### 7.2 Другие простые типы + +```py +>>> ii1=-1234567890 +>>> type(ii1) + + +>>> ff1=-8.9876e-12 +>>> type(ff1) + + +>>> dv1=0b1101010 #Двоичное число +>>> type(dv1) + +``` +Двоичное число сохранено в объекте класса int + +```py +>>> vsm1=0o52765 #Восьмеричное число +>>> type(vsm1) + + +>>> shest1=0x7109af6 #Шестнадцатеричное число +>>> type(shest1) + + +cc1=2-3j +type(cc1) + +``` + +Создание комплексного числа: + +```py +a=3.67; b=-0.45 +cc2=complex(a,b) +type(cc2) + +``` + +### 7.3 Строка символов + +Строки выделяются апострофами: +```py +>>> ss1='Это - строка символов' +>>> ss1 +'Это - строка символов' +``` + +Строки выделяются двойными кавычками: +```py +>>> ss1="Это - строка символов" +>>> ss1 +'Это - строка символов' +``` + +Попробовала экранированные последовательности: + +```py +>>> ss1a="Это - \" строка символов \", \n \t выводимая на двух строках" +>>> print(ss1a) +Это - " строка символов ", + выводимая на двух строках +``` + +Создала строку по шаблону: + +```py +>>> ss1b= 'Меня зовут: \n Зеленкина К. М.' +>>> print(ss1b) +Меня зовут: + Зеленкина К. М. +``` +Многострочные строки: + +```py +>>> mnogo="""Нетрудно заметить , что в результате операции +над числами разных типов получается число, +имеющее более сложный тип из тех, которые участвуют в операции.""" + +>>> print(mnogo) +Нетрудно заметить , что в результате операции +над числами разных типов получается число, +имеющее более сложный тип из тех, которые участвуют в операции. +``` + +Обратилась к частям строки с помощью индексов: + +```py +>>> ss1[0] +'Э' +>>> ss1[8] +'р' +>>> ss1[-2] +'о' +``` + +Выполнила операцию «разрезания»/«создания среза»: +```py +>>> ss1[6:9] +'стр' +>>> ss1[13:] +'символов' +>>> ss1[:13] +'Это - строка ' +>>> ss1[5:-8] +' строка ' +>>> ss1[3:17:2] +' тоасм' +``` + +При отрицательном значении шага перечислились элементы с индексами от 3 до 17 в обратном порядке: +```py +>>> ss1[17:3:-2] +'омсаот ' +``` + +Заменив 17 на -4, мы получим тот-же результат, т. к. символ под индексом 17 и -4 один и тот же: + +```py +>>> ss1[-4:3:-2] +'омсаот ' +``` +```py +>>> s=ss1b[:4] +>>> print(s) +Меня + +>>> sk1=ss1b[:4]+' именовать'+ss1b[12:]; print(sk1) +Меня именовать + Зеленкина К. М. +``` +Самостоятельно придумала значения и создала объекты разных типов: + +```py +>>> flag = True +>>> type(flag) + + +>>> n=16 +>>> type(n) + + +>>> k = 'Привет' +>>> type(k) + +``` + +## Пункт 8. Сложные типы объектов +### 8.1 Списки + +__ Список __ — это упорядоченная коллекция элементов произвольных типов (числа, строки, другие объекты). + +Список с элементами разных типов: + +```py +>>> spis1=[111, 'Spisok' ,5-9j] +>>> spis1 +[111, 'Spisok', (5-9j)] +``` + +Вводить элементы в списках можно на разных строках до закрытия квадратной скобкой: + +```py +>>> stup=[0,0,1,1,1,1,1,1,1]; stup +[0, 0, 1, 1, 1, 1, 1, 1, 1] +>>> spis=[1,2,3,4, + 5,6,7, + 8,9,10] +>>> spis +[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +``` + +В списках тоже можно обращаться к элементам по индексам: + +```py +>>> spis1[-1] +(5-9j) + +>>> stup[-8::2] +[0, 1, 1, 1] +``` + +Пояснение: Вошло 4 элемента. Элемент под индексом '-8' есть элемент с индексом 1, срез произойдёт до последнего элемента с шагом 2 + +Заменила второй элемент в spis1: + +```py +>>> spis1[1]='Список' +>>> spis1 +[111, 'Список', (5-9j)] +>>> 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') +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 __ - вставит второй аргумент под номер индекса элемента + +```py +>>> spis1.insert(0, 24); spis1 +[24, 111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.'] +``` +__ remove __ - удалит элемент, указанный в скобках + +```py +>>> spis1.remove(24); spis1 +[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.'] +``` + +__ extend __ - добавляет каждый элемент аргумента в конец списка + +```py +>>> spis1.extend('24'); spis1 +[111, (5-9j), 'New item', 'Меня зовут: \n Зеленкина К. М.', '2', '4'] +``` + +__ clear __ - удаляет всё из списка + +```py +>>> spis1.clear(); spis1 +[] +``` + +__ sort__ - сортирует элементы в списке по возрастанию, а буквы по алфавиту + +```py +>>> spis1=[20, 4, 63, 2, 1, 0, 13, 7]; spis1 +[20, 4, 63, 2, 1, 0, 13, 7] +>>> spis1.sort() +>>> spis1 +[0, 1, 2, 4, 7, 13, 20, 63] + +>>> spis2 = ['д', 'с','г','а','ш'] +>>> spis2.sort() +>>> spis2 +['а', 'г', 'д', 'с', 'ш'] +``` + +__ reverse __ - сортирует элементы в обратном порядке + +```py +>>> spis1.reverse(); spis1 +[63, 20, 13, 7, 4, 2, 1, 0] + +>>> spis2.reverse();spis2 +['ш', 'с', 'д', 'г', 'а'] +``` + +__ copy __ - копирует список + +```py +>>> vv=spis1.copy(); vv +[63, 20, 13, 7, 4, 2, 1, 0] +``` + +__ count __ - cчитает количество заданного аргумента в скобках в списке + +```py +>>> spis2.count('д') +1 +``` + +__ index __ - выдаёт индекс элемента + +```py +>>> spis1.index(20) +1 +``` + +#### Вложенные списки + +```py +>>> spis2=[spis1,[4,5,6,7]]; spis2 +[[63, 20, 13, 7, 4, 2, 1, 0], [4, 5, 6, 7]] +>>> spis2[0][1] #обращение к элементу списка spis1 +20 +>>> spis2[0][1]=78; spis2 #Замена значения элемента на 78 +[[63, 78, 13, 7, 4, 2, 1, 0], [4, 5, 6, 7]] + +>>> spis1 +[63, 78, 13, 7, 4, 2, 1, 0] +``` + +Пояснение: Список spis1 отличается от первоначального, потому что он лежит в другом списке, в котором мы и поменяли значение + +Создала список с разными типами данных + +```py +>>>spisok = [89, 'дом', True, ['яблоко', 'помидор', 'хлеб']]; spisok + +[89, 'дом', True, ['яблоко', 'помидор', 'хлеб']] +>>> type(spisok) + + +``` + +### 8.2 Кортежи + +Кортеж – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. + +```py +>>> kort1=(222,'Kortezh',77+8j); kort1 + +(222, 'Kortezh', (77+8j)) +``` + +Переопределим кортеж: + +1. Добавим элементы + +```py +>>> kort1= kort1+(1,2) +>>> kort1 +(222, 'Kortezh', (77+8j), 1, 2) + +>>> kort1= kort1+(ss1b,); kort1 +(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Зеленкина К. М.') +``` + +2. Удалим элементы: + +```py +>>> kort2=kort1[:2]+kort1[3:]; kort2 +(222, 'Kortezh', 1, 2, 'Меня зовут: \n Зеленкина К. М.') +``` + +Узнала индекс заданного элемента: + +```py +>>> kort1.index(2) +4 +``` + +Подсчитала количество вхождений заданного элемента в кортеже: + +```py +>>> kort1.count(222) +1 +``` + +Т. к. кортежи неизменяемы, то у них отсутствуют методы append и pop. +Попробуем заменить элемент в кортеже (выдаст ошибку): + +```py +>>> kort1[2]=90 +Traceback (most recent call last): + File "", line 1, in + kort1[2]=90 +TypeError: 'tuple' object does not support item assignment +``` + +### Создаю объект-кортеж с разными типами данных: + +```py +>>> kort2=(23, 'Тыква', [4, 5, 6, 7], (4, 6, 8, 10)) +kort2 +(23, 'Тыква', [4, 5, 6, 7], (4, 6, 8, 10)) +type(kort2) + + +``` + +## 8.3 Словарь +__ Словарь __ - совокупность пар: «ключ (key)»:«значение (value)». + +Создадим словарь: + +```py +>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}; dic1 +{'Saratov': 145, 'Orel': 56, 'Vologda': 45} +``` +В словарях обращение к элементам происходит по ключам: + +```py +>>> dic1['Orel'] +56 +``` +Изменение словаря, добавление элемента: + +```py + >>> dic1['Pskov']=78 + >>> dic1 +{'Saratov': 120, 'Vologda': 45, 'Pskov': 78, 'Orel': 56} +``` +Отобразим сортированный словарь с помощью функции sorted (Отображает, но не сортирует): + +```py +>>> sorted(dic1.keys()) +['Orel', 'Saratov', 'Vologda'] +>>> sorted(dic1.values()) +[45, 56, 145] +``` + +Элементы словаря могут быть любого типа, даже словарём: + +```py +>>> dic2={1:'mean',2:'standart deviation',3:'correlation'} +>>> dic3={'statistics':dic2,'POAS':['base','elementary','programming']} +>>> dic3 +{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']} + +>>> dic3['statistics'][2] +'standart deviation' +``` + +Создадим более сложный словарь: + +```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 Зеленкина К. М.'} + +>>> dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b])); dic5 +{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n Зеленкина К. М.'} +``` + +Создадим свой объект-кортеж и объект-список: + +```py +>>> spisok01=(1, 5, 7, 9, 3, 0,10); spisok01 +(1, 5, 7, 9, 3, 0, 10) +>>> spisok02=[22,10,7,45,100]; spisok02 +[22, 10, 7, 45, 100] +>>>spisok03=dict(zip(spisok01,spisok02)); spisok03 +{1: 22, 5: 10, 7: 7, 9: 45, 3: 100} + +>>> len(spisok03) +5 #Элементов 5, потому что в spisok02 всего пять элементов +``` + +Пример словаря с описанием состава студентов, обучающихся на АВТИ: + +```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 +{'линия связи', 'датчик', 'двигатель', 'реле', 'микропроцессор'} + +>>> mnoz1.remove('линия связи'); mnoz1 +{'датчик', 'двигатель', 'реле', 'микропроцессор'} +``` + +Создадим своё множество: + +```py +>>> mnoz2={5, 'яблоко', False, (10, 6, 0)}; mnoz2 +{False, 5, (10, 6, 0), 'яблоко'} + +>>> mnoz2.add(100); mnoz2 +{False, 100, 5, (10, 6, 0), 'яблоко'} + +>>> mnoz2.remove('яблоко'); mnoz2 +{False, 100, 5, (10, 6, 0)} + +>>>False in mnoz2 +True +``` + +## 9. Конец сеанса +