# Отчет по теме 3

Володин Денис, А-02-23


## Пункт 1.

Рабочая среда настроена на нахождение в нужной директории:

```py
>>> import os
>>> os.chdir(r'C:\Users\denvo\OneDrive\Рабочий стол\python-labs\TEMA3')
```

## Пункт 2.

## Пункт 2.1

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

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

```py
>>> logiz1=bool(56)
>>> logiz1
True
>>> logiz2=bool(0)
>>> logiz2
False
>>> logiz3=bool("Beta")
>>> logiz3
True
>>> logiz4=bool("")
>>> logiz4
False
>>> logiz5=bool(" ")
>>> logiz5
True
>>> logiz6=bool(-1)
>>> logiz6
True
>>> logiz7=bool(None)
>>> logiz7
False
>>> logiz8=bool([])
>>> logiz8
False
>>> logiz8=bool([" "])
>>> logiz8
True
```

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

```py
>>> 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.

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

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

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

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

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

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

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

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

##  Пункт 3.

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

## Пункт 3.1

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

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

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

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

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

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

## Пункт 3.3

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

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

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

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

## Пункт 3.4

Удаление объектов.

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

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

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

Видно, что результат выглядит неточно. Это связанно с тем, что
вещественные числа в python внутри представляются как двоичные, но не всегда вещественное
число можно представить как двоичное абсолютно точно, из-за этого возникают такие неточности

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

## Пункт 4.2

Умножение

```py
>>> -6.7*12
-80.4
```

## Пункт 4.3

Деление

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

## Пункт 4.4

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

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

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

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

## Пункт 4.6

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

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

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

```py
>>> 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 и наоборот)

```py
>>> 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.

В целом, можно сказать, что в Python двоичная инверсия делает из числа n число -(n+1).

## Пункт 5.2

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

```py
>>> bin(7&9)
'0b1'
>>> bin(7&8)
'0b0'
```

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

## Пункт 5.3

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

```py
>>> bin(7|9)
'0b1111'
>>> bin(7|8)
'0b1111'
>>> bin (14|5)
'0b1111'
```

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

## Пункт 5.4

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

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

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

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

```py
>>> h = 14
>>> bin(h)
'0b1110'
>>> g = h << 2
>>> g
56
>>> bin(g)
'0b111000'
```

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

```py  
>>> g1 = h >> 1
>>> g1
7
>>> bin(g1)
'0b111'  
>>> g2 = h >> 2
>>> g2
3
>>> bin(g2)
'0b11'
```

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

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

```py
>>> ~93
-94
>>> bin(~93)
'-0b1011110'
>>> bin(93&102)
'0b1000100'
>>> bin(93|102)
'0b1111111'
>>> bin(93^102)
'0b111011' 
>>> 93 >> 3
11
>>> bin(93 >> 3)
'0b1011'
>>> 102 << 2
408
>>> bin (102 << 2)
'0b110011000'
```

## Пункт 6

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

## Пункт 6.1

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

```py
>>> 'Система '+'регулирования'
'Система регулирования'
>>> ['abc','de','fg']+['hi','jkl']
['abc', 'de', 'fg', 'hi', 'jkl']
>>> ('abc','de','fg')+('hi','jkl')
('abc', 'de', 'fg', 'hi', 'jkl')
```

!! Конкатенировать словари и множества нельзя.
Словари нельзя конкатенировать напрямую с помощью +, потому что ключи должны быть
уникальными, и если у двух складываемых словарей будет одинаковая пара ключей, будет
конфликтная ситуация.
Множества нельзя складывать потому, что они не итерируются так, как итерируются другие
коллекции, например, списки или кортежи. Конкатенация подразумевает добавление в конец,
но у множеств нет конца в таком же понимании, как, например, у списков.

```py
>>> {'one':1 , 'two':2} + {'three':3}
Traceback (most recent call last):
  File "<pyshell#90>", line 1, in <module>
    {'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 <module>
    {1, 2} + {1, 3, 3, 4}
TypeError: unsupported operand type(s) for +: 'set' and 'set'
```

## Пункт 6.2

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

```py
>>> 'ля-'*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)

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

## Пункт 6.4

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

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

```py
>>> 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 <module>
    stroka % (16, "меньше")
TypeError: not enough arguments for format string
>>> stroka % (16,' меньше ',25,15)
Traceback (most recent call last):
  File "<pyshell#118>", line 1, in <module>
    stroka % (16,' меньше ',25,15)
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)

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

## Пункт 7

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

## Пункт 7.1

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

```py
>>> zz = -12
>>> zz
-12
```

## Пункт 7.2

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

```py
>>> zz += 5
>>> zz
-7
>>> zz -= 3
>>> zz
-10
>>> stroka = 'Система'
>>> stroka += ' регулирования'
>>> stroka
'Система регулирования'
```

## Пункт 7.3

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

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

```py
>>> zz //= 4
>>> zz
-7.0
>>> zz %= -0.45
>>> zz
-0.24999999999999983
```

## Пункт 7.5

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

```py
>>> w = v = 10
>>> w
10
>>> v
10
>>> 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)
>>> 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

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

```py
>>> w == v
True
>>> w != v
False
>>> w < v
False
>>> w > v
False
>>> w <= v
True
>>> w >= v
True
>>> 0 == False
True
>>> 1 == True
True
>>> 0 == None
False
>>> None == None
True
>>> 5 != 5.0000
False
>>> inf = float ("Infinity")
>>> inf1 = float("-inf")
>>> inf > -inf
True
>>> inf2 = float ("Infinity")
>>> inf == inf2
True
>>> [1, 2, 3] == (1, 2, 3)
False
>>> "9" == 9
False
>>> None > 0
Traceback (most recent call last):
  File "<pyshell#198>", line 1, in <module>
    None > 0
TypeError: '>' not supported between instances of 'NoneType' and 'int'
>>> '100' < 100
Traceback (most recent call last):
  File "<pyshell#200>", line 1, in <module>
    '100' < 100
TypeError: '<' not supported between instances of 'str' and 'int'
```

## Пункт 8.2

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

```py
>>> 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
>>> a = [1, 2, 3]
>>> b = a
>>> b
[1, 2, 3]
>>> a == b
True
>>> a in b
False
```

## Пункт 8.3

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

```py
>>> 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 для разных объектов неизменяемого типа с одним значением

```py
>>> v = w = 10
>>> w is v
True
>>> w1 = ['A', 'B']
>>> v1 = ['A', 'B']
>>> w1 is v1
False
>>> w1 == v1
True
```

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

```py
>>> id(w)
2290989558352
>>> id(v)
2290989558352
>>> id(w1)
2291031104768
>>> id(v1)
2291031109824
>>> a = 15
>>> b = 15
>>> a is b
True
>>> id(a)
2290989558512
>>> id(b)
2290989558512
```

Это связано с тем, что python - очень высокоуровневый язык, возможности в плане оперирования
памятью сведены к минимуму, и иногда использование памяти оптимизировано. Например, числа
от -5 до 256 python подвергает интернированию, т.е. делает так, чтобы они ссылались на
один участок памяти (конкретно в cpython). Но с числами, не попадающими в этот диапазон, это
не работает.

```py
>>> aaa = 567
>>> bbb = 567
>>> aaa is bbb
False
>>> a = b = 567
>>> a is b
True
>>> aa = ()
>>> bb = ()
>>> aa is bb
True
```

## Пункт 9

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

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

Методы строк

```py
>>> stroka.find('пр')
5
>>> stroka.count("с")
4
>>> stroka.replace(' у',' автоматического у')
'Микропроцессорная система автоматического управления'
>>> spis22=stroka.split(' ')
>>> spis22
['Микропроцессорная', 'система', 'управления']
>>> stroka.upper()
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
>>> stroka.lower()
'микропроцессорная система управления'
>>> stroka3=" ".join(spis22)
>>> stroka3
'Микропроцессорная система управления'
>>> 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

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

```py
>>> spsk = [12, "kitten", (1, 2), "a", 56.78]
>>> dir(spsk)
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> spsk.pop(2)
(1, 2)
>>> spsk
[12, 'kitten', 'a', 56.78]
>>> spsk.append('c')
>>> spsk
[12, 'kitten', 'a', 56.78, 'c']
>>> spsk.insert(2,'a')
>>> spsk
[12, 'kitten', 'a', 'a', 56.78, 'c']
>>> spsk.count('a')
2
```

## Пункт 9.3

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

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

```py
>>> cor = (11, "oopsie", "doopsie", 64.9, 5+7j)
>>> dir(cor)
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
>>> cor.count(11)
1
>>> cor.index(64.9)
3
>>> cor.index("nothing")
Traceback (most recent call last):
  File "<pyshell#316>", line 1, in <module>
    cor.index("nothing")
ValueError: tuple.index(x): x not in tuple
```

## Пункт 9.4

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

```py
>>> newdi = di.copy()
>>> newdi
{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False}
>>> dir(newdi)
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>> di.get("key2")
'val2'
>>> 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, и они - объекты-итераторы. Они
    ссылаются на адреса ключей или значений в памяти, но не хранят значения. Также эти объекты
    автоматически обновляются при обновлении словаря. Например, добавим в словарь пару:
    
```py
>>> di["key6"] = 546
>>> di
{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False, 'key6': 546}
>>> dikeys = di.keys()
>>> dikeys
dict_keys(['key1', 'key2', 'key3', 'key4', 'key5', 'key6'])
>>> di.popitem()
('key6', 546)
>>> di
{'key1': 1, 'key2': 'val2', 'key3': 34.6, 'key4': 'f', 'key5': False}
>>> 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}
```

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

```py
>>> se = {1, "val2", 34.6, "f", False, 546}
>>> dir(se)
['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
>>> 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'}
>>> 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 <module>
    se.remove(90000)
KeyError: 90000
>>> 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, (5+6j), 'val2', 'kekeke'}
```