From 43b8bd5536b75783f4c1e2b6673b8bb5e82ca423 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BA=D1=81=D0=B8=D0=BC=20=D0=9A=D0=BE=D1=80?= =?UTF-8?q?=D0=BD=D0=B5=D0=B5=D0=B2?= Date: Sat, 27 Sep 2025 19:39:32 +0300 Subject: [PATCH] done lab3 --- TEMA3/report.md | 702 ++++++++++++++++++++++++++++++++++++++++++++++++ TEMA3/task.md | 71 +++++ 2 files changed, 773 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..4eabb35 --- /dev/null +++ b/TEMA3/report.md @@ -0,0 +1,702 @@ +# Отчет по теме 3 + +Корнеев Максим, А-03-23 + +## 1 Преобразование простых базовых типов объектов. + +### 1.1 Преобразование в логический тип +```py +>>> logiz1=bool(56) +>>> logiz1 +True +>>> type(logiz1) + +>>> logiz2=bool(0) +>>> logiz2 +False +>>> type(logiz2) + +>>> logiz3=bool("Beta") +>>> logiz3 +True +>>> type(logiz3) + +>>> logiz4=bool("") +>>> logiz4 +False +>>> type(logiz4) + +``` + +### 1.2 Преобразование в численные типы +```py +>>> tt1=int(198.6) +>>> tt1 +198 +>>> type(tt1) + +>>> tt2=int("-76") +>>> tt2 +-76 +>>> type(tt2) + +>>> tt3=int("B",16) +>>> tt3 +11 +>>> type(tt3) + +>>> tt4=int("71",8) +>>> tt4 +57 +>>> type(tt4) + +>>> 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 ожидает, что ей сообщат строку (только цифры, может быть знак в начале). Здесь есть точка, поэтому возникает несоответствие ожидаемого формата. Нужно сначала переопределить это число как float, а потом уже применить команду int. + +```py +>>> flt1=float(789) +>>> flt1 +789.0 +>>> type(flt1) + +>>> flt2=float(-6.78e2) +>>> flt2 +-678.0 +>>> type(flt2) + +>>> flt3=float("Infinity") +>>> flt3 +inf +>>> type(flt3) + +>>> flt4=float("-inf") +>>> flt3 +inf +>>> type(flt4) + +``` + +### 1.3 Преобразование десятичных чисел в другие системы счисления +```py +>>> hh=123 +>>> dv1=bin(hh) +>>> dv1 +'0b1111011' +>>> type(dv1) + +>>> vos1=oct(hh) +>>> vos1 +'0o173' +>>> type(vos1) + +>>> shs1=hex(hh) +>>> shs1 +'0x7b' +>>> type(shs1) + +>>> int(dv1,2) +123 +>>> int(vos1,8) +123 +>>> int(shs1,16) +123 +``` + +## 2 Преобразование более сложных типов объектов + +### 2.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}" +``` + +### 2.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'] +>>> spis3=list({"A":1,"B":2,"C":9}.values()) +>>> spis3 +[1, 2, 9] +``` + +### 2.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') +``` + +### 2.4 Удаление объектов +```py +>>> del strk5, kort8 +>>> dir() +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1'] +``` + +Создадим строку с моей фамилией и инициалами. Преобразуем её в список, затем список - в кортеж, затем кортеж - в строку. +```py +>>> familia = 'КорнеевМА' +>>> f_spis=list(familia) +>>> f_spis +['К', 'о', 'р', 'н', 'е', 'е', 'в', 'М', 'А'] +>>> f_kort=tuple(f_spis) +>>> f_kort +('К', 'о', 'р', 'н', 'е', 'е', 'в', 'М', 'А') +>>> f_str=str(f_kort) +>>> f_str +"('К', 'о', 'р', 'н', 'е', 'е', 'в', 'М', 'А')" +``` + +## 3 Арифметические операции + +### 3.1 Сложение и вычитание (+ и -) +```py +>>> 12+7+90 +109 +>>> 5.689e-1 - 0.456 +0.11289999999999994 +>>> 23.6+54 +77.6 +>>> 14-56.7+89 +46.3 +``` + +### 3.2 Умножение (*) +```py +>>> -6.7*12 +-80.4 +``` + +### 3.3 Деление (/) +```py +>>> -234.5/6 +-39.083333333333336 +>>> a=178/45 +>>> a +>>> 3.9555555555555557 +>>> type(a) + +``` + +### 3.4 Деление с округлением вниз (//) +```py +>>> b=178//45 +>>> b +3 +>>> type(b) + +>>> c=-24.6//12.1 +>>> c +-3.0 +>>> type(c) + +``` + +### 3.5 Получение остатка от деления (%) +```py +>>> 148%33 +16 +>>> 12.6%3.8 +1.2000000000000002 +>>> 15%2.3 +1.200000000000001 +>>> 13.2%2 +1.1999999999999993 +``` + +### 3.6 Возведение в степень (**) +```py +>>> 14**3 +2744 +>>> e=2.7**3.6 +>>> e +35.719843790663525 +>>> 13.4**4 +32241.793600000005 +>>> 11**4.3 +30059.970232379124 +``` + +Попробуем операции с участием комплексных чисел: +```py +>>> c1=2-3j +>>> c2=1+4j +>>> c1+c2 +(3+1j) +>>> c1+2 +(4-3j) +>>> c2-3 +(-2+4j) +>>> c2*c1 +(14+5j) +>>> c2*3 +(3+12j) +>>> c1/5 +(0.4-0.6j) +>>> 12/c2 +(0.7058823529411765-2.823529411764706j) +>>> c1**2 +(-5-12j) +>>> 2**c1 +(-1.947977671863125-3.493620327099486j) +>>> c1**c2 +(-98.43395342485856-155.17660426903427j) +``` +Из используемых выше операций нельзя использовать с комплексными аргументами деление с округлением вниз (//) и получение остатка от деления (%) + +## 4 Операции с двоичными представлениями целых чисел + +### 4.1 Двоичная инверсия (~) +```py +>>> dv1=9 +>>> bin(dv1) +'0b1001' +>>> dv2=~dv1 +>>> bin(dv2) +'-0b1010' +>>> dv2 +-10 +``` +Результат не совпадает с ожидаемым видом "0110". Это происходит, потому что в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака. Было число 9 (1001), меняем все значения на противоположные (0110), затем надо поменять знак (это значит, что надо инвертировать все значения разрядов - будет 1001) и прибавить к полученному числу единицу (которая отвечает за знак), получаем число 1010. + +### 4.2 Двоичное «И» (&) +```py +>>> 7&9 +1 +>>> bin(7&9) +'0b1' +>>> 7&8 +0 +>>> bin(7&8) +'0b0' +``` + +### 4.3 Двоичное «ИЛИ» (|) +```py +>>> 7|9 +15 +>>> bin(7|9) +'0b1111' +>>> 7|8 +15 +>>> bin(7|8) +'0b1111' +>>> 14|5 +15 +>>> bin(14|5) +'0b1111' +``` + +### 4.4 Двоичное «исключающее ИЛИ»(^) +```py +>>> 14^5 +11 +>>> bin(14^5) +'0b1011' +``` + +### 4.5 Сдвиг двоичного представления на заданное число разрядов +```py +>>> h=14 +>>> bin(h) +'0b1110' +>>> g=h<<2 +>>> bin(g) +'0b111000' +>>> g1=h>>1 +>>> bin(g1) +'0b111' +>>> g2=h>>2 +>>> bin(g2) +'0b11' +``` + +Возьмём два числа 92 и 201. Проведём с ними двоичные операции: +```py +>>> g3=92 +>>> bin(g3) +'0b1011100' +>>> g4=201 +>>> bin(g4) +'0b11001001' +>>> g5=~g3 +>>> g5 +-93 +>>> bin(g5) +'-0b1011101' +>>> g3&g4 +72 +>>> bin(g3&g4) +'0b1001000' +>>> g3|g4 +221 +>>> bin(g3|g4) +'0b11011101' +>>> g3^g4 +149 +>>> bin(g3^g4) +'0b10010101' +>>> g3<<2 +368 +>>> bin(g3<<2) +'0b101110000' +>>> g4>>3 +25 +>>> bin(g4>>3) +'0b11001' +``` + +## 5 Операции при работе с последовательностями + +### 5.1 Объединение последовательностей (конкатенация)(+) +```py +>>> 'Система '+'регулирования' +'Система регулирования' +>>> ['abc','de','fg']+['hi','jkl'] +['abc', 'de', 'fg', 'hi', 'jkl'] +>>> ('abc','de','fg')+('hi','jkl') +('abc', 'de', 'fg', 'hi', 'jkl') +``` + +### 5.2 Повторение (*) +```py +>>> 'ля-'*5 +'ля-ля-ля-ля-ля-' +>>> ['ку','-']*3 +['ку', '-', 'ку', '-', 'ку', '-'] +>>> ('кис','-')*4 +('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-') +>>> signal1=[0]*3+[1]*99 +>>> signal1 +[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] +>>> signal2=(0,)*3+(1,)*5+(0,)*7 +>>> signal2 +(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0) +``` + +### 5.3 Проверка наличия заданного элемента в последовательности (in) +```py +>>> stroka='Система автоматического управления' +>>> 'автомат' in stroka +True +>>> 'ку' in ['ку','-']*3 +True +>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') +False +``` + +### 5.4 Подстановка значений в строку с помощью оператора «%» +```py +>>> stroka='Температура = %g %s %g' +>>> stroka +'Температура = %g %s %g' +>>> stroka % (16,' меньше ',25) +'Температура = 16 меньше 25' +>>> stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' +>>> stroka +'Температура = %(zn1)g %(sravn)s %(zn2)g' +>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25} +'Температура = 16 меньше 25' +``` + +## 6 Оператор присваивания + +### 6.1 Обычное присваивание значения переменной (=) +```py +>>> zz=-12 +>>> zz +-12 +``` + +### 6.2 Умножение текущего значения переменной на заданную величину (*=) или деление (/=) +```py +>>> zz/=2 +>>> zz +-6.0 +>>> zz*=5 +>>> zz +-30.0 +>>> strk='Hello' +>>> strk*=4 +>>> strk +'HelloHelloHelloHello' +``` + +### 6.3 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) +```py +>>> a=30 +>>> a//=4 +>>> a +7 +>>> a%=4 +>>> a +3 +>>> a**=3 +>>> a +27 +``` + +### 6.4 Множественное присваивание +```py +>>> w=v=10 +>>> w +10 +>>> v +10 +>>> n1,n2,n3=(11,-3,'all') +>>> n1 +11 +>>> n2 +-3 +>>> n3 +'all' +>>> n1,n2,n3='a21' +>>> n1 +'a' +>>> n2 +'2' +>>> n3 +'1' +>>> n1,n2,n3=[11,-3,'all'] +>>> n1 +11 +>>> n2 +-3 +>>> n3 +'all' +>>> n1,n2,n3={'sq':1, 'wew':'let', 'roar':-2} +>>> n1 +'sq' +>>> n2 +'wew' +>>> n3 +'roar' +>>> n1,n2,n3={'sq':1, 'wew':'let', 'roar':-2}.values() +>>> n1 +1 +>>> n2 +'let' +>>> n3 +-2 +>>> n1,n2,n3={11,-3,'all'} +>>> n1 +'all' +>>> n2 +11 +>>> n3 +-3 +``` + +## 7 Логические операции + +### 7.1 Операции сравнения +```py +>>> w +10 +>>> v +10 +>>> w==v +True +>>> w!=v +False +>>> w>> w>v +False +>>> w<=v +True +>>> w>=v +True +``` + +### 7.2 Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in) +```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 +``` + +### 7.3 Создание больших логических выражений с использованием соединительных слов +```py +>>> a=17 +>>> b=-6 +>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1) +True +>>> ('cap' in mnoz1) or not (a>> ('Pskov' in dic1) or ('pen' in mnoz1) and ('Vologda' in dic1) +True +``` + +### 7.4 Проверка ссылок переменных на один и тот же объект (is) +```py +>>> w=v=10 +>>> w is v +True +>>> w1=['A','B'] +>>> v1=['A','B'] +>>> w1 is v1 +False +``` +Оператор is проверяет, ссылаются ли объекты на один и тот же адрес в памяти. Переменные целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти. Списки были созданы в разных строках, и адреса у них разные, т.е. они ссылаются на разные участки в памяти, поэтому is возвращает False. + +## 8 Операции с объектами, выполняемые с помощью методов + +### 8.1 Методы для работы со строками +```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'] +>>> stroka.find('пр') +5 +>>> stroka.count("с") +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' +``` + +### 8.2 Методы для работы со списками +```py +>>> spsk=['a', 21, -2, 'Maxim', 0] +>>> spsk.pop(2) # вывод элемента с указанным индексом и удаление его из списка +-2 +>>> spsk +['a', 21, 'Maxim', 0] +>>> spsk.append('c') # добавляение переданного элемента в конец списка +>>> spsk +['a', 21, 'Maxim', 0, 'c'] +>>> spsk.insert(2,'a') # добавление в список элемента в указанный индекс, сдвигая следующие элементы +>>> spsk +['a', 21, 'a', 'Maxim', 0, 'c'] +>>> spsk.count('a') # вывод колличества вхождений в список указанного элемента +2 +``` + +### 8.3 Методы для работы с кортежами +```py +>>> cor = (1, 'a', 'b', 0.05, 10+3j) # Создание кортежа +>>> cor.count(1) # Подсчет количества элементов по значению +1 +>>> cor.index(0.05) # Поиск индекса первого вхождения +3 +>>> cor.index('d') +Traceback (most recent call last): + File "", line 1, in + cor.index('d') +ValueError: tuple.index(x): x not in tuple +``` + +### 8.3 Методы для работы со словарями и множествами +Методы словарей: +```py +>>> dct1 +{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']} +>>> new_dct1=dct1.copy() # Создается копия, но новые значения ссылаются на предыдущие +>>> new_dct1 +{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']} +>>> dct1.get('Depart') # Возвращение значения по ключу +['UII', 'PM', 'VMSS', 'MM'] +>>> dct1.keys() # Возвращение объекта только из ключей +dict_keys(['Institut', 'Depart', 'gruppa']) +>>> dct1.values() # Возвращение объекта только из значений +dict_values([['AVTI', 'IEE', 'IBB'], ['UII', 'PM', 'VMSS', 'MM'], ['A-01-15', 'A-02-15']]) +>>> new_dct1.clear() # Полное очищение списка +>>> new_dct1 +{} +>>> dct1.pop('Depart') # Удаление ключа и возвращение значения +['UII', 'PM', 'VMSS', 'MM'] +>>> dct1 +{'Institut': ['AVTI', 'IEE', 'IBB'], 'gruppa': ['A-01-15', 'A-02-15']} +``` + +Методы множеств: +```py +>>> mnoz1={1, 'датчик', False, 256, 'двигатель'} +>>> mnoz1 +{False, 256, 1, 'двигатель', 'датчик'} +>>> mnoz1.add(10+7j) # Добавление элемента +>>> mnoz1 +{False, 256, 1, 'двигатель', 'датчик', (10+7j)} +>>> mnoz2=mnoz1.copy() # Создание копии +>>> mnoz2 +{False, 256, 1, 'двигатель', 'датчик', (10+7j)} +>>> mnoz1.remove(1) # Удаление элемента по значению +>>> mnoz1 +{False, 256, 'двигатель', 'датчик', (10+7j)} +>>> mnoz2.clear() # Очищение множества +>>> mnoz2 +set() +>>> mnoz1.pop() # Удаление случайного элемента из множества +False +>>> mnoz1 +{256, 'двигатель', 'датчик', (10+7j)} +>>> mnoz1.update({True, 'b'}) # Добавление элементов +>>> mnoz1 +{256, True, 'b', 'двигатель', 'датчик', (10+7j)} +``` \ No newline at end of file diff --git a/TEMA3/task.md b/TEMA3/task.md new file mode 100644 index 0000000..5d2bb4a --- /dev/null +++ b/TEMA3/task.md @@ -0,0 +1,71 @@ +# Общее контрольное задание по теме 3 + +Корнеев Максим, А-03-23 + +## Задание + +Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия: +* Преобразовать восьмеричное значение 45 в целое число. +* Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? +* Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4. +* Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. +* Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка. +* Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов. +* Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. + + + +## Решение + +```py +>>> h=int('45',8) +>>> h +37 +>>> D={"усиление":23, "запаздывание":12, "постоянная времени":78} +>>> spis1=list(D) +>>> spis1 +['усиление', 'запаздывание', 'постоянная времени'] +>>> spis2=list(D.values()) +>>> spis2 +[23, 12, 78] +>>> kort1=tuple(spis1) +>>> kort1 +('усиление', 'запаздывание', 'постоянная времени') +>>> kort2=tuple(spis2) +>>> kort2 +(23, 12, 78) +>>> kort=kort1+kort2 +>>> kort # Список отличается от кортежа тем, что список изменяем, а кортеж нет. +('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78) +>>> ((1768//24.8)%3)**2.4 +5.278031643091577 +>>> (~(13&27)^14)<<2 +-32 +>>> spis3=['колебат']*4 +>>> spis3 +['колебат', 'колебат', 'колебат', 'колебат'] +>>> 'аткол' in spis3[1]+spis3[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'] +>>> D.keys() +dict_keys(['усиление', 'запаздывание', 'постоянная времени']) +>>> D.values() +dict_values([23, 12, 78]) +>>> strk='Создать объект - символьную строку с текстом данного предложения.' +>>> strk +'Создать объект - символьную строку с текстом данного предложения.' +>>> spis=strk.split(' ') +>>> spis +['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.'] +>>> spis.index('-') +2 +>>> spis.pop(2) +'-' +>>> spis.insert(2,',') +>>> spis +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.'] +>>> spis.remove('данного') +>>> spis +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.'] +``` \ No newline at end of file