From 6d445a190a3dc829ae140fa233abf1312642344f Mon Sep 17 00:00:00 2001 From: TimoshenkoAA Date: Mon, 22 Sep 2025 13:27:38 +0000 Subject: [PATCH] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D0=B8=D0=BB(?= =?UTF-8?q?=D0=B0)=20=D0=BD=D0=B0=20'TEMA3/report3.md'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA3/report3.md | 2446 +++++++++++++++++++++++----------------------- 1 file changed, 1223 insertions(+), 1223 deletions(-) diff --git a/TEMA3/report3.md b/TEMA3/report3.md index 86f4a17..26be464 100644 --- a/TEMA3/report3.md +++ b/TEMA3/report3.md @@ -1,1223 +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'} -``` - - - - - - - +# Тема 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'} +``` + + + + + + +