From 918bf2dcd1c28db398e514621207c89827566f9e Mon Sep 17 00:00:00 2001 From: KriviAS Date: Sun, 5 Oct 2025 13:42:02 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D1=82=D1=87=D1=91=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA2/test.md | 30 --- TEMA3/report.md | 644 ++++++++++++++++++++++++++++++++++++++++++++++++ TEMA3/task.md | 60 +++++ 3 files changed, 704 insertions(+), 30 deletions(-) delete mode 100644 TEMA2/test.md create mode 100644 TEMA3/report.md create mode 100644 TEMA3/task.md diff --git a/TEMA2/test.md b/TEMA2/test.md deleted file mode 100644 index 704463a..0000000 --- a/TEMA2/test.md +++ /dev/null @@ -1,30 +0,0 @@ -# Индивидуальное контрольное задание по теме 2 - -Криви Анастасия, А-02-23 - -## Задание - -Создайте два списка: один – с фамилиями 4-х студентов вашей группы, другой – с 5 числами: 111,112,113,114,115. Напишите инструкцию создания кортежа, у которого списки были бы двумя элементами. Отобразите кортеж. Напишите инструкцию вывода на экран с использованием функции print и ссылок на элементы кортежа так, чтобы получилось сообщение вида: <ФИО студента> 114 - -## Решение - -Создание списков:один – с фамилиями 4-х студентов вашей группы, другой – с 5 числами: 111,112,113,114,115. - -```py -spis=[111,112,113,114,115] -spis1=['Криви', 'Володин', 'Киреев', 'Добровольска'] -``` -Создание кортежа, у которого списки были бы двумя элементами. -```py -k =(spis1, spis); k -(['Криви', 'Володин', 'Киреев', 'Добровольска'], [111, 112, 113, 114, 115]) -``` -Инструкция вывода на экран с использованием функции print и ссылок на элементы кортежа так, чтобы получилось сообщение вида: <ФИО студента> 114 - -```py -print(list(zip(k[0],k[1]))) - -[('Криви', 111), ('Володин', 112), ('Киреев', 113), ('Добровольска', 114)] -``` - -## Завершение \ No newline at end of file diff --git a/TEMA3/report.md b/TEMA3/report.md new file mode 100644 index 0000000..7c44a2d --- /dev/null +++ b/TEMA3/report.md @@ -0,0 +1,644 @@ +# Отчет по теме 2 + +Криви Анастасия, А-02-23 + +## 1 Запуск IDLE +## 2 Преобразование простых базовых типов объектов +Выполнение указанных инструкций: + +2.1. Преобразование в логический тип с помощью функции bool(<Объект>) + +```py +logiz1=bool(56); logiz1 +True +logiz2=bool(0); logiz2 +False +logiz2=bool(1); logiz2 +True +logiz3=bool("Beta"); logiz3 +True +logiz4=bool(""); logiz4 +False +``` +Из этих примеров делаем вывод о том, что данная функция выводит True при не пустых заначениях, не равных нулю. Значение False в обратных. + +2.2. Преобразование в целое десятичное число объекта с заданной системой счисления. Эта задача существляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). + +По умолчанию система счисления принимается десятичной. + +```py +tt1=int(195.4); tt1 +195 +tt2=int("-76"); tt2 +-76 +tt3=int("B",16); tt3 +11 +tt4=int("71",8); tt4 +57 +tt5=int("98.76"); tt5 +Traceback (most recent call last): + File "", line 1, in + tt5=int("98.76"); tt5 +ValueError: invalid literal for int() with base 10: '98.76' +``` +При попытке преобразовать строку "98.76" в целое число с помощью int() позникает ошибка. Почему? Строка содержит десятичную точку, что является недопустимым для прямого преобразования в int. функция int ожидает строку, представляющую целое число, то есть без плавающей точки. + +Для того чтобы устранить ошибку, необходимо преобразовать строку "98.76" в целое число, мы должны сначала преобразовать ее в float, а затем в int: + +```py +tt5 = int(float("98.76")) +98 +``` +Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>). + +```py +flt1=float(789);flt1 +789.0 +flt2=float(-6.78e2); flt2 #Потому что -6.78 * 100 = -678 +-678.0 +flt3=float("Infinity"); flt3 #Бесконечность +inf +flt4=float("-inf"); flt4 #Бесконечность отрицательная +-inf +``` +2.3. Преобразование десятичных чисел в другие системы счисления + +```py +hh=123 +dv1=bin(hh) #Преобразование в строку с двоичным представлением +dv1 +'0b1111011' +vos1=oct(hh); vos1 # Преобразование в строку с восьмеричным представлением +'0o173' +shs1=hex(hh); shs1 # Преобразование в строку с шестнадцатеричным представлением +'0x7b' +``` +Обратное преобразование: + +```py +int(dv1,2) +123 +int(vos1,8) +123 +int(shs1,16) +123 +``` +## 3 Изучите преобразования более сложных базовых типов объектов + +3.1. Преобразование в строку символов с помощью функции str(<Объект>) + +```py +strk1=str(23.6); strk1 +'23.6' +strk2=str(logiz3); logiz3; strk2 +True +'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. Преобразование элементов объекта в список с помощью функции list(<Объект>) + +```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'] +``` +3.3. Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>) + +```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. Удаление объектов + +Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del. + +```py +del strk5, kort8 +dir() +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'fio', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'kortf', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spisf', 'strk1', 'strk2', 'strk3', 'strk4', 'strkf', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1'] +``` +Создание строки со своей фамилией и инициалами, преобразование её в список, затем список – в кортеж и, наконец, кортеж – в строку + +```py +f="Криви А.С." +s=list(f); s +['К', 'р', 'и', 'в', 'и', ' ', 'А', '.', 'С', '.'] +k=tuple(s); k +('К', 'р', 'и', 'в', 'и', ' ', 'А', '.', 'С', '.') +st=str(k); st +"('К', 'р', 'и', 'в', 'и', ' ', 'А', '.', 'С', '.')" +``` +## 4 Арифметические операции + +4.1. Сложение и вычитание + +```py +12+7+90 +109 +5.689e-1-0.5 +0.06889999999999996 +25.5+4 +29.5 +13-51.05+11003907 +11003868.95 +``` +4.2. Умножение + +```py +-6.7*12 +-80.4 +``` +Умножение вещественного числа на целое число + +4.3. Деление + +Результатом деления всегда будет вещественное число + +```py +-234.5/6 #Деление вещественного числа на целое +-39.083333333333336 +a=178/45 #Деление двух целых чисел – проверьте тип объекта a! +type(a) + +``` + +4.4. Деление с округлением вниз + +Здесь результат может быть целым или вещественным. В нижеследующих операциях определите тип результата + +```py +b=178//45 #Деление двух целых чисел +3 +c=-24.6//12.1 #Деление двух вещественных чисел +-3.0 + +178.3434//34e-4 +52453.0 +``` + +4.5. Получение остатка от деления + +```py + 148%33 #Остаток от деления двух целых чисел +16 +12.6%3.8 #Остаток от деления двух вещественных чисел +1.2000000000000002 + +12e-6%391278e-8 +1.2e-05 +``` +4.6. Возведение в степень +```py + 14**3 #Целое число возводится в целую степень +2744 + e=2.7**3.6; e #Вещественное число возводится в вещественную степень +35.719843790663525 +``` +В результате операции над числами разных типов получается число, имеющее наиболее сложный тип из тех типов, которые участвуют в операции. + +Для комплексных чисел доступны операции: +, -, *, /, **, но не // и %. + +## 5 Операции с двоичными представлениями целых чисел +5.1. Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0). + +~x = - (x + 1) + +```py +dv1=9; dv1 +9 +dv2=~dv1; dv2 +-10 + +dv1=10283 +~dv1 +-10284 +``` +5.2. Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел +```py +7&9 # 111 и 1001 = 0001 +1 +7&8 # 111 и 1000 = 0000 +0 +``` +5.3. Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0 + +```py +7|9 # 111 или 1001 = 1111 +15 +7|8 # 111 или 1000 = 1111 +15 +14|5 # 1110 или 0101 = 1111 +15 +14|14 +14 +0|0 +0 +111|1 +111 +``` +5.4. Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1. +```py +14^5 # 1110 исключающее или 0101 = 1011 +11 +type(c) + +``` +5.5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева + +```py +h=14 #Двоичное представление = 1110 +g=h<<2; g +56 +g1=h>>1; g1 # Новое двоичное представление = 0111 +7 +g2=h>>2; g2 # Новое двоичное представление = 0011 +3 +``` +Оперции с числами, двоичный код которых 7 знаков: +```py +99>>2 +24 +99<<50 +111464090777419776 +99<<0 +99 +99<<1 +198 +100<<100 +126765060022822940149670320537600 +bin(126765060022822940149670320537600) +'0b11001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' +bin(100) +'0b1100100' +bin(99) +'0b1100011' +``` +## 6 Операции при работе с последовательностями (строками, списками, кортежами) +6.1. Объединение последовательностей (конкатенация)(+) + +'Система' + 'регулирования' #Соединение двух строк символов + +Соединение двух списков: +```py +['abc','de','fg']+['hi','jkl'] +['abc', 'de', 'fg', 'hi', 'jkl'] +``` +Соединение двух кортежей: +```py +('abc','de','fg')+('hi','jkl') +('abc', 'de', 'fg', 'hi', 'jkl') +``` + +6.2. Повторение (*) + +```py +'ля-'*5 #строки +'ля-ля-ля-ля-ля-' +['ку','-']*3 #список +['ку', '-', 'ку', '-', 'ку', '-'] +('кис','-')*4 #кортеж +('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-') +``` +Создание списка со 100 отсчетами сигнала-ступеньки +```py +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] +``` + +Создание кортежа с отсчетами сигнала – импульса +```py +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) + +```py +stroka='Система автоматического управления' +'автомат' in stroka; stroka #подстрока +True +'Система автоматического управления' +'ку' in ['ку','-']*3 #наличие контекста +True +'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') +False +``` +6.4.Подстановка значений в строку с помощью оператора «%» + +```py +Пример 1: + +stroka='Температура = %g %s %g' +stroka +'Температура = %g %s %g' +stroka % (16,' меньше ',25) +'Температура = 16 меньше 25' +``` +Используя данных из словаря +```py +stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' +stroka % {'zn1':16,'sravn':' меньше ','zn2':25} +'Температура = 16 меньше 25' +``` + +## 7 Оператор присваивания + +7.1.Обычное присваивание значения переменной (=) +```py +zz=-12 +``` +7.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=) +```py +zz+=5; zz # Значение zz увеличивается на 5 +-7 +zz-=3; zz +-10 +``` +Для последовательностей операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением: +```py +stroka='Система'; stroka+=' регулирования'; stroka +'Система регулирования' +``` +7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=) +```py +zz=-10 +zz/=2 +zz +-5.0 +zz*=5 +zz +-25.0 +``` +Для строк операция (*=) означает повторение текущего значения объекта заданное число раз. +```py +stroka*=2 +stroka +'Система регулированияСистема регулирования' +``` +7.4.Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) +```py +zz//=2; zz +-13.0 +zz**=8; zz +815730721.0 +``` +7.5. Множественное присваивание +```py +w=v=10 # Переменным присваивается одно и то же значение +n1,n2,n3=(11,-3,'all') #Значения переменных берутся из кортежа +n1 +11 +n2 +-3 +n3 +'all' +n1, n2, n3 = [11, -3, 'all'] +n1 +11 +n1, n2, n3 = {'a':1, 'b':2, 'c':3} +n1 +'a' +n1, n2, n3 = {'a':1, 'b':2, 'c':3}.values() +n1 +1 +n1, n2, n3 = {1, 2, 3} +n1 +1 +n1, n2, n3 = '1,2' +n1, n2, n3 +('1', ',', '2') +``` + +## 8 Логические операции + +Создание логических выражений, дающих в результате вычисления значения True или False. + +8.1. Операции сравнение: +равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) + +```py +w=v=10 +w==v +True +w<=10 +True +v>6 +True +``` +8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in) +Операции с множеством +```py +mnoz1={'pen','book','pen','iPhone','table','book'} +'book' in mnoz1 +True +'cap' in mnoz1 +False +``` +Операции со словарем +```py +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 +(a>=b) and ('book' in mnoz1) and ('Pskov' in dic1) +False +(a>=b) and ('book' in mnoz1) or ('Pskov' in dic1) +True +``` +8.4. Проверка ссылок переменных на один и тот же объект (is). + +```py +w=v=10 +w is v +True +w1=['A','B'] +v1=['A','B'] +w1 is v1 +False +w1=v1 +w1 is v1 +True +``` +При создании списков ['A', 'B'] и ['A', 'B'] Python создает два разных объекта в памяти. Хотя содержимое списков идентично, это разные объекты с разными адресами в памяти +## 9. Операции с объектами, выполняемые с помощью методов + +Полный список всех атрибутов любого объекта можно получить с использованием функции dir. +```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. Методы для работы со строками + +Номер позиции первого вхождения указанного контекста или значение -1 +```py +stroka.find('пр') +5 +``` +Подсчет числа вхождений строки “с” в stroka +```py +stroka.count("с") +4 +``` +Замена +```py +stroka.replace(' у',' автоматического у') +'Микропроцессорная система автоматического управления' +``` +Cписок подстрок, между которыми в строке стоит заданный разделитель +```py +spis22=stroka.split(' '); spis22 +['Микропроцессорная', 'система', 'управления' +``` +Cтрокa со всеми заглавными буквами +```py +stroka.upper() +'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ' +``` +Cтрокa, собранную из элементов списка +```py +stroka3=" ".join(spis22); stroka3 +'Микропроцессорная система управления' +``` +Kортеж с результатами поиска «с» слева +```py +stroka3.partition("с") +('Микропроце', 'с', 'сорная система управления') +``` +Kортеж с результатами поиска «с» справа +```py +stroka3.rpartition("с") +('Микропроцессорная си', 'с', 'тема управления') +``` +Mетод format. +Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола + +```py +stroka3=" ".join(spis22); stroka3 +'Микропроцессорная система управления' +strk1='Момент времени {}, значение = {}' +strk1.format(1,89.7) +'Момент времени 1, значение = 89.7' + +strk2='Момент времени {1}, значение = {0}:{2}' #где 0,1,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. Методы для работы со списками + +```py +spsk=['trt']*5; spsk +['trt', 'trt', 'trt', 'trt', 'trt'] + +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) +'trt' +spsk.append('c') +spsk +['trt', 'trt', 'trt', 'trt', 'c'] +spsk.insert(2,'a') +spsk +['trt', 'trt', 'a', 'trt', 'trt', 'c'] +spsk.count('a') +1 +``` +9.3. Kортеж и применение его методов +```py +k=('ele -')*4; k +'ele -ele -ele -ele -' +k.replace(' -', ' - ') +'ele - ele - ele - ele - ' + + +k.append('ele') +Traceback (most recent call last): + File "", line 1, in + k.append('ele') +AttributeError: 'str' object has no attribute 'append' +k.insert(3, 'ele') +Traceback (most recent call last): + File "", line 1, in + k.insert(3, 'ele') +AttributeError: 'str' object has no attribute 'insert' +k.pop(0) +Traceback (most recent call last): + File "", line 1, in + k.pop(0) +AttributeError: 'str' object has no attribute 'pop' + + +k.count('e') +8 +k.index('ele') +0 +``` +9.4. Mетоды словарей и множеств + +```py +d={'сонливость':10, 'усталость':1, 'апатия':2, 'мотивация':8}; d +{'сонливость': 10, 'усталость': 1, 'апатия': 2, 'мотивация': 8} + +d.values() +dict_values([10, 1, 2, 8]) +d.keys() +dict_keys(['сонливость', 'усталость', 'апатия', 'мотивация']) +d.pop('усталость') +1 +d['усталость'] = 100 +d +{'сонливость': 10, 'апатия': 2, 'мотивация': 8, 'усталость': 100} +``` +```py +m={'сонливость', 'усталость', 'апатия', 100j} +type(m) + +m.add(1028140+2947) +m +{'усталость', 100j, 1031087, 'апатия', 'сонливость'} +m.pop() +'усталость' +m +{100j, 1031087, 'апатия', 'сонливость'} +m.pop() +100j +m +{1031087, 'апатия', 'сонливость'} +m.issubset('b') +False +``` +## 10 Завершение работы \ No newline at end of file diff --git a/TEMA3/task.md b/TEMA3/task.md new file mode 100644 index 0000000..5eccec6 --- /dev/null +++ b/TEMA3/task.md @@ -0,0 +1,60 @@ +# Общее контрольное задание по теме 3 + +Криви Анастасия, А-02-23 + +## Задание + +Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций. + +## Решение + +Преобразовать восьмеричное значение 45 в целое число. +```py +int('45', 8) +37 +``` +Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? +```py +k1=list(D.keys());k1; v1=list(D.values()); v1 +['усиление', 'запаздывание', 'постоянная времени'] +[23, 12, 78] +D1=(k1,v1); D1 +(['усиление', 'запаздывание', 'постоянная времени'], [23, 12, 78]) +``` +Кортеж, в отличие от списка, является неизменяемым объектом + +Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4 +```py +((1768 // 24.8) % 3) ** 2.4 +5.278031643091577 +``` +Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. +```py +(~(13 & 27) ^ 14) << 2 +-32 +``` +Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка. +```py +s=['колебат']*4;s +['колебат', 'колебат', 'колебат', 'колебат'] +"аткол" in s[1] + s[2] +True +``` +Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов. +```py +D.keys(); D.values() +dict_keys(['усиление', 'запаздывание', 'постоянная времени']) +dict_values([23, 12, 78]) +``` +Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. +```py +sim +'Создать объект - символьную строку с текстом данного предложения' +type(sim) + +spis[spis.index('-')]=',' +spis.remove('данного');spis +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения'] +``` + +