From 6d7d7012be5a27d29fafa79db6eabe492fec54dc Mon Sep 17 00:00:00 2001 From: MelnikovDM Date: Tue, 9 Sep 2025 23:23:40 +0300 Subject: [PATCH] Add new file --- TEMA2/report.md | 706 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 706 insertions(+) create mode 100644 TEMA2/report.md diff --git a/TEMA2/report.md b/TEMA2/report.md new file mode 100644 index 0000000..4692c74 --- /dev/null +++ b/TEMA2/report.md @@ -0,0 +1,706 @@ +#Протокол ПО АС по ТЕМЕ 2 +#Выполнил: Мельников Д. М. +#Проверил: Козлюк Д. А. + +#Цель темы: изучение применения простых конструкций языка Python в операциях с данными. + +##1. Запуск оболочки IDLE и установка рабочего каталога + +##2. Изучение простых объектов +Рассмотрим операции присваивания значения объектам-переменным +``` +>>>f1=16; f2=3 +``` +Для того, чтобы узнать, какое значение имеет переменная, достаточно перечислить их имена в строке, разделяя их знаком «,» (запятая) или «;» (точка с запятой) : +``` +>>>f1,f2 +>>>f1;f2 +(16, 3) +``` + +Для того, чтобы узнать, какие объекты уже существуют в данный момент в среде Python (в пространстве имен), используем функцию dir без аргументов: +``` +>>>dir() +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2'] +``` +Для получения списка атрибутов любого объекта используем ту же функцию dir(), с аргументами – именами интересующих объектов, например: +``` +>>>dir(f1) +['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] +``` + +Для определения классовой принадлежности любого объекта следует использовать функцию type(): +``` +>>>type(f2) + +``` +Для удаления объекта или его части из оперативной памяти используем инструкцию del, например: +``` +>>>del f1,f2 +``` +Проверим, остались ли эти объекты в памяти. +``` +>>>dir() +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__'] +``` +Видим, что объекты удалились. + +##3. Изучение правила именования объектов в Python. +Правила именования: + • имена должны состоять из латинских букв, цифр и символов подчеркивания; + • имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных); + • имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python; + • большие и малые буквы в именах различаются (имена – чувствительные к регистру)! +С учетом этих правил в командном окне IDLE выполните следующие операции (если после ввода инструкции не появляется диагностическое сообщение, убедитесь, что переменная получила введенное значение): +``` +>>>gg1=1.6 #значение в виде вещественного числа +>>>gg1 +1.6 +>>>hh1='Строка' #значение в виде символьной строки +>>>hh1 +'Строка' +>>>73sr=3 #неправильное имя – начинается с цифры - будет диагностика! +SyntaxError: invalid decimal literal +>>>and=7 #недопустимое имя – совпадает с ключевым словом - будет диагностика! +SyntaxError: invalid syntax +``` +##4. Вывод списка ключевых слов с помощью инструкции +``` +>>>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'] +``` +Просмотрим список, сохраним его в переменной с некоторым именем. +``` +>>>kwd = keyword.kwlist +>>>kwd +['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. Ввод списка встроенных идентификаторов с помощью инструкций +``` +>>>import builtins +>>>dir(builtins) +['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip'] +``` +Изучим назначение функций: abs, len, max, min, pow, round, sorted, sum, zip: + +Взятие модуля: +``` +>>>abs(-10) +10 +``` + +Длина списка: +``` +>>>len([1, 2, 3]) +3 +``` + +Выбор максимального значения: +``` +>>>max(10, 5) +10 +``` + +Выбор минимального значения: +``` +>>>min(10, 5) +5 +``` + +Возведение в степень: +``` +>>>pow(5, 2) +25 +``` +Возведение в степень по модулю: +``` +>>>pow(5, 2, 2) +1 +``` +Округление до целого: +``` +>>>round(5,298) +5 +``` +Сортировка по возрастанию(можно применить reverse = True для сортировки по убыванию): +``` +>>>sorted([3, 10, 4, 15, 7]) +[3, 4, 7, 10, 15] +``` +Суммирование: +``` +>>>sum([10, 5 ,7]) +22 +``` +Объединение объектов в кортеж (возвращается указатель на участок памяти) +>>> list1 = [1, 2, 2] +>>> list2 = [3, 4, 5] +>>> zip (list1, list2) + +Это итератор - указатель на объект памяти. + +## 6. Пример того, что Python - регистрочувствительный язык. +``` +>>>Gg1 = 45 +>>>gg1, Gg1 +(1.6, 45) +``` + +## 7. Изучение простых базовых типов объектов: логический (bool), целый (int), вещественный (float), комплексный (complex), строка символов (str). + +### 7.1. Логический тип. +``` +>>>bb1=True; bb2=False +>>>bb1;bb2 +True +False +>>>type(bb1) #функция, показывающая тип (класс) объекта + +``` + +### 7.2. Другие простые типы + +Целое число (десятичное) +``` +>>> ii1 = 1234567890 +>>> type(ii1) + +``` + +Экспоненциальная форма записи числа +``` +>>> ff1 = 8.987e-12 +>>> type(ff1) + +``` + +Двоичное число (префикс 0b - binary) +``` +>>> dv1 = 0b1100101 +>>> type(dv1) + +``` + +Восьмеричное число (0о - octal) +``` +>>> vsm1 = 0o52765 +>>> type(vsm1) + +``` + +Шестнадцатеричное число (0х - hexadecimal) +``` +>>> shest1 = 0x7109af6 +>>> type(shest1) + +``` + +Комплексное число +``` +>>> cc1 = 2 - 3j +>>> type(cc1) + +``` + +Создание комплексного числа +``` +>>> a = 3.67 +>>> b = 0.45 +>>> cc2 = complex (a, b) +>>> cc2 +(3.67+0.45j) +>>> type (cc2) + +``` + +### 7.3. Строка символов +``` +>>>ss1='Это - строка символов' +>>>ss1 +'Это - строка символов' +``` +Строки можно заключать в апострофы или в двойные кавычки: +``` +>>>ss1="Это - строка символов" +>>>ss1 +'Это - строка символов' +``` +Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие. Пример: +``` +>>>ss1a="Это - \" строка символов \", \n \t выводимая на двух строках" +>>>print(ss1a) +Это - " строка символов ", + выводимая на двух строках + +``` + +Создадим строку по шаблону: +``` +>>>ss1b= 'Меня зовут: \n <Мельников Д. М.>' +>>>print(ss1b) +Меня зовут: + <Мельников Д. М.> + +``` +Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек, например, +``` +>>>mnogo="""Нетрудно заметить , что в результате операции +над числами разных типов получается число, +имеющее более сложный тип из тех, которые участвуют в операции.""" +>>>print(mnogo) +Нетрудно заметить , что в результате операции +над числами разных типов получается число, +имеющее более сложный тип из тех, которые участвуют в операции. +``` +При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки. +Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. При этом надо учитывать, что нумерация символов начинается с 0. Например, +``` +>>>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 +' тоасм' +``` +Обратим внимание на то, что в срезе указываются не позиции элементов, а их индексы и что указываемая правая граница в срез не включается. + +Значение при отрицательном значении шага: +``` +>>>ss1[17:3:-2] +'омсаот ' +``` +При замене 17 на -4 получается такой же результат: +``` +ss1[-4:3:-2] +'омсаот ' +``` +Строка является неизменяемым объектом. Попробуем, например, инструкцию +``` +>>>ss1[4]='=' # Будет диагностика! +Traceback (most recent call last): + File "", line 1, in + ss1[4] = '=' +TypeError: 'str' object does not support item assignment +``` +Однако, можно это сделать по-другому, переопределив строку: +``` +>>>ss1 = ss1[:4] + '=' + ss1[5:] +>>>ss1 +'Это = строка символов' +``` +С использованием ранее созданной строки ss1b попробуем создать объекты с разными срезами исходной строки. +``` +>>>ss1b[0:5] +'Меня ' +>>>ss1b[:10:2] +'Мн оу' +``` +Самостоятельное создание объектов разных типов. Отображение типов и значений созданных объектов. +``` +>>>obj1 = 25 +>>>type(obj1) + +>>>obj2 = hex(obj1) +>>>obj2 +'0x19' +>>>type(obj2) + +``` + +## 8. Списки (list), кортежи (tuple), словари (dict), множества (set). + +### 8.1. Список – это последовательность: упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания. +Пример списка с 3 элементами разных типов: +``` +>>>spis1=[111,'Spisok',5-9j] +>>>spis1 +[111, 'Spisok', (5-9j)] +``` +Еще пример: список, содержащий последовательность отсчетов сигнала в виде «единичной ступеньки»: +``` +>>>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] + +``` +При работе с элементами списка можно использовать индексы точно так же, как это делали с элементами символьной строки, например, ссылка на последний элемент списка: +``` +>>>spis1[-1] +(5-9j) +``` +или +``` +>>>stup[-8::2] +[0, 1, 1, 1] +``` +Проверим возможность изменения списка, например, +``` +>>>spis1[1] = 'Список' +>>>spis1 +[111, 'Список', (5-9j)] +``` +Текущее число элементов в списке можно узнать с помощью функции len(): +``` +>>>len(spis1) +3 +``` +Методы объекта находятся в списке его атрибутов, который выводится с помощью уже известной функции dir(). Описание метода можно вывести с помощью функции help() по образцу +``` +>>>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'] # В конец списка добавлен элемент «New item» +>>>spis1+['New item'] +[111, 'Список', (5-9j), 'New item', 'New item'] +``` +Обратим внимание на то, что в этой инструкции новый список только отображается, но не сохраняется! + +Добавим в конец списка spis1 строку ss1b и отобразите список. +Удаление элемента: +``` +>>>spis1.pop(1) #Из списка удален элемент с индексом 1 +'Список' +>>>spis1 +[111, (5-9j), 'New item'] +``` +Также могут использоваться методы insert, remove, extend, clear, sort, reverse, copy, count, index: + +1. Для insert (Вставка элемента в определенное место по индексу) +``` +>>>help(spis1.insert) +Help on built-in function insert: + +insert(index, object, /) method of builtins.list instance + Insert object before index. + +>>>spis1.insert(3, "hello") +>>>spis1 +[111, (5-9j), 'New item', 'hello'] + +``` + +2. Для remove (Удаление элемента по значению) +``` +>>>help(spis1.remove) +Help on built-in function remove: + +remove(value, /) method of builtins.list instance + Remove first occurrence of value. + + Raises ValueError if the value is not present. + +>>>spis1.remove(111) +>>>spis1 +[(5-9j), 'New item', 'hello'] +``` + +3. Для extend (Добавление элементов объекта в конец другого объекта) +``` +>>>help(spis1.extend) +Help on built-in function extend: + +extend(iterable, /) method of builtins.list instance + Extend list by appending elements from the iterable. + +>>>per1 = [123, "new", (7, 5)] +>>>spis1.extend(per1) +>>>spis1 +[(5-9j), 'New item', 'hello', 123, 'new', (7, 5)] +``` + +4. Для clear (Полное очищение списка) +``` +>>>help(spis1.clear) +Help on built-in function clear: + +clear() method of builtins.list instance + Remove all items from list. + +>>>per1.clear() +>>>per1 +[] +``` + +5. Для sort ( Сортировка списка без создания нового объекта) +``` +>>>help(spis1.sort) +Help on built-in function sort: + +sort(*, key=None, reverse=False) method of builtins.list instance + Sort the list in ascending order and return None. + + The sort is in-place (i.e. the list itself is modified) and stable (i.e. the + order of two equal elements is maintained). + + If a key function is given, apply it once to each list item and sort them, + ascending or descending, according to their function values. + + The reverse flag can be set to sort in descending order. + +>>>per1 = [1, 2, 3.77777, 8, 9, -3, 0] +>>>per1.sort(key = abs, reverse = False) +>>>per1 +[0, 1, 2, -3, 3.77777, 8, 9] + +``` + +6. Для copy (Создание копии списка) +``` +>>>help(spis1.copy) +Help on built-in function copy: + +copy() method of builtins.list instance + Return a shallow copy of the list. + +>>>copyper = per1.copy() +>>>copyper +[0, 1, 2, -3, 3.77777, 8, 9] +``` +7. Для count (Подсчет количества элементов по значению) +``` +>>>help(spis1.count) +Help on built-in function count: + +count(value, /) method of builtins.list instance + Return number of occurrences of value. + +>>>per1.count(5) +0 +>>>per1.count(8) +1 +``` + +8. Для index (Поиск индекса по значению) +``` +>>>help(spis1.index) +Help on built-in function index: + +index(value, start=0, stop=9223372036854775807, /) method of builtins.list instance + Return first index of value. + + Raises ValueError if the value is not present. + +>>>per1.index(2) +2 +``` + +Списки могут быть вложенными: +``` +>>>spis2=[spis1,[4,5,6,7]] #здесь элементами являются два списка +>>>spis2 +[[(5-9j), 'New item', 'hello', 123, 'new', (7, 5)], [4, 5, 6, 7]] +``` +Обращение к элементам вложенного списка +``` +>>>spis2[0][1] #обращение к элементу списка spis1 +'New item' +``` +Изменение элемента вложенного списка: +``` +>>>spis2[0][1] = 78 +>>>spis2 +[[(5-9j), 78, 'hello', 123, 'new', (7, 5)], [4, 5, 6, 7]] +>>>spis1 +[(5-9j), 78, 'hello', 123, 'new', (7, 5)] +``` +Видим, что spis1 тоже изменился. Это происходит потому, что python работает не просто с +объектами, а с ссылками на участки памяти. То есть, в Python списки передаются по ссылке, +а не по значению.Упоминая spis1 в строке spis2=[spis1,[4,5,6,7]] мы не создаем копию spis1, а сообщаем именно тот список, поэтому его изменения в составе spis2 отображаются на исходном spis1. + +Создание своего списка - объекта: +``` +>>>spis3 = [99, 'Test', True, spis1] +>>>spis3 +[99, 'Test', True, [(5-9j), 78, 'hello', 123, 'new', (7, 5)]] +``` + + +### 8.2. Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддер­живают включение в них объектов различных типов и операции, типич­ные для последовательностей. + +Примеры операций с кортежами: создание кортежа +``` +>>>kort1 = (222, 'Kortezh', 77 + 8j) +>>>kort1 +(222, 'Kortezh', (77+8j)) +``` +Изменить кортеж нельзя, но можно его переопределить: +``` +>>>kort1 = kort1 + (1, 2) +>>>kort1 +(222, 'Kortezh', (77+8j), 1, 2) +``` +Если надо добавить еще один элемент в кортеж: +``` +>>>kort1= kort1+(ss1b,) +>>>kort1 +(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n <Мельников Д. М.>') +``` +Теперь переопределим кортеж с удалением комплексного элемента: +``` +>>>kort2 = kort1[:2] + kort1[3:] +>>>kort2 +(222, 'Kortezh', 1, 2, 'Меня зовут: \n <Мельников Д. М.>') +``` + +Два важных метода кортежа (они есть также и у списков): +• Определение индекса заданного элемента: +``` +>>>kort1.index(2) +4 +``` +• Подсчет числа вхождений заданного элемента в кортеже: +``` +>>>kort1.count(222) +1 +``` + +Методов append и pop у кортежей нет, т.к. они являются неизменяемыми. +Попробуем операцию замены элемента кортежа: +``` +>>>kort1[2] = 90 +Traceback (most recent call last): + File "", line 1, in + kort1[2] = 90 +TypeError: 'tuple' object does not support item assignment +``` +Создание объекта-кортежа с элементами разных типов: число, строка, список, кортеж. +``` +>>>kortezh = (333, 'Dmitry', [10, 11, 12], (6, 7, 8)) +>>>kortezh +(333, 'Dmitry', [10, 11, 12], (6, 7, 8)) +``` + +### 8.3. Объект-словарь похож на ассоциативные массивы в других языках программирования. Его содержанием является совокупность пар: «ключ (key)»:«значение (value)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений. +Пример создания словаря: +``` +>>>dic1 = {'Saratov' : 145, 'Orel' : 56, 'Vologda' : 45} +>>>dic1 +{'Saratov': 145, 'Orel': 56, 'Vologda': 45} +``` + +Обращение к элементам словаря не по индексам, а по ключам: +``` +>>>dic1['Orel'] +56 +``` +Пополнение словаря (добавление элемента, изменение словаря): +``` +>>>dic1['Pskov']=78 +>>>dic1 +{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78} +``` +Обратим внимание на то, что в силу неупорядоченности словаря при его выводе элементы могут располагаться не в том порядке, в каком они задавались при его формировании. +Для того, чтобы получить перечень ключей или значений из словаря следует использовать методы keys или values, создающие списки, соответственно, ключей или значений из словаря. +Функция sorted позволяет увидеть список упорядоченным по ключам или по значениям: +``` +>>>sorted(dic1.keys()) +['Orel', 'Pskov', 'Saratov', 'Vologda'] +>>>sorted(dic1.values()) +[45, 56, 78, 145] +``` +Элементы словаря могут быть любого типа, в том числе и словарями. Например, создадим словарь: +```>>> +>>>dic2={1:'mean',2:'standart deviation',3:'correlation'} +>>>dic3={'statistics':dic2,'POAS':['base','elementary','programming']} +>>>dic3['statistics'][2] +'standart deviation' +``` +Создадим более сложный словарь из списка с элементами-кортежами с использованием функции dict: +``` +>>>dic4= dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)]) +>>>dic4 +{1: ['A', 'B', 'C'], 2: [4, 5], 'Q': 'Prim', 'Stroka': 'Меня зовут: \n <Мельников Д. М.>'} +>>>dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b])) +>>>dic5 +{'A': 16, 'B': -3, 'C': 9, 'Stroka': 'Меня зовут: \n <Мельников Д. М.>'} +``` +Самостоятельно придумайте объект-кортеж с 7 элементами и объект-список с 5 элементами и попробуйте создать из них словарь с помощью функций dict и zip. Сколько элементов в получившемся словаре? Объясните это число. +``` +>>>obj_cort = ("plus", "minus", "del", 4, 5, "med", "mod") +>>>obj_cort +('plus', 'minus', 'del', 4, 5, 'med', 'mod') +>>>obj_list = ["one", "two", "three", "four", "five"] +>>>obj_list +['one', 'two', 'three', 'four', 'five'] +>>>obj_dict = dict(zip(obj_list, obj_cort)) +>>>obj_dict +{'one': 'plus', 'two': 'minus', 'three': 'del', 'four': 4, 'five': 5} +``` +Как мы видим длина словаря составляет 5 объектов. Это связано с функцией zip, которая делает так, что длина итогового объекта будет соответствовать минимальной длине составляющего. + +### 8.4. Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи). +Пример создания множества: +``` +>>>mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'} +>>>mnoz1 +{'датчик', 'двигатель', 'линия связи', 'микропроцессор'} +``` +В созданном множестве дубликаты элементов были автоматически удалены. + +Некоторые операции с множеством: +- определение числа элементов +``` +>>>len(mnoz1) +4 +``` +- проверка наличия элемента во множестве +``` +>>>'датчик' in mnoz1 +True +``` +- добавление элемента +``` +>>>mnoz1.add('реле') +>>>mnoz1 +{'двигатель', 'датчик', 'реле', 'линия связи', 'микропроцессор'} +``` + +- удаление элемента +``` +mnoz1.remove('линия связи') +mnoz1 +{'двигатель', 'датчик', 'реле', 'микропроцессор'} +``` +Объект-множество с элементами разных типов. +``` +mnoz2 = {'коробка', 10, True, 'gear'} +mnoz2 +{True, 10, 'gear', 'коробка'} +len(mnoz2) +4 +mnoz2.remove(True) +mnoz2 +{10, 'gear', 'коробка'} + +``` + +## 9. Завершение сеанса работы \ No newline at end of file