From 41636e9ca98f6bbd7cc8adc9d2e74cb92d775862 Mon Sep 17 00:00:00 2001 From: TimoshenkoAA Date: Mon, 22 Sep 2025 13:26:53 +0000 Subject: [PATCH] =?UTF-8?q?=D0=BE=D1=82=D1=87=D0=B5=D1=82=20=D0=BF=D0=BE?= =?UTF-8?q?=20=D0=9B=D0=A03?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA3/report3.md | 1223 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1223 insertions(+) create mode 100644 TEMA3/report3.md diff --git a/TEMA3/report3.md b/TEMA3/report3.md new file mode 100644 index 0000000..86f4a17 --- /dev/null +++ b/TEMA3/report3.md @@ -0,0 +1,1223 @@ +# Тема 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 "", line 1, in + 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 "", line 1, in + 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) + +``` +### Пункт 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) + +>>> comp2 = (6 - 4j) +>>> type(comp2) + +``` +Сложение +``` +>>> comp1 + comp2 +(9-2j) +``` +Вычитание +``` +>>> comp1 - comp2 +(-3+6j) +``` +Умножение +``` +>>> comp1 * comp2 +(26+0j) +>>> type(comp1 * comp2) + +``` +Деление +``` +>>> comp1 / comp2 +(0.19230769230769232+0.46153846153846156j) +``` +Целочисленное деление +``` +>>> comp1 // comp2 +Traceback (most recent call last): + File "", line 1, in + comp1 // comp2 +TypeError: can't take floor of complex number. + +>>> comp1 // 6 +Traceback (most recent call last): + File "", line 1, in + comp1 // 6 +TypeError: can't take floor of complex number. +``` +Взятие остатка от деления +``` +>>> comp1 % comp2 +Traceback (most recent call last): + File "", line 1, in + comp1 % comp2 +TypeError: can't mod complex numbers. + +>>> comp1 % 6 +Traceback (most recent call last): + File "", line 1, in + 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 "", 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 "", 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 "", 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 "", 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) + +>>> zz /= 2 +>>> zz +-5.0 +>>> type(zz) + + +>>> 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) + +``` +Словарь +``` +>>> 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 "", 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()) + +``` +Возвращение объекта только из ключей +``` +>>> 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 "", 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'} +``` + + + + + + +