From 399720b4718c23c3d5b7a242fc7d8d14f7573256 Mon Sep 17 00:00:00 2001 From: PokhilAA Date: Sat, 27 Sep 2025 15:15:07 +0300 Subject: [PATCH] =?UTF-8?q?=D0=BE=D1=82=D1=87=D0=B5=D1=82=20+=20=D0=BE?= =?UTF-8?q?=D0=BA=D0=B7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA3/report.md | 695 ++++++++++++++++++++++++++++++++++++++++++++++++ TEMA3/task.md | 55 ++++ 2 files changed, 750 insertions(+) create mode 100644 TEMA3/report.md create mode 100644 TEMA3/task.md diff --git a/TEMA3/report.md b/TEMA3/report.md new file mode 100644 index 0000000..591e491 --- /dev/null +++ b/TEMA3/report.md @@ -0,0 +1,695 @@ +# Отчет по теме 3 + +Похил Анастасия, А-02-23 + +### 1. Настройка текущего каталога. +```py +import os +os.chdir('C://Users//Настя//Desktop//python-labs//TEMA3//') +``` +### 2. Преобразование простых базовых типов объектов. + +#### 2.1. Преобразование в логический тип с помощью функции bool(<Объект>) + +```py +logiz1 = bool(56) +logiz2 = bool(0) +logiz3 = bool("Beta") +logiz4 = bool("") +logiz1 +True +logiz2 +False +logiz3 +True +logiz4 +False +type(logiz1) + +``` + +#### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления +- Примеры использования функции int: + +```py +tt1 = int(198.6) +tt1 +198 +tt2 = int("-76") +tt2 +-76 +tt3 = int("B",16) +tt3 +11 +tt4 = int("71",8) +tt4 +57 +tt5 = int("98.76") +Traceback (most recent call last): + File "", line 1, in + tt5=int("98.76") +ValueError: invalid literal for int() with base 10: '98.76' +``` +- Преобразование целых чисел или строк символов в вещественное число + +```py +flt1 = float(789) +flt1 +789.0 +flt2 = float(-6.78e2) +flt2 +-678.0 +flt3 = float("Infinity") +flt3 +inf +flt4 = float("-inf") +flt4 +-inf +``` + +#### 2.3. Преобразование десятичных чисел в другие системы счисления: + +```py +hh = 123 +dv1 = bin(hh) #Преобразование в строку с двоичным представлением +vos1 = oct(hh) # Преобразование в строку с восьмеричным представлением +shs1 = hex(hh) # Преобразование в строку с шестнадцатеричным представлением +dv1 +'0b1111011' +vos1 +'0o173' +shs1 +'0x7b' +int(dv1,2) +123 +int(vos1, 8) +123 +int(shs1, 16) +123 +``` + +### 3. Преобразования более сложных базовых типов объектов. + +#### 3.1. Преобразование в строку символов + + +```py +strk1 = str(23.6) +strk1 +'23.6' +strk2 = str(logiz3) +strk2 +'True' +strk3 = str(["A","B","C"]) #Преобразуем список +strk3 +"['A', 'B', 'C']" +strk4 = str(("A","B","C")) #Преобразуем кортеж +strk4 +"('A', 'B', 'C')" +strk5 = str({"A":1,"B":2,"C":9}) #Преобразуем словарь +strk5 +"{'A': 1, 'B': 2, 'C': 9}" +``` + +#### 3.2. Преобразование элементов объекта в список + +```py +spis1 = list("Строка символов") #Заданная строка разделяется на символы +spis1 +['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'] +spis2 = list((124,236,-15,908)) #Кортеж превращается в список +spis2 +[124, 236, -15, 908] +spis3 = list({"A":1,"B":2,"C":9}) #Преобразование словаря в список +spis3 +['A', 'B', 'C'] +``` +- Методы .values(), .items() + +```py +spis3 = list({"A":1,"B":2,"C":9}.values()) +spis3 +[1, 2, 9] +spis3 = list({"A":1,"B":2,"C":9}.items()) +spis3 +[('A', 1), ('B', 2), ('C', 9)] +``` +#### 3.3. Преобразование элементов объектов в кортеж + +```py +kort7 = tuple('Строка символов') #Преобразование строки символов в кортеж +kort7 +('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в') +kort8 = tuple(spis2) #Преобразование списка в кортеж +kort8 +(124, 236, -15, 908) +kort9 = tuple({"A":1,"B":2,"C":9}) #Преобразование словаря в кортеж +kort9 +('A', 'B', 'C') +``` + +#### 3.4. Удаление обьектов + +```py +del strk5, kort8 +strk5 +Traceback (most recent call last): + File "", line 1, in + strk5 +NameError: name 'strk5' is not defined. Did you mean: 'strk1'? +kort8 +Traceback (most recent call last): + File "", line 1, in + kort8 +NameError: name 'kort8' is not defined. Did you mean: 'kort7'? +str_A = "Похил А.А" +spis_A = list(str_A) +spis_A +['П', 'о', 'х', 'и', 'л', ' ', 'А', '.', 'А'] +kort_A = tuple(spis_A) +kort_A +('П', 'о', 'х', 'и', 'л', ' ', 'А', '.', 'А') +str_AA = str(kort_A) +str_AA +"('П', 'о', 'х', 'и', 'л', ' ', 'А', '.', 'А')" +``` + +### 4. Арифметические операции. + +#### 4.1. Сложение и вычитание + +```py +12+7+90 # Сложение целых чисел +109 +5.689e-1 - 0.456 #Вычитание вещественных чисел +0.11289999999999994 +23.6+54 #Сложение вещественного и целого чисел +77.6 +14-56.7+89 #Сложение и вычитание целых и вещественных чисел +46.3 +``` + +#### 4.2. Умножение + +```py +>-6.7*12 #Умножение вещественного числа на целое число +-80.4 +``` + +#### 4.3. Деление + +```py +-234.5/6 #Деление вещественного числа на целое +-39.083333333333336 +a = 178/45 #Деление двух целых чисел +a +3.9555555555555557 +type(a) + +``` + +#### 4.4. Деление с округлением вниз + +```py +b = 178//45 #Деление двух целых чисел +b +3 +type(b) + +c = -24.6//12.1 #Деление двух вещественных чисел +c +-3.0 +type(c) + +d = 23.65//12 +d +1.0 +type(d) + +d = 12//52.43 +d +0.0 +type(d) + +d = 6//2 +d +3 +type(d) + + +``` + +#### 4.5. Получение остатка от деление + +```py +148%33 #Остаток от деления двух целых чисел +16 +12.6%3.8 #Остаток от деления двух вещественных чисел +1.2000000000000002 +256%2.5 +1.0 +34.2%4 +2.200000000000003 +``` + +#### 4.6. Возведение в степень + +```py +14**3 #Целое число возводится в целую степень +2744 +e = 2.7**3.6 #Вещественное число возводится в вещественную степень +e +35.719843790663525 +52**1.2 +114.60511792303392 +0.3**11 +1.7714699999999993e-06 +``` + +#### 4.7. Операции с комплексными числами + +```py +z1 = 3 + 2j +z2 = 6 - 4j +z1 + z2 +(9-2j) +z1 * z2 +(26+0j) +z1 / z2 +(0.19230769230769232+0.46153846153846156j) +z1 // z2 +Traceback (most recent call last): + File "", line 1, in + z1 // z2 +TypeError: unsupported operand type(s) for //: 'complex' and 'complex' +z1 % z2 +Traceback (most recent call last): + File "", line 1, in + z1 % z2 +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' +z1**z2 +(-717.4651414273118-23072.00404010235j) +``` + +### 5. Операции с двоичными представлениями целых чисел. + +#### 5.1. Двоичная инверсия + +```py +dv1 = 9 +dv2 = ~dv1 +dv2 +-10 +``` + +#### 5.2. Двоичное "И" + +```py +7 & 9 # 111 и 1001 = 0001 +1 +7 & 8 # 111 и 1000 = 0000 +0 +``` + +#### 5.3. Двоичное "ИЛИ" + +```py +7 | 9 # 111 или 1001 = 1111 +15 +7 | 8 # 111 или 1000 = 1111 +15 +14 | 5 # 1110 или 0101 = 1111 +15 +``` + +#### 5.4. Двоичное «исключающее ИЛИ» + +```py +14 ^ 5 # 1110 исключающее или 0101 = 1011 +11 +``` + +Число 11 получилось при переводе 1011 из двоичной системы в десятичную. + +#### 5.5. Сдвиг двоичного представления на заданное число разрядов влево или вправо с дополнением нулями + +```py +h = 14 #Двоичное представление = 1110 +g = h<<2 # Новое двоичное представление = 111000 +g +56 +g1 = h>>1 # Новое двоичное представление = 0111 +g1 +7 +g2 = h>>2 # Новое двоичное представление = 0011 +g2 +3 +h0 = 127 +bin(h0) +'0b1111111' +g0 = h0<<1 +g0 +254 +bin(g0) +'0b11111110' +g0 = h0>>3 +g0 +15 +bin(g0) +'0b1111' +``` +Создание двух двоичных чисел с 7-ю знаками и выполнение операций над ними: + + +```py +b1 = int("1010101",2) +b2 = int("1111001",2) +b_2 = ~b2 +b_2 +-122 +b1 & b2 +81 +b1 | b2 +125 +b1^b2 +44 +b1 >> 1 +42 +b2 << 3 +968 +b1 +85 +b2 +121 +``` + +### 6. Операции при работе с последовательностями (строками, списками, кортежами). + +#### 6.1. Объединение последовательностей (конкатенация)(+) + +```py +'Система '+'регулирования' #Соединение двух строк символов +'Система регулирования' +['abc','de','fg']+['hi','jkl'] # Объединение двух списков +['abc', 'de', 'fg', 'hi', 'jkl'] +('abc','de','fg')+('hi','jkl') # Объединение двух кортежей +('abc', 'de', 'fg', 'hi', 'jkl') +``` + +#### 6.2. Повторение(*) + +```py +'ля-'*5 #Повторение строки 5 раз +'ля-ля-ля-ля-ля-' +['ку','-']*3 #Повторение списка 3 раза +['ку', '-', 'ку', '-', 'ку', '-'] +('кис','-')*4 #Повторение кортежа 4 раза +('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-') +signal1 = [0]*3 + [1]*99 +signal2 = (0,)*3 + (1,)*5 + (0,)*7 +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, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0) +``` + +#### 6.3. Проверка наличия заданного элемента в последовательности (in) + +```py +stroka = 'Система автоматического управления' +'автомат' in stroka #Наличие подстроки в строке +True +'ку' in ['ку','-']*3 #Наличие контекста в списке +True +'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') #Наличие контекста в кортеже +False +``` + +#### 6.4.Подстановка значений в строку с помощью оператора «%» + +```py +stroka = 'Температура = %g %s %g' +stroka % (16,' меньше ',25) +'Температура = 16 меньше 25' +stroka = 'Температура = %(zn1)g %(sravn)s %(zn2)g' +stroka % {'zn1':16,'sravn':' меньше ','zn2':25} +'Температура = 16 меньше 25' +``` + +### 7. Оператор присваивания + +#### 7.1. Обычное присваивание значения переменной (=) + + +```py +zz = -12 +zz +-12 +``` + +#### 7.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=) + +```py +zz += 5 # Значение zz увеличивается на 5 +zz -= 3 # Значение уменьшается на 3 +zz +-10 +stroka='Система' +stroka+=' регулирования' +stroka +'Система регулирования' +``` + +#### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=) + +```py +zz /= 2 +zz +-5.0 +zz *= 5 +zz +-25.0 +stroka='Система регулирования' +stroka *= 2 +stroka +'Система регулированияСистема регулирования' +``` + +#### 7.4.Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) + +```py +zz //= 3 +zz +-9.0 +zz %= 2 +zz +1.0 +zz **= 3 +zz +1.0 +``` + +##### 7.5. Множественное присваивание + +```py +w = v = 10 # Переменным присваивается одно и то же значение +w +10 +v +10 +n1,n2,n3 = (11,-3,'all') #Значения переменных берутся из кортежа +n1;n2;n3 +11 +-3 +'all' +n1,n2,n3 = "11", "-3", "all" +n1;n2;n3 +'11' +'-3' +'all' +n1,n2,n3 = [11,-3,'all'] +n1;n2;n3 +11 +-3 +'all' +n1,n2,n3 = {11: 1,-3:2,'all':3} +n1;n2;n3 +11 +-3 +'all' +``` + +### 8. Логические операции. + +#### 8.1. Операции сравнения + +```py +w = v = 10 +w == v +True +w != v +False +w < v +False +w > v +False +w >= v +True +w <= v +True +``` + +#### 8.2. Проверка наличия заданного элемента в последовательности или в множестве + +```py +mnoz1 = {'pen','book','pen','iPhone','table','book'} +'book' in mnoz1 +True +'cap' in mnoz1 +False +dic1 = {'Saratov':145, 'Orel':56, 'Vologda':45} +'Vologda' in dic1 +True +'Pskov' in dic1 +False +56 in dic1.values() +True +dct1 = {'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']} +'UII' in dct1['Depart'] +True +dct1['Depart'][1] == 'MM' +False +``` + +#### 8.3. Логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not) + +```py +a = 17 +b = -6 +(a >= b) and ('book' in mnoz1) and not ('Pskov' in dic1) +True +(5 > 6) and ('kazan' in dic1) and not ('lozhka' in mnoz1) +False +(5 > 6) and (7 > 5) or ("Saratov" in dic1) +True +``` + +#### 8.4. Проверка ссылок переменных на один и тот же объект (is) + +```py +w = v = 10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти +w is v +True +w1 = ['A','B'] +v1 = ['A','B'] +w1 is v1 #При раздельном создании списков с одинаковыми элементами получаются разные объекты в памяти, поэтому is возвращает False.Оператор is проверяет идентичность объектов (ссылку на один объект), а не равенство содержимого +False +``` + +### 9. Операции с объектами, выполняемые с помощью методов. + +```py +stroka = 'Микропроцессорная система управления' +dir(stroka) +['__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'] +``` + +#### 9.1. Методы для работы со строками + +```py +stroka.find('пр') #Возвращает номер позиции первого вхождения указанного контекста или значение -1 +5 +stroka.count("с") #Подсчет числа вхождений строки “с” в stroka +4 +stroka.replace(' у',' автоматического у') +'Микропроцессорная система автоматического управления' +spis22 = stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит заданный разделитель +spis22 +['Микропроцессорная', 'система', 'управления'] +stroka.upper() #Возвращает строку со всеми заглавными буквами +'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ' +stroka3 = " ".join(spis22) #Возвращает строку, собранную из элементов списка +stroka3 +'Микропроцессорная система управления' +stroka3.partition("с") #Возвращает кортеж с результатами поиска «с» слева +('Микропроце', 'с', 'сорная система управления') +stroka3.rpartition("с") #Возвращает кортеж с результатами поиска «с» справа +('Микропроцессорная си', 'с', 'тема управления') +strk1 = 'Момент времени {}, значение = {}' +strk1.format(1,89.7) +'Момент времени 1, значение = 89.7' +strk2 = 'Момент времени {1}, значение = {0}:{2}' +strk2.format(36.7,2,'норма!') +'Момент времени 2, значение = 36.7:норма!' +strk3 = 'Момент времени {num}, значение = {znch}' +strk3.format(znch = 89.7,num = 2) +'Момент времени 2, значение = 89.7' +``` + +#### 9.2. Методы для работы со списками + +```py +spsk = [1, 'a', 2, 'd', 4] +dir(spsk) +['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] +spsk.pop(2) +2 +spsk +[1, 'a', 'd', 4] +spsk.append('c') +spsk +[1, 'a', 'd', 4, 'c'] +spsk.insert(2, 'a') +spsk +[1, 'a', 'a', 'd', 4, 'c'] +spsk.count('a') +2 +``` + +#### 9.3. Методы для работы с кортежами + +```py +t = (1, 2, 3, 2, 4) +dir(t) +['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] +t.count(2) +2 +t.index(3) +2 +len(t) +5 +t[1] +2 +``` + +#### 9.4. Методы для работы со словарями и множествами + +```py +#словарь +d = {'a': 1, 'b': 2, 'c': 3} +dir(d) +['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'] +d.keys() +dict_keys(['a', 'b', 'c']) +d.values() +dict_values([1, 2, 3]) +d.get('b') +2 +d.update({'d': 4}) +d +{'a': 1, 'b': 2, 'c': 3, 'd': 4} +#множество +s = {1, 2, 3, 2, 4} +dir(s) +['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update'] +s.add(5) +s +{1, 2, 3, 4, 5} +s.remove(2) +s +{1, 3, 4, 5} +s.intersection({1, 3}) #пересечение множеств +{1, 3} +``` + +### 10. Закончен сеанс работы с IDLE. \ No newline at end of file diff --git a/TEMA3/task.md b/TEMA3/task.md new file mode 100644 index 0000000..e63373e --- /dev/null +++ b/TEMA3/task.md @@ -0,0 +1,55 @@ +# Общее контрольное задание по теме 3 + +**Похил Анастасия, А-02-23** + +## Задание +• Преобразовать восьмеричное значение 45 в целое число. +• Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? +• Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4. +• Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключа-ющее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. +• Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка. +• Определить список методов, доступных у ранее созданного словаря D. Поочередно использо-вать его методы keys и values, определить, что можно получить с применением этих методов. +• Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. + +## Решение +```py +int('45', 8) +37 +D = {"усиление":23, "запаздывание":12, "постоянная времени":78} +keys_list = list(D.keys()) +values_list = list(D.values()) +keys_list +['усиление', 'запаздывание', 'постоянная времени'] +values_list +[23, 12, 78] +result_tuple = (keys_list, values_list) +result_tuple +(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78]) +(1768 // 24.8 % 3) ** 2.4 +5.278031643091577 +((~(13 & 27) ^ 14) << 2) +-32 +lst = ['колебат'] * 4 +lst +['колебат', 'колебат', 'колебат', 'колебат'] +'аткол' in (lst[1] + lst[2]) +True +dir(D) +['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'] +list(D.keys()) +['усиление', 'запаздывание', 'постоянная времени'] +list(D.values()) +[23, 12, 78] +text = "Создать объект - символьную строку с текстом данного предложения." +text +'Создать объект - символьную строку с текстом данного предложения.' +words = text.split() +words +['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.'] +words[words.index('-')] = ',' +words +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.'] +words.remove('данного') +words +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.'] +``` \ No newline at end of file