python-labs/TEMA3/report3.md

Тема 3. Операции с объектами

Выполнил : Тимошенко А.А. Проверил : Козлюк Д.А.

Пункт 1.

>>> import os
>>> os.chdir('C:\\Users\\mapon\\OneDrive\\Рабочий стол\\ПО АС\\ТЕМА3')

Пункт 2.

Пункт 2.1

Преобразование в логический тип (bool())

Различные варианты:

>>> logiz1=bool(56)
>>> logiz1
True
>>> logiz2=bool(0)
>>> logiz2
False
>>> logiz3=bool("Beta")
>>> logiz3
True
>>> logiz4=bool("")
>>> logiz4
False

Пункт 2.2 Преобразование в целое с заданной системой счисления (по умолчанию десятичная)

>>> 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#34>", line 1, in <module>
    tt5=int("98.76")
ValueError: invalid literal for int() with base 10: '98.76'

Как видно, последняя команда вернула диагностическое сообщение. Это происходит потому, что команда int ожидает, что ей сообщат строку, похожую на тип int (только цифры, может быть знак в начале). Здесь есть точка, поэтому вознакает несоответствие ожидаемого формата фактическому. Можно сначала строку перевести в число с плавающей точкой, а потом уже в int.

Еще варианты:

>>> tt6=int("+43")
>>> tt6
43
>>> tt6=int("aaa")
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    tt6=int("aaa")
ValueError: invalid literal for int() with base 10: 'aaa'
>>> tt6=int("aaa", 16)
>>> tt6
2730

Преобразование в вещественное число:

>>> flt1 = float(789)
>>> flt1
789.0
>>> flt2=float(-6.78e2)
>>> flt2
-678.0
>>> flt3=float("Infinity")
>>> flt3
inf
>>> flt4=float("-inf")
>>> flt4
-inf
>>> flt5=float(False)
>>> flt5
0.0
>>> flt6=float(True)
>>> flt6
1.0

Пункт 2.3

Преобразование в другие системы счисления.

>>> hh=123
>>> dv1 = bin(hh)
>>> dv1
'0b1111011'
>>> vos1 = oct(hh)
>>> vos1
'0o173'
>>> shs1 = hex(hh)
>>> shs1
'0x7b'

Обратный перевод с целью проверки:

>>> int(dv1, 2)
123
>>> int(vos1, 8)
123
>>> int(shs1, 16)
123
>>> hh == int(shs1, 16)
True

Пункт 3.

Преобразования более сложных типов

Пункт 3.1

Преобразование в строку (str()).

>>> 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

Преобразование в список

>>> 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']

Как видно, такая команда вернула список только из ключей. Можно написать так, чтобы в список попали только значения:

>>> spis4 = list({"A":1,"B":2,"C":9}.values())
>>> spis4
[1, 2, 9]

Пункт 3.3

Преобразование в кортеж (tuple())

>>> kort7=tuple('Строка символов')
>>> kort7
('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в')
>>> kort8 = tuple(spis2)
>>> kort8
(124, 236, -15, 908)
>>> kort9 = tuple(({"A":1,"B":2,"C":9}))
>>> kort9
('A', 'B', 'C')

Аналогично предыдущему пункту, в кортеж попали только ключи. Значения можно записать в кортеж так:

>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values()))
>>> kort9
(1, 2, 9)

Пункт 3.4

>>> del strk5, kort8

Проверим:

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__',
 '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'flt5', 'flt6', 'hh', 'kort7',
 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'logiz5', 'logiz6', 'logiz7', 'logiz8',
 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spis5', 'strk1', 'strk2', 'strk3',
 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt6', 'vos1']

Пункт 4.

Арифметические операции

Пункт 4.1

Сложение и вычитание

>>> 12 + 7 + 90
109
>>> 5.689e-1 - 0.456
0.11289999999999994 

>>> 23.6+54
77.6
>>> 14-56.7+89
46.3

Пункт 4.2

Умножение

>>> -6.7*12
-80.4

Пункт 4.3

Деление

>>> -234.5/6
-39.083333333333336
>>> a=178/45
>>> a
3.9555555555555557
>>> type(a)
<class 'float'>

Пункт 4.4

Деление с округлением вниз (целая часть) (//)

>>> b=178//45
>>> b
3

Посмотрим результат обычного деления:

>>> 178/45
3.9555555555555557

>>> c=-24.6//12.1
>>> c
-3.0
>>> -24.6/12.1
-2.0330578512396698

>>> d = 65.45//13
>>> d
5.0
>>> 65.45/13
5.0346153846153845

>>> e = 75//3.78
>>> e
19.0
>>> 75/3.78
>>> 19.841269841269842

Пункт 4.5

Получение остатка от деления (%)

>>> 148%33
16
>>> 12.6%3.8
1.2000000000000002
>>> 34%2.3
1.8000000000000025
>>> 56.97%6
2.969999999999999

Пункт 4.6

Возведение в степень (**)

>>> 14**3
2744
>>> 2.7**3.6
35.719843790663525

Попробуем проделать арифметические операции над комплексными числами. Создадим два комплексных числа

>>> comp1 = (3 + 2j)
>>> type(comp1)
<class 'complex'>
>>> comp2 = (6 - 4j)
>>> type(comp2)
<class 'complex'>

Сложение

>>> comp1 + comp2
(9-2j)

Вычитание

>>> comp1 - comp2
(-3+6j)

Умножение

>>> comp1 * comp2
(26+0j)
>>> type(comp1 * comp2)
<class 'complex'>

Деление

>>> comp1 / comp2
(0.19230769230769232+0.46153846153846156j)

Целочисленное деление

>>> comp1 // comp2
Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    comp1 // comp2
TypeError: can't take floor of complex number.

>>> comp1 // 6
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    comp1 // 6
TypeError: can't take floor of complex number.

Взятие остатка от деления

>>> comp1 % comp2
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    comp1 % comp2
TypeError: can't mod complex numbers.

>>> comp1 % 6
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    comp1 % 6
TypeError: can't mod complex numbers.

Возведение в степень

>>> comp1 ** comp2
(-717.4651414273118-23072.00404010235j)

Пункт 5

Операции с двоичными представлениями чисел

Пункт 5.1

Двоичная инверсия (в двоичном виде 0 меняется на 1 и наоборот)

>>> dv1 = 9
>>> dv2 = ~dv1
>>> dv2
-10
>>> bin(dv1)
'0b1001'
>>> bin(dv2)
'-0b1010'

Видно, что результат не совсем совпадает с ожидаемым видом "0110". Вот почему эту происходит: в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака. Знак в двоичных числах записывается с помощью дополнительного кода. Получается, происходит следующее: 1. Было число 9 (1001) 2. Меняем все значения на противоположные, станет 0110 3. Теперь надо поменять знак. Чтобы поменять знак, надо, во-первых, инвертировать все значения разрядов - будет опять 1001 4. Во-вторых, надо прибавить к полученному числу еще единицу, которая как раз и отвечает за минус. Будет 1001 + 1 = 1010.

Пункт 5.2

Двоичное "И" (&)

>>> bin(7&9)
'0b1'

Пояснение: 7 в двоичной системе счисления: 0111 9 в двоичной системе счисления: 1001 Совпадение единиц только в первом разряде, поэтому итог - 0001 или просто 1

>>> bin(7&8)
'0b0'

Пояснение: 7 в двоичной системе счисления: 0111 8 в двоичной системе счисления: 1000 Совпадений единиц нет, итог - 0000 или просто 0

Пункт 5.3

Двоичное "ИЛИ" (|)

>>> bin(7|9)
'0b1111'

Пояснение: 7 в двоичной системе счисления: 0111 9 в двоичной системе счисления: 1001 Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111

>>> bin(7|8)
'0b1111'

Пояснение: 7 в двоичной системе счисления: 0111 8 в двоичной системе счисления: 1000 Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111

>>> bin (14|5)
'0b1111'

Пояснение: 14 в двоичной системе счисления: 1110 5 в двоичной системе счисления: 0101 Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111

Пункт 5.4

Двоичный XOR (^) (возвращается единица, если оба разряда разные)

>>> bin(14^5)
'0b1011'

Пояснение: 14 в двоичной системе счисления: 1110 5 в двоичной системе счисления: 0101 Возвращается 1, если оба разряда разные, поэтому итог - 1011

В десятичном представлении:

>>> 14^5
11

Пункт 5.5

Побитовый сдвиг (<< влево) и (>> вправо). Биты, которые "выпадают" за пределы числа, отбрасываются. Освободившиеся позиции заполняются нулями.

>>> h = 14
>>> bin(h)
'0b1110'

Сдвиг на два разряда влево:

>>> g = h << 2
>>> g
56

Пояснение:

>>> bin(g)
'0b111000'

Было 001110. Сдвинули влево на один разряд, будет 011100. Сдвинули еще раз - 111000. Слева можно добавить сколько угодно незначащих нулей, чтобы было нагляднее.

Сдвиг на один разряд вправо:

>>> g1 = h >> 1
>>> g1
7

Пояснение:

>>> bin(g1)
'0b111'

Было 1110. Стало 0111. Можно откинуть незначащий ноль.

Сдвиг на два разряда вправо:

>>> g2 = h >> 2
>>> g2
3

Пояснение:

>>> bin(g2)
'0b11'

Было 1110. Сдвиг вправо на один разряд: 0111. Еще на один - 0011 (Биты, выходящие за правый край, отбрасываются).

Возьмем два двоичных числа: 1011101 (в десятичной системе это 93) 1100110 (в десятичной системе это 102)

Побитовая инверсия

>>> ~93
-94
>>> bin(~93)
'-0b1011110'

Двоичное И ``

bin(93&102) '0b1000100'

Двоичное ИЛИ

bin(93|102) '0b1111111'

Двоичное XOR

bin(93^102) '0b111011' #Число стало короче, т.к. автоматически убрался незначащий ноль слева

Побитовый сдвиг

93 >> 3 11 bin(93 >> 3) '0b1011'

102 << 2 408 bin (102 << 2) '0b110011000'

## Пункт 6

Операции при работе с последовательности

### Пункт 6.1

Конкатенация (объединение)

Строки

'Система '+'регулирования' 'Система регулирования'

Списки

['abc','de','fg']+['hi','jkl'] ['abc', 'de', 'fg', 'hi', 'jkl']

Кортежи
>>> ('abc','de','fg')+('hi','jkl')
('abc', 'de', 'fg', 'hi', 'jkl')

Конкатериновать словари и множества нельзя.

{'one':1 , 'two':2} + {'three':3} Traceback (most recent call last): File "<pyshell#90>", line 1, in {'one':1 , 'two':2} + {'three':3} TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

{1, 2} + {1, 3, 3, 4} Traceback (most recent call last): File "<pyshell#85>", line 1, in {1, 2} + {1, 3, 3, 4} TypeError: unsupported operand type(s) for +: 'set' and 'set'

### Пункт 6.2

Повторение (*)

'ля-'*5 'ля-ля-ля-ля-ля-'

['ку','-']*3 ['ку', '-', 'ку', '-', 'ку', '-']

('кис','-')*4 ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')

signal1=[0]*3+[1]*99 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)

stroka='Система автоматического управления' 'автомат' in stroka True 'ку' in ['ку','-']*3 True 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') False

### Пункт 6.4

Подстановка значений в строку с помощью оператора «%»

Подстановка возвращает новую строку, но не перезаписывает исходную.

stroka='Температура = %g %s %g' stroka % (16,' меньше ',25) 'Температура = 16 меньше 25' stroka 'Температура = %g %s %g'

Если сообщим меньше вставок, чем требует строка:

stroka % (16, "меньше") Traceback (most recent call last): File "<pyshell#113>", line 1, in stroka % (16, "меньше") TypeError: not enough arguments for format string

Если больше:

stroka1 % (2024, 21) 'Сейчас 2024 год 21 века' stroka1 % (2024, 21, 45) Traceback (most recent call last): File "<pyshell#118>", line 1, in stroka1 % (2024, 21, 45) TypeError: not all arguments converted during string formatting

Вот различные типы вставок для оператора %:
    %s - строка
    %d и %i - целое число (d - всегда десятичное, а i - десятичное или переведенное
         в десятичное из другой с/с, а еще может содержать знак)
    %f - число с плавающей точкой
    %e - экспоненциальная форма записи числа
    %g - автовыбор между e и f в зависимости от размера (очень большие и очень близкие к нулю
         числа удобнее записать в экспоненциальной форме. Обычно %g будет использовать %f,
         если значение находится в пределах от 1e-4 до 1e+15)
    %.nf - число с плавающей точкой, но конкретным количеством знаков после запятой (пр. %.2f)

stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' stroka % {'zn1':16,'sravn':' меньше ','zn2':25} 'Температура = 16 меньше 25'

## Пункт 7

Оператор присваивания

### Пункт 7.1

Обычное присваивание

zz = -12 zz -12

### Пункт 7.2

Присваивание одновременно с уменьшением или вычитанием (на уровне выполнения
сначала происходит арифметическая операция, а потом присваивание)

zz += 5 zz -7

zz -= 3 zz -10

Конкатенация строк:

stroka = 'Система' stroka += ' регулирования' stroka 'Система регулирования'

### Пункт 7.3

Присваивание с умножением и делением.

type(zz) <class 'int'> zz /= 2 zz -5.0 type(zz) <class 'float'>

zz *= 5 zz -25.0

Для строк:

stroka = "mew " stroka *= 3 stroka 'mew mew mew '

### Пункт 7.4

zz //= 4 zz -7.0

zz %= -0.45 zz -0.24999999999999983

### Пункт 7.5

Множественное присваивание

1) Присваивание одного значения нескольким переменным:

w = v = 10 w 10 v 10

2) Кортежное присваивание

n1, n2, n3 = (11, -3, 'all') n1 11 n2 -3 n3 'all'

Попробуем использовать другие коллекции:

Список

x1, x2, x3 = ["a", 67, None] x1 'a' x2 67 x3 type(x3) <class 'NoneType'>

Словарь

s1, s2, s3 = {"one": 1, "two": 2, "three": 3} s1, s2, s3 ('one', 'two', 'three')

По умолчанию в словарях итерируются именно ключи. Если нужно задать значения, то это надо
указать отдельно:

s1, s2, s3 = {"one": 1, "two": 2, "three": 3}.values() s1, s2, s3 (1, 2, 3)

Если в каждую переменную надо положить именно и ключ, и значение одновременно, можно
использовать метод .items(), который каждую пару ключ-значение упаковывает в отдельный
кортеж

y1, y2, y3 = {"one": 1, "two": 2, "three": 3}.items() y1 ('one', 1) y2 ('two', 2) y3 ('three', 3)

Множество

Множество можно использовать для присваивания, но иногда порядок может быть иным:

m1, m2, m3 = {1, 2, 3} m1, m2, m3 (1, 2, 3)

m1, m2, m3 = {54, 9, 0} m1, m2, m3 (0, 9, 54)

Строка

c1, c2, c3 = "cat", "dog", "pig" c1, c2, c3 ('cat', 'dog', 'pig')

## Пункт 8

Логические операции

### Пункт 8.1

Используем операции сравнения на ранее созданных переменных:

w == v True w != v False w < v False w > v False w <= v True w >= v True

### Пункт 8.2

Проверка наличия заданного элемента

В множестве:

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

Создание больших логических выражений

a = 17 b = 6 (a >= b) and ('book' in mnoz1) and not ('Pskov' in dic1) True

Собственные примеры:

((per1 + 50) in dic1.values()) and not per2 or 'Tula' in dic1 True

not(len(dic1) == 3) or (sum(dic1.values()) > 300) or ('ITAE' in dct1['Depart']) False

### Пункт 8.4

Проверка ссылок переменных на один и тот же объект

Проверим is для разных объектов неизменяемого типа с одним значением

v = w = 10 w is v True

Попробуем создать два списка с одинаковым значением:

w1 = ['A', 'B'] v1 = ['A', 'B'] w1 is v1 False

Но при этом:

w1 == v1 True

--Почему так происходит?--
Оператор is проверяет, ссылаются ли объекты на один и тот же адрес в памяти. Переменные
целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти.
Словари были созданы в разных строках, и адреса они разные, т.е. они ссылаются на разные
участки в памяти, поэтому is возвращает False. Можно убедиться в этом наглядно: 

id(w) 140732520269000

id(v) 140732520269000

Видно, что адрес памяти объекта одинаковый.

Теперь проверим для списков:

id(w1) 1342934277312

id(v1) 1342934274048

Видно, что адреса разные.


## Пункт 9

Операции с объектами, выполняемые с помощью методов

stroka='Микропроцессорная система управления' dir(stroka) ['add', 'class', 'contains', 'delattr', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'getnewargs', '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

Методы строк

Поиск первого вхождения подстроки

stroka.find('пр') 5

Поиск количества вхождений подстроки

stroka.count("с") 4

У обоих методов в качестве доп. аргумента можно указать срез.

Замена подстроки

stroka.replace(' у',' автоматического у') 'Микропроцессорная система автоматического управления'

Это возвращает новую строку, но не перезаписывает исходную.

Разделение по separator'у

spis22=stroka.split(' ') spis22 ['Микропроцессорная', 'система', 'управления']

Все буквы заглавные

stroka.upper() 'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'

Все буквы строчные

stroka.lower() 'микропроцессорная система управления'

Собрать строку из элементов списка

stroka3=" ".join(spis22) stroka3 'Микропроцессорная система управления'

В кавычках указывается разделитель, в скобках после join - объект, из которого собираем
строку

Разделение по первой входящей подстроке

stroka3.partition("с") ('Микропроце', 'с', 'сорная система управления')

Разделение по последней входящей подстроке

stroka3.rpartition("с") ('Микропроцессорная си', 'с', 'тема управления')

Форматирование

strk1='Момент времени {}, значение = {}' strk1 'Момент времени {}, значение = {}' strk1.format(1,89.7) 'Момент времени 1, значение = 89.7'

Можно указать порядок:

strk2='Момент времени {1}, значение = {0}:{2} strk2 'Момент времени {1}, значение = {0}:{2}' strk2.format(36.7,2,'норма!') 'Момент времени 2, значение = 36.7:норма!'

Или можно подставить имена аргументов-вставок, и тогда порядок подстановки может быть
произвольным:

strk3='Момент времени {num}, значение = {znch}' strk3 'Момент времени {num}, значение = {znch}' strk3.format(znch=89.7,num=2) 'Момент времени 2, значение = 89.7'

### Пункт 9.2

Методы списков

spsk = [12, "kitten", (1, 2), "a", 56.78]

Удаление элемента по индексу и сдвиг последующих влево

spsk.pop(2) (1, 2) spsk [12, 'kitten', 'a', 56.78]

Вставка элемента в конец

spsk.append('c') spsk [12, 'kitten', 'a', 56.78, 'c']

Можно вставить только один элемент, иначе TypeError

Вставка элемента в конкретное место по индексу

spsk.insert(2,'a') spsk [12, 'kitten', 'a', 'a', 56.78, 'c']

Подсчет количества элементов по значению

spsk.count('a') 2

### Пункт 9.3

Методы кортежей

Кортежи неизменяемы, поэтому методов, связанных с удалением или добавлением элементов, нет.
Есть два:

cor = (11, "oopsie", "doopsie", 64.9, 5+7j)

Подсчет количества элементов по значению

cor.count(11) 1

Поиск индекса первого вхождения

Если не найдено, то ValueError

cor.index(64.9) 3 cor.index("nothing") Traceback (most recent call last): File "<pyshell#316>", line 1, in cor.index("nothing") ValueError: tuple.index(x): x not in tuple

### Пункт 9.4

Методы словарей

Создание поверхностной копии

Создается копия, но новые значения не создаются с нуля, а просто ссылаются на предыдущие:

newdi = di.copy() newdi {'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False}

Возвращение значения по ключу

di.get("key2") 'val2'

Если такого ключа нет, возвращается None

print(di.get("key77")) None

Возвращение кортежей из пар ключ-значение

di.items() dict_items([('key1', 1), ('key2', 'val2'), ('key3', 34.6), ('key4', 'f'), ('key5', False)]) type(di.items()) <class 'dict_items'>

Возвращение объекта только из ключей

di.keys() dict_keys(['key1', 'key2', 'key3', 'key4', 'key5'])

Возвращение объекта только из значений

di.values() dict_values([1, 'val2', 34.6, 'f', False])

Пояснение:
    Возвращаются объекты dict_keys, dict_values, dict_items, и они - объекты-итераторы. Они
    ссылаются на адреса ключей или значений в памяти, но не хранят значения. Также эти объекты
    автоматически обновляются при обновлении словаря. Например, добавим в словарь пару:

>>> di["key6"] = 546
>>> di
{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False, 'key6': 546}

    Теперь в отдельный объект положим dict_keys:

>>> dikeys = di.keys()
>>> dikeys
dict_keys(['key1', 'key2', 'key3', 'key4', 'key5', 'key6'])

    Удалим с помощью метода .popitem() последний добавленный элемент:

>>> di.popitem()
('key6', 546)

    Вот как теперь выглядит словарь:

>>> di
{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False}

    Вот как выглядит dikeys:

>>> dikeys
dict_keys(['key1', 'key2', 'key3', 'key4', 'key5'])

Полное очищение словаря

newdi.clear() newdi {}

Удаление ключа и возвращение значения

di.pop("key3") 34.6 di {'key1': 1, 'key2': 'val2', 'key4': 'f', 'key5': False}

Методы множеств

se = {1, "val2", 34.6, "f", False, 546} se {False, 1, 34.6, 546, 'f', 'val2'}

Добавление элемента

se.add(5+6j) se {False, 1, 34.6, 546, (5+6j), 'f', 'val2'}

Создание поверхностной копии

newse = se.copy() newse {False, 1, 34.6, 546, (5+6j), 'f', 'val2'}

Удаление элемента по значению с KeyError при отсутствии

se.remove(1) se {False, 34.6, 546, (5+6j), 'f', 'val2'} se.remove(90000) Traceback (most recent call last): File "<pyshell#348>", line 1, in se.remove(90000) KeyError: 90000

Удаление элемента по значению с возвратом None при отсутствии

se.discard("f") se.discard(90000) print(se.discard(90000)) None

Очищение множества

newse.clear() newse set()

Удаление и возвращение случайного элемента из множества

se.pop() False se {34.6, 546, (5+6j), 'val2'}

Добавление элементов

se.update({True, "kekeke"}) se {True, 34.6, 546, 'val2', (5+6j), 'kekeke'}