форкнуто от main/python-labs
Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
708 строки
31 KiB
Markdown
708 строки
31 KiB
Markdown
Протокол ПО АС по ТЕМЕ 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)
|
|
<class 'int'>
|
|
```
|
|
Для удаления объекта или его части из оперативной памяти используем инструкцию 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)
|
|
<zip object at 0x000002039D4C0C80>
|
|
```
|
|
Это итератор - указатель на объект памяти.
|
|
|
|
## 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) #функция, показывающая тип (класс) объекта
|
|
<class 'bool'>
|
|
```
|
|
|
|
### 7.2. Другие простые типы
|
|
|
|
Целое число (десятичное)
|
|
```
|
|
>>> ii1 = 1234567890
|
|
>>> type(ii1)
|
|
<class 'int'>
|
|
```
|
|
|
|
Экспоненциальная форма записи числа
|
|
```
|
|
>>> ff1 = 8.987e-12
|
|
>>> type(ff1)
|
|
<class 'float'>
|
|
```
|
|
|
|
Двоичное число (префикс 0b - binary)
|
|
```
|
|
>>> dv1 = 0b1100101
|
|
>>> type(dv1)
|
|
<class 'int'>
|
|
```
|
|
|
|
Восьмеричное число (0о - octal)
|
|
```
|
|
>>> vsm1 = 0o52765
|
|
>>> type(vsm1)
|
|
<class 'int'>
|
|
```
|
|
|
|
Шестнадцатеричное число (0х - hexadecimal)
|
|
```
|
|
>>> shest1 = 0x7109af6
|
|
>>> type(shest1)
|
|
<class 'int'>
|
|
```
|
|
|
|
Комплексное число
|
|
```
|
|
>>> cc1 = 2 - 3j
|
|
>>> type(cc1)
|
|
<class 'complex'>
|
|
```
|
|
|
|
Создание комплексного числа
|
|
```
|
|
>>> a = 3.67
|
|
>>> b = 0.45
|
|
>>> cc2 = complex (a, b)
|
|
>>> cc2
|
|
(3.67+0.45j)
|
|
>>> type (cc2)
|
|
<class 'complex'>
|
|
```
|
|
|
|
### 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 "<pyshell#83>", line 1, in <module>
|
|
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)
|
|
<class 'int'>
|
|
>>>obj2 = hex(obj1)
|
|
>>>obj2
|
|
'0x19'
|
|
>>>type(obj2)
|
|
<class 'str'>
|
|
```
|
|
|
|
## 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 "<pyshell#161>", line 1, in <module>
|
|
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. Завершение сеанса работы |