# Отчет по теме 3 ***Цель темы: изучение способов использования объектов разных типов.*** Терехов Фёдор Валерьевич, А-01-23 ## 1. Цель темы: изучение способов использования объектов разных типов. ### 1.1. Преобразование в логический тип с помощью функции bool(<Объект>). ```python logiz1=bool(56) print(f"{logiz1}\n") logiz2=bool(0) print(f"{logiz2}\n") logiz3=bool("Beta") print(f"{logiz3}\n") logiz4=bool("") print(f"{logiz4}\n") ``` Ответ программы: ```shell True False True False ``` ### 1.2. Преобразование в целое десятичное число объекта с заданной системой счисления. *Преобразование в целое десятичное число объекта с заданной системой счисления осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.* ```python tt1=int(198.6) #Отбрасывается дробная часть print(f"{tt1}\n") tt2=int("-76") #Число – в строке символов, система по умолчанию - десятичная print(f"{tt2}\n") tt3=int("B",16) print(f"{tt3}\n") tt4=int("71",8) print(f"{tt4}\n") tt5=int("98.76") print(f"{tt5}\n") ``` Ответ программы: ```shell 198 -76 11 57 Traceback (most recent call last): File "/home/user/Desktop/VUZ/3CURSE/POAS_labs/python-labs/TEMA3/task1.py", line 26, in tt5=int("98.76") ^^^^^^^^^^^^ ValueError: invalid literal for int() with base 10: '98.76' ``` *Объясните, почему при выполнении последней инструкции выдано диагностическое сообщение.* "98.76" - это строка. Функция int принимает либо строку с целым числом, либо число с точкой, но не строку с числом с точкой. Вариант решения - использовать функцию float(), которая преобразует строку в вещественное число, а затем функцию int() для преобразование в целое: ```python tt5=int(float("98.76")) print(f"{tt5}\n") ``` Ответ программы: ```shell 98 ``` *Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>).* ```python flt1=float(789) print(f"{flt1}\n") flt2=float(-6.78e2) print(f"{flt2}\n") flt3=float("Infinity") print(f"{flt3}\n") flt4=float("-inf") print(f"{flt4}\n") ``` Ответ программы: ```shell 789.0 -678.0 inf -inf ``` ### 1.3. Преобразование десятичных чисел в другие системы счисления. ```python hh=123 dv1=bin(hh) #Преобразование в строку с двоичным представлением print(f"{dv1}\n") vos1=oct(hh) # Преобразование в строку с восьмеричным представлением print(f"{vos1}\n") shs1=hex(hh) # Преобразование в строку с шестнадцатеричным представлением print(f"{shs1}\n") ``` Ответ программы: ```shell 0b1111011 0o173 0x7b ``` *Для проверки выполним обратные преобразования объектов dv1, vos1, shs1 по образцу int(dv1,2):* ```python print(f"{int(dv1, 2)}\n") print(f"{int(vos1, 8)}\n") print(f"{int(shs1, 16)}\n") ``` Ответ программы: ```shell 123 123 123 ``` ## 2. Преобразование более сложных базовых типов объектов. ### 2.1. Преобразование в строку символов с помощью функции str(<Объект>). ```python strk1=str(23.6) print(f"{strk1}\n") strk2=str(logiz3) print(f"{strk2}\n") strk3=str(["A","B","C"]) #Преобразуем список print(f"{strk3}\n") strk4=str(("A","B","C")) #Преобразуем кортеж print(f"{strk4}\n") strk5=str({"A":1,"B":2,"C":9}) #Преобразуем словарь print(f"{strk5}\n") ``` Ответ программы: ```shell 23.6 True ['A', 'B', 'C'] ('A', 'B', 'C') {'A': 1, 'B': 2, 'C': 9} ``` ### 2.2. Преобразование элементов объекта в список с помощью функции list(<Объект>). ```python spis1=list("Строка символов") #Заданная строка разделяется на символы print(f"{spis1}\n") spis2=list((124,236,-15,908)) #Кортеж превращается в список print(f"{spis2}\n") spis3=list({"A":1,"B":2,"C":9}) #Преобразование словаря в список print(f"{spis3}\n") ``` Ответ программы: ```shell ['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'] [124, 236, -15, 908] ['A', 'B', 'C'] ``` *Обратите внимание на то, что из словаря попало в созданный список. Придумайте инструкцию, обеспечивающую создание из того же словаря списка с другими его частями.* list(словарь) берёт только ключи словаря. **.items()** — это метод словаря, который даёт представление (view) пар (ключ, значение). Возвращает не список, а объект-«вид» (dict_items). Он живой: если словарь меняется, меняется и этот вид. ```python spis3=list({"A":1,"B":2,"C":9}.items()) #Преобразование словаря в список print(f"{spis3}\n") ``` Ответ программы: ```shell [('A', 1), ('B', 2), ('C', 9)] ``` ### 2.3. Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>). ```python kort7=tuple('Строка символов') #Преобразование строки символов в кортеж8 print(f"{kort7}\n") kort8=tuple(spis2) #Преобразование списка в кортеж print(f"{kort8}\n") kort9=tuple({"A":1,"B":2,"C":9}) #Преобразование словаря в кортеж print(f"{kort9}\n") ``` Ответ программы: ```shell ('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в') (124, 236, -15, 908) ('A', 'B', 'C') ``` ### 2.4. Удаление объектов. *Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del.* ```python print(f"Объекты в пространстве до удаления:\n{dir()}\n") del strk5, kort8 print(f"Объекты в пространстве после удаления:\n{dir()}\n") ``` Ответ программы: ```shell Объекты в пространстве до удаления: ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'kort7', 'kort8', 'kort9', 'logiz3', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'strk5'] Объекты в пространстве после удаления: ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'kort7', 'kort9', 'logiz3', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4'] ``` ### Задание. *Создайте строку со своей фамилией и инициалами, преобразуйте её в список, затем список – в кортеж и, наконец, кортеж – в строку.* ```python name="TerekhovFV" print(f"{name}\n{type(name)}\n") list_name=list(name) print(f"{list_name}\n{type(list_name)}\n") tuple_name=tuple(list_name) print(f"{tuple_name}\n{type(tuple_name)}\n") string_name=str(tuple_name) print(f"{string_name}\n{type(string_name)}\n") ``` Ответ программы: ```shell TerekhovFV ['T', 'e', 'r', 'e', 'k', 'h', 'o', 'v', 'F', 'V'] ('T', 'e', 'r', 'e', 'k', 'h', 'o', 'v', 'F', 'V') ('T', 'e', 'r', 'e', 'k', 'h', 'o', 'v', 'F', 'V') ``` ## 3. Арифметические операции. ### 3.1. Сложение и вычитание (+ и -). ```python print(12+7+90) # Сложение целых чисел print(5.689e-1 - 0.456) #Вычитание вещественных чисел print(23.6+54) #Сложение вещественного и целого чисел print(14-56.7+89) # Сложение и вычитание целых и вещественных чисел ``` Ответ программы: ```shell 109 0.11289999999999994 77.6 46.3 ``` ### 3.2. Умножение (*). ```python print(-6.7*12) #Умножение вещественного числа на целое число ``` Ответ программы: ```shell -80.4 ``` ### 3.3. Деление (/). ```python print(-234.5/6) #Деление вещественного числа на целое a=178/45 #Деление двух целых чисел print(f"a={a}\n{type(a)}\n") ``` Ответ программы: ```shell -39.083333333333336 a=3.9555555555555557 ``` ### 3.4. Деление с округлением вниз (//). *Здесь результат может быть целым или вещественным.* ```python b=178//45 #Деление двух целых чисел print(f"b={b}\n{type(b)}\n") c=-24.6//12.1 #Деление двух вещественных чисел print(f"c={c}\n{type(c)}\n") ``` Ответ программы: ```shell b=3 c=-3.0 ``` *Самостоятельно попробуйте смешанные комбинации типов чисел в этой операции.* ```python b=b//c print(f"b={b}\n{type(b)}\n") c=c//int(b) print(f"c={c}\n{type(c)}\n") ``` Ответ программы: ```shell b=-1.0 c=3.0 ``` **Значит если хотя бы одно из чисел вещественное, то ответ будет вещественным.** ### 3.5. Получение остатка от деления (%). ```python print(148%33) #Остаток от деления двух целых чисел print(12.6%3.8) #Остаток от деления двух вещественных чисел ``` Ответ программы: ```shell 16 1.2000000000000002 ``` *Самостоятельно попробуйте смешанные комбинации типов чисел в этой операции.* ```python print(1%0.3) print(3.0%1) ``` Ответ программы: ```shell 0.10000000000000003 0.0 ``` **Значит если хотя бы одно из чисел вещественное, то ответ будет вещественным.** ### 3.6. Возведение в степень (**). ```python print(14**3) #Целое число возводится в целую степень e=2.7**3.6 #Вещественное число возводится в вещественную степень print(e) ``` Ответ программы: ```shell 2744 35.719843790663525 ``` *Самостоятельно попробуйте смешанные комбинации типов чисел в этой операции.* ```python print(4**2.5) print(4.0**2) ``` Ответ программы: ```shell 32.0 16.0 ``` **Значит если хотя бы одно из чисел вещественное, то ответ будет вещественным.** ### Задание. *Попробуйте операции с участием комплексных чисел. Какие из приведенных выше операций можно применять к комплексным числам, а какие – нет?* * ***Классические сложение, вычитание, умножение, деление:*** ```python print((5-9j)+(2+5j)) print((5-9j)-(2+5j)) print((5-9j)*(2+5j)) print((5-9j)/(2+5j)) ``` Ответ программы: ```shell (7-4j) (3-14j) (55+7j) (-1.206896551724138-1.4827586206896552j) ``` * ***Остаток от деления:*** ```python print((5-9j)%(2+5j)) ``` Ответ программы: ```shell Traceback (most recent call last): File "/home/user/Desktop/VUZ/3CURSE/POAS_labs/python-labs/TEMA3/task3.py", line 46, in print((5-9j)%(2+5j)) ~~~~~~^^~~~~~ TypeError: unsupported operand type(s) for %: 'complex' and 'complex' ``` **Нельзя получить остаток от деления компексных чисел.** * ***Деление с округлением в меньшую сторону:*** ```python print((5-9j)//(2+5j)) ``` Ответ программы: ```shell Traceback (most recent call last): File "/home/user/Desktop/VUZ/3CURSE/POAS_labs/python-labs/TEMA3/task3.py", line 47, in print((5-9j)//(2+5j)) ~~~~~~^^~~~~~~ TypeError: unsupported operand type(s) for //: 'complex' and 'complex' ``` * ***Возведение в степень:*** ```python print((5-9j)**(2+5j)) ``` Ответ программы: ```shell (-21509.595911266613-2297.8216985074932j) ``` **Можно комплексное число возвести в комплексную степень.** ***Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее наиболее сложный тип из тех типов, которые участвуют в операции.*** ## 4. Операции с двоичными представлениями целых чисел. ### 4.1. Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0). ```python dv1=9 dv2=~dv1 print(bin(dv1)) print(bin(dv2)) ``` Ответ программы: ```shell 0b1001 -0b1010 ``` ### 4.2. Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел. ```python print(bin(7&9)) # 111 и 1001 = 0001 print(bin(7&8)) # 111 и 1000 = 0000 ``` Ответ программы: ```shell 0b1 0b0 ``` ### 4.3. Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0. ```python print(bin(7|9)) # 111 или 1001 = 1111 print(bin(7|8)) # 111 или 1000 = 1111 print(bin(14|5)) # 1110 или 0101 = 1111 ``` Ответ программы: ```shell 0b1111 0b1111 0b1111 ``` ### 4.4. Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1. ```python print(bin(14^5)) # 1110 исключающее или 0101 = 1011 print(f"В десятичном представлении: {14^5}") ``` Ответ программы: ```shell 0b1011 В десятичном представлении: 11 ``` ### 4.5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева. ```python h=14 #Двоичное представление = 1110 print(f"В десятичном представлении: {h}") print(f"В двоичном представлении: {bin(h)}\n") g=h<<2 # Новое двоичное представление = 111000 print(f"В десятичном представлении: {g}") print(f"В двоичном представлении: {bin(g)}\n") g1=h>>1 # Новое двоичное представление = 0111 print(f"В десятичном представлении: {g1}") print(f"В двоичном представлении: {bin(g1)}\n") g2=h>>2 # Новое двоичное представление = 0011 print(f"В десятичном представлении: {g2}") print(f"В двоичном представлении: {bin(g2)}\n") ``` Ответ программы: ```shell В десятичном представлении: 14 В двоичном представлении: 0b1110 В десятичном представлении: 56 В двоичном представлении: 0b111000 В десятичном представлении: 7 В двоичном представлении: 0b111 В десятичном представлении: 3 В двоичном представлении: 0b11 ``` ### Задание. *Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.* ```python a = 91 b = 101 print(f"В десятичном представлении a: {a}") print(f"В двоичном представлении a: {bin(a)}\n") print(f"В десятичном представлении: {b}") print(f"В двоичном представлении: {bin(b)}\n") print(f"В десятичном представлении a & b = {a&b}") print(f"В двоичном представлении a & b = {bin(a&b)}\n") print(f"В десятичном представлении a | b = {a|b}") print(f"В двоичном представлении a | b = {bin(a|b)}\n") print(f"В десятичном представлении a ^ b = {a^b}") print(f"В двоичном представлении a ^ b = {bin(a^b)}\n") print(f"В десятичном представлении ~a = {~a}") print(f"В двоичном представлении ~a = {bin(~a)}\n") print(f"В десятичном представлении ~a = {~b}") print(f"В двоичном представлении ~a = {bin(~b)}\n") print(f"В десятичном представлении a<<4 = {a<<4}") print(f"В двоичном представлении a<<4 = {bin(a<<4)}\n") print(f"В десятичном представлении b>>5 = {b>>5}") print(f"В двоичном представлении b>>5 = {bin(b>>5)}\n") ``` Ответ программы: ```shell В десятичном представлении a | b = 127 В двоичном представлении a | b = 0b1111111 В десятичном представлении a ^ b = 62 В двоичном представлении a ^ b = 0b111110 В десятичном представлении ~a = -92 В двоичном представлении ~a = -0b1011100 В десятичном представлении ~a = -102 В двоичном представлении ~a = -0b1100110 В десятичном представлении a<<4 = 1456 В двоичном представлении a<<4 = 0b10110110000 В десятичном представлении b>>5 = 3 В двоичном представлении b>>5 = 0b11 ``` ## 5. Операции при работе с последовательностями (строками, списками, кортежами). ### 5.1. Объединение последовательностей (конкатенация)(+). ``` python print('Система '+'регулирования') #Соединение двух строк символов print(['abc','de','fg']+['hi','jkl']) # Объединение двух списков print(('abc','de','fg')+('hi','jkl')) # Объединение двух кортежей ``` Ответ программы: ```shell Система регулирования ['abc', 'de', 'fg', 'hi', 'jkl'] ('abc', 'de', 'fg', 'hi', 'jkl') ``` ### 5.2. Повторение (*). ```python print('ля-'*5) #Повторение строки 5 раз print(['ку','-']*3) #Повторение списка 3 раза print(('кис','-')*4) #Повторение кортежа 4 раза ``` Ответ программы: ```shell ля-ля-ля-ля-ля- ['ку', '-', 'ку', '-', 'ку', '-'] ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-') ``` *Создание списка со 100 отсчетами сигнала-ступеньки:* ```python signal1=[0]*3+[1]*99 print(signal1) ``` Ответ программы: ```shell [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] ``` *Создание кортежа с отсчетами сигнала – импульса:* ```python signal2=(0,)*3+(1,)*5+(0,)*7 print(signal2) print("\n") ``` Ответ программы: ```shell (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0) ``` ### 5.3. Проверка наличия заданного элемента в последовательности (in). ```python stroka='Система автоматического управления' print('автомат' in stroka) #Наличие подстроки в строке print('ку' in ['ку','-']*3) #Наличие контекста в списке print('ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')) #Наличие контекста в кортеже ``` Ответ программы: ```shell True True False ``` ### 5.4. Подстановка значений в строку с помощью оператора «%». ***Пример №1*** ```python stroka='Температура = %g %s %g' print(stroka % (16,' меньше ',25)) ``` Ответ программы: ```shell Температура = 16 меньше 25 ``` ***Пример №2*** ```python stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' print(stroka % {'zn1':16,'sravn':' меньше ','zn2':25}) ``` Ответ программы: ```shell Температура = 16 меньше 25 ``` ## 6. Оператор присваивания. ### 6.1. Обычное присваивание значения переменной (=). ```python zz=-12 print(zz) ``` Ответ программы: ```shell -12 ``` ### 6.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=). ```python zz+=5 # Значение zz увеличивается на 5 print(zz) zz-=3 # Значение уменьшается на 3 print(zz) ``` Ответ программы: ```shell -7 -10 ``` *Для последовательностей операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.* ```python stroka='Система' stroka+=' регулирования' print(stroka) ``` Ответ программы: ```shell Система регулирования ``` ### 6.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=). ```python zz/=2 print(zz) zz*=5 print(zz) ``` Ответ программы: ```shell -5.0 -25.0 ``` _Для строк операция (*=) означает повторение текущего значения объекта заданное число раз._ ```python stroka*= 3 print(stroka) ``` Ответ программы: ```shell Система регулированияСистема регулированияСистема регулирования ``` ### 6.4. Деления с округлением вниз (//=). ```python zz//=2 print(zz) ``` Ответ программы: ```shell -13.0 ``` ### 6.5. Возведение в степень. ```python zz**=2 print(zz) ``` Ответ программы: ```shell 169.0 ``` ### 6.6. Получение остатка от деления (%=). ```python zz%=3 print(zz) ``` Ответ программы: ```shell 1.0 ``` ### Множественное присваивание. ```python w=v=10 # Переменным присваивается одно и то же значение print(w) print(v) n1,n2,n3=(11,-3,'all') #Значения переменных берутся из кортежа print(n1, n2, n3) ``` Ответ программы: ```shell 10 10 11 -3 all ``` ***Вместо кортежа нельзя использовать строку*** ```python n1,n2,n3="11,-3,'all'" print(n1, n2, n3) ``` Ответ программы: ```shell Traceback (most recent call last): File "/home/user/Desktop/VUZ/3CURSE/POAS_labs/python-labs/TEMA3/task6.py", line 40, in n1,n2,n3="11,-3,'all'" ^^^^^^^^ ValueError: too many values to unpack (expected 3) ``` ***Вместо кортежа можно использовать список*** ```python n1,n2,n3=[11,-3,'all'] print(n1, n2, n3) ``` Ответ программы: ```shell 11 -3 all ``` ***Вместо кортежа можно использовать множество*** ```python n1,n2,n3={11,-3,'all'} print(n1, n2, n3) ``` Ответ программы: ```shell 11 -3 all ``` ***Вместо кортежа можно использовать словарь*** ```python n1,n2,n3={'11':1,'-3':2,"all": 3} print(n1, n2, n3) ``` Ответ программы: ```shell 11 -3 all ``` ## 7. Логические операции – при создании логических выражений, дающих в результате вычисления значения True или False. ### 7.1. Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=). ```python w=v=10 print(w>=v) print(w==v) print(w<=v) print(w!=v) print(wv) ``` Ответ программы: ```shell True True True False False False ``` ### 7.2. Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in). * **Операции с множеством** ```python mnoz1={'pen','book','pen','iPhone','table','book'} print('book' in mnoz1) print('cap' in mnoz1) ``` Ответ программы: ```shell True False ``` * **Операции со словарём** ```python dic1={'Saratov':145, 'Orel':56, 'Vologda':45} print('Vologda' in dic1) print('Pskov' in dic1) print(56 in dic1.values()) ``` Ответ программы: ```shell True False True ``` *Ещё один пример работы со словарём* ```python dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']} print('UII' in dct1['Depart']) print(dct1['Depart'][1] == 'MM') ``` Ответ программы: ```shell True False ``` ### 7.3. Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). ```python a=17 b=-6 print((a>=b) and ('book' in mnoz1) and ('Pskov' not in dic1)) print((a % 2 == 1) and (b < 0) and (('Moscow' in dic1) or ('Pskov' not in dic1))) print(not (a <= b) and (('pen' in mnoz1) or ('book' not in mnoz1)) and ('Kazan' not in dic1)) print((len(mnoz1) >= 3) and (a + b > 0) or (('Pskov' in dic1) and (dic1['Pskov'] > 50))) ``` Ответ программы: ```shell True True True True ``` ### 7.4. Проверка ссылок переменных на один и тот же объект (is). ```python w=v=10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти print(w is v) w1=['A','B'] v1=['A','B'] print(w1 is v1) ``` Ответ программы: ```shell True False ``` ***is сравнивает тождество объектов, а не равенство значений. При w = v = 10 обе переменные указывают на один и тот же объект, а w1 = ['A','B'] и v1 = ['A','B'] создают две разные списочные коробки с одинаковым содержимым.*** ***Чтобы тождество объектов было верным необходимо, чтобы АДРЕС объектов был тот же. Адрес можно проверить с помощью функции id(). == спрашивает "содержимое одинаковое?", а is спрашивает "это один и тот же объект?".*** ## 8. Операции с объектами, выполняемые с помощью методов. ***Полный список всех атрибутов любого объекта можно получить с использованием функции dir.*** ```python stroka='Микропроцессорная система управления' print(dir(stroka)) ``` Ответ программы: ```shell ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__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'] ``` ### 8.1. Методы для работы со строками. * *Методы find, count, replace, split, upper, join, partition, rpartition.* ```python stroka='Микропроцессорная система управления' print(stroka.find('пр')) #Возвращает номер позиции первого вхождения указанного контекста или значение -1 print(stroka.count("с")) #Подсчет числа вхождений строки “с” в stroka stroka.replace(' у',' автоматического у') print(stroka) spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит заданный разделитель print(spis22) print(stroka.upper()) #Возвращает строку со всеми заглавными буквами stroka3=" ".join(spis22) #Возвращает строку, собранную из элементов списка print(stroka3) print(stroka3.partition("с")) #Возвращает кортеж с результатами поиска «с» слева print(stroka3.rpartition("с")) #Возвращает кортеж с результатами поиска «с» справа ``` Ответ программы: ```shell 5 4 Микропроцессорная система управления ['Микропроцессорная', 'система', 'управления'] МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ Микропроцессорная система управления ('Микропроце', 'с', 'сорная система управления') ('Микропроцессорная си', 'с', 'тема управления') ``` * *Метод format.* ```python strk1 = 'Момент времени {}, значение = {}' print(strk1.format(1, 89.7)) strk2='Момент времени {1}, значение = {0}:{2}' print(strk2.format(36.7,2,'норма!')) strk3='Момент времени {num}, значение = {znch}' print(strk3.format(znch=89.7,num=2)) ``` Ответ программы: ```shell нт времени 1, значение = 89.7 Момент времени 2, значение = 36.7:норма! Момент времени 2, значение = 89.7 ``` ### 8.2. Методы для работы со списками. * Метод pop(индекс) удаляет элемент по индексу. * Метод append(элемент) добавляет элемент в конец списка. * Метод insert(индекс, элемент) вставляет элемент в заданный индекс. Последующие индекс сдвигаются вправо. * Метод count(элемент) подсчитывает количество заданных элементов в списке. ```python spsk=['a','b','c','d','e','f'] print(spsk) spsk.pop(2) print(spsk) spsk.append('c') print(spsk) spsk.insert(2,'a') print(spsk) print(spsk.count('a')) ``` Ответ программы: ```shell ['a', 'b', 'c', 'd', 'e', 'f'] ['a', 'b', 'd', 'e', 'f'] ['a', 'b', 'd', 'e', 'f', 'c'] ['a', 'b', 'a', 'd', 'e', 'f', 'c'] 2 ``` ### 8.3. Методы для работы с кортежами. *У кортежа всего два собственных метода: count(элемент) и index(элемент).* ```python t = (10, 20, 20, 30, 40) print(t.count(20)) # сколько раз встречается 20 print(t.index(30)) # индекс первого вхождения 30 ``` Ответ программы: ```shell 2 3 ``` ### 8.4. Методы для работы со словарями. * keys() - отображает ключи * values() - отображает значения * items() - отображает пары ключей и значений * get(k, default=None) - безопасное чтение - вернуть d[k], а если ключа нет — default, без ошибки. * d[k] = v - присвоение значения по ключу (добавит или перезапишет) * d.setdefault(k, default=None) – вернуть d[k], а если ключа нет — создать его со значением default и вернуть. * d.pop(k[, default]) - удалить ключ и вернуть значение; если нет и default не задан — ошибка. * d.popitem() - удалить последнюю добавленную пару (LIFO) и вернуть её кортежем. * d.clear() – очистить словарь. ```python d = {'A': 1, 'B': 2, 'C': 3} print("start:", d) print(d.keys()) print(d.values()) print(d.items(),'\n') print(d.get('B', 0)) print(d.get('Z', 0),'\n') d['D'] = 4 d['A'] = 10 print(d,'\n') print(d.setdefault('E', 5)) print(d.setdefault('A', 999),'\n') print(d,'\n') val = d.pop('B') print(val, d) print(d.pop('Z', 'нет'),'\n') last_key, last_val = d.popitem() print((last_key, last_val)) print(d,'\n') d.clear() print(d) ``` Ответ программы: ```shell start: {'A': 1, 'B': 2, 'C': 3} dict_keys(['A', 'B', 'C']) dict_values([1, 2, 3]) dict_items([('A', 1), ('B', 2), ('C', 3)]) 2 0 {'A': 10, 'B': 2, 'C': 3, 'D': 4} 5 10 {'A': 10, 'B': 2, 'C': 3, 'D': 4, 'E': 5} 2 {'A': 10, 'C': 3, 'D': 4, 'E': 5} нет ('E', 5) {'A': 10, 'C': 3, 'D': 4} {} ``` ### 8.5. Методы для работы с множествами. * s = set([1, 2, 2, 3]) - создаёт множество без повторяющихся элементов. * empty = set() - пустое множество. * s.add(4) - добавляет элемент в множество. * s.update([5,6]) - добавляет несколько элементов. * s.remove(2) - удаляет элемент множества, если нет - KeyError. * s.discard(99) - удаляет элемент, если нет — тихо. * x = s.pop() - удаляет элемент множества. * s.clear() - очищает множество. * a.issubset(b) - множество a принадлежит множеству b. * a.issuperset(b) - множество b ринадлежит множеству a. * t = a.copy() - копирует множество. * fs = frozenset({1,2,3}) - неизменяемое множество. ```python s = set([1, 2, 2, 3]) print("s:", s) empty = set() print("empty:", empty) s.add(4) print("add(4):", s) s.update([5, 6]) print("update([5,6]):", s) s.remove(2) print("remove(2):", s) s.discard(99) print("discard(99):", s) x = s.pop() print("pop() ->", x, "; s:", s) s.clear() print("clear():", s) a = {1, 2} b = {1, 2, 3} print("a:", a, "b:", b) print("a.issubset(b):", a.issubset(b)) print("a.issuperset(b):", a.issuperset(b)) print("b.issuperset(a):", b.issuperset(a)) a2 = a.copy() print("copy() a2:", a2) fs = frozenset({1, 2, 3}) print("frozenset fs:", fs, type(fs)) ``` Ответ программы: ```shell s: {1, 2, 3} empty: set() add(4): {1, 2, 3, 4} update([5,6]): {1, 2, 3, 4, 5, 6} remove(2): {1, 3, 4, 5, 6} discard(99): {1, 3, 4, 5, 6} pop() -> 1 ; s: {3, 4, 5, 6} clear(): set() a: {1, 2} b: {1, 2, 3} a.issubset(b): True a.issuperset(b): False b.issuperset(a): True copy() a2: {1, 2} frozenset fs: frozenset({1, 2, 3}) ```