one commit

1 месяц назад · abed8344ec
--- a/TEMA2/report.md
+++ 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)
+<class 'int'>
+```
+
+Удалила объекты f1 и f2:
+
+```py
+>>> del f1,f2
+>>> f1;f2
+Traceback (most recent call last):
+  File "<pyshell#9>", line 1, in <module>
+    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
+<zip object at 0x0000021067B5EC80>
+>>> 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)
+<class 'bool'>
+```
+
+### 7.2 Другие простые типы
+
+```py
+>>> ii1=-1234567890
+>>> type(ii1)
+<class 'int'>
+
+>>> ff1=-8.9876e-12
+>>> type(ff1)
+<class 'float'>
+
+>>> dv1=0b1101010 #Двоичное число
+>>> type(dv1)
+<class 'int'>
+```
+Двоичное число сохранено в объекте класса int
+
+```py
+>>> vsm1=0o52765 #Восьмеричное число
+>>> type(vsm1)
+<class 'int'>
+
+>>> shest1=0x7109af6 #Шестнадцатеричное число
+>>> type(shest1)
+<class 'int'>
+
+cc1=2-3j
+type(cc1)
+<class 'complex'>
+```
+
+Создание комплексного числа:
+
+```py
+a=3.67; b=-0.45
+cc2=complex(a,b)
+type(cc2)
+<class 'complex'>
+```
+
+### 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)
+<class 'bool'> 
+
+>>> n=16
+>>> type(n)
+<class 'int'>
+
+>>> k = 'Привет'
+>>> type(k)
+<class 'str'>
+```
+
+## Пункт 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)
+          
+<class 'list'>
+```
+
+### 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 "<pyshell#161>", line 1, in <module>
+    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)
+          
+<class 'tuple'>
+```
+
+## 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. Конец сеанса
+