From eb6783bfbcf52d6f4d850cbe38f0d0fd24a29b64 Mon Sep 17 00:00:00 2001 From: byvs Date: Sun, 14 Sep 2025 19:44:56 +0300 Subject: [PATCH 1/2] report in TOPIC3 is done --- TEMA3/report.md | 716 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 716 insertions(+) create mode 100644 TEMA3/report.md diff --git a/TEMA3/report.md b/TEMA3/report.md new file mode 100644 index 0000000..f476bf3 --- /dev/null +++ b/TEMA3/report.md @@ -0,0 +1,716 @@ +# Отчёт по теме 3 +Выполнил Степанищев Виктор, А-03-23 + +## 1. Начало работы +Запуск IDLE, установление рабочего каталога + +## 2. Преобразование простых базовых типов объектов +### 2.1 Преобразование в логический тип с помощью функции bool +```py +>>> logiz1=bool(56) # 56 не ноль, поэтому True (любое число не равное нулю - True) +>>> logiz2=bool(0) # 0 - ноль, поэтому False +>>> logiz3=bool("Beta") # строка не пустая (имеет длину не равную нулю) - True +>>> logiz4=bool("") # строка пустая, кол-во символов 0 - False +>>> logiz1 +True +>>> logiz2 +False +>>> logiz3 +True +>>> logiz4 +False +``` +### 2.2 Преобразование в целое десятичное число / в вещественное число +```py +>>> tt1=int(198.6) # отбрасывается дробная часть (без округления) +>>> tt2=int("-76") # число в строке символов (-76), система счисления не указана как параметр - по дефолту десятичная +>>> tt3=int("B",16) # перевод в 16-ричную +>>> tt4=int("71",8) # перевод в 8-ричную + +>>> tt1 +198 +>>> tt2 +-76 +>>> tt3 +11 +>>> tt4 +57 +``` +Диагностическая ошибка +```py +>>> 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(float("98.76")) + +```py +>>> flt1=float(789) +>>> flt2=float(-6.78e2) +>>> flt3=float("Infinity") +>>> flt4=float("-inf") +>>> flt1 +789.0 +>>> flt2 +-678.0 +>>> flt3 +inf +>>> flt4 +-inf +``` +### 2.3 Преобразование десятичных чисел в другие системы счисления +```py +>>> hh=123 +>>> dv1=bin(hh) # двоичная сс +>>> vos1=oct(hh) # 8-ричная сс +>>> shs1=hex(hh) # 16-ричная сс +>>> dv1 +'0b1111011' +>>> vos1 +'0o173' +>>> shs1 +'0x7b' +``` +Обратное преобразование: +```py +>>> int(dv1, 2) +123 +>>> int(vos1, 8) +123 +>>> int(shs1, 16) +123 +``` + +## 3. Преобразование более сложных базов типов объектов +### 3.1 Преобразование в строку +```py +>>> strk1=str(23.6) +>>> strk2=str(logiz3) +>>> strk3=str(["A","B","C"]) +>>> strk4=str(("A","B","C")) +>>> strk5=str({"A":1,"B":2,"C":9}) +``` +Вывод +```py +>>> strk1 +'23.6' +>>> strk2 +'True' +>>> strk3 +"['A', 'B', 'C']" +>>> strk4 +"('A', 'B', 'C')" +>>> strk5 +"{'A': 1, 'B': 2, 'C': 9}" +``` + +### 3.2 Преобразование эл-ов объекта в список с помощью list() +```py +>>> spis1=list("Строка символов") +>>> spis2=list((124,236,-15,908)) +>>> spis3=list({"A":1,"B":2,"C":9}) +``` +Вывод +```py +>>> spis1 +['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'] +>>> spis2 +[124, 236, -15, 908] +>>> spis3 +['A', 'B', 'C'] +``` +Задание: + + Придумайте инструкцию, обеспечивающую создание из того же словаря списка с другими его частями. + +Решение: +```py +>>> spis3=list({"A":1,"B":2,"C":9}.values()) +>>> spis3 +[1, 2, 9] +``` +### 3.3 Преобразование элементов объектов в кортеж +```py +>>> kort7=tuple('Строка символов') +>>> kort8=tuple(spis2) +>>> kort9=tuple({"A":1,"B":2,"C":9}) +``` +Вывод +```py +>>> kort7 +('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в') +>>> kort8 +(124, 236, -15, 908) +>>> kort9 +('A', 'B', 'C') +``` +```py +>>> kort9=tuple({"A":1,"B":2,"C":9}.values()) # уже по значениям +``` +Вывод +```py +>>> kort9 +(1, 2, 9) +``` +### 3.4 Удаление объектов +```py +>>> del strk5, kort8 +``` +Проверка на наличие переменных после удаления +```py +>>> 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'? +``` +Задание: + +Создайте строку со своей фамилией и инициалами, преобразуйте её в список, затем список – в кортеж и, наконец, кортеж – в строку + +Ответ: + +```py +>>> fio = 'Stepanishchev V.R.' +>>> list_fio = list(fio) +>>> cort_fio = tuple(list_fio) +>>> str_fio = str(cort_fio) +``` +Вывод: +```py +>>> list_fio +['S', 't', 'e', 'p', 'a', 'n', 'i', 's', 'h', 'c', 'h', 'e', 'v', ' ', 'V', '.', 'R', '.'] +>>> cort_fio +('S', 't', 'e', 'p', 'a', 'n', 'i', 's', 'h', 'c', 'h', 'e', 'v', ' ', 'V', '.', 'R', '.') +>>> str_fio +"('S', 't', 'e', 'p', 'a', 'n', 'i', 's', 'h', 'c', 'h', 'e', 'v', ' ', 'V', '.', 'R', '.')" +``` + +## 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 +>>> c=-24.6//12.1 +``` +Вывод результата и типа каждого объекта +```py +>>> type(b) + +>>> b +3 + +>>> type(c) + +>>> c +-3.0 +``` +Если в целочисленном делении используется хотя бы один объект вещественного типа - результат будет вещественным, +если оба целых объекта - результат целый + +Самостоятельно попробовал смешанные комбинации типов чисел в этой операции: +```py +>>> lol = 145.2 // 2 +``` +Вывод: +```py +>>> type(lol) + +>>> lol +72.0 +``` +### 4.5 Получение остатка от деления +```py +>>> 148%33 +16 +>>> 12.6%3.8 +1.2000000000000002 +``` +Самостоятельно попробовал смешанные комбинации типов чисел в этой операции: +```py +>>> 158.6 % 6 +2.5999999999999943 +``` +Если в остатке от деления используется хотя бы один объект вещественного типа - результат будет вещественным, +если оба целых объекта - результат целый +## 4.6 Возведение в степень +```py +>>> 14**3 +2744 +>>> e=2.7**3.6 +>>> e +35.719843790663525 +``` +Самостоятельно попробовал смешанные комбинации типов чисел в этой операции: +```py +>>> 5**3.2 +172.4662076826519 +``` +Вопрос: + + Какие из приведенных выше операций можно применять к комплексным числам, а какие – нет? + +Ответ: + +К комплексным числам можно применять следующие операции: +1) сложение +2) вычитание +3) умножение +4) деление +5) возведение в степень + +и нельзя следующие: +1) целочисленное деление +```py +>>> z1 = 3 + 4j +>>> z2 = 1 + 2j +>>> z1 // z2 +Traceback (most recent call last): + File "", line 1, in + z1 // z2 +TypeError: unsupported operand type(s) for //: 'complex' and 'complex' +``` +(целочисленное деление требует целой части, не мнимой) + +2) остаток от деления +```py +>>> z1 = 3 + 4j +>>> z2 = 1 + 2j +>>> z1 % z2 +Traceback (most recent call last): + File "", line 1, in + z1 % z2 +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' +``` +(остаток от деления по сути основан на целочисленном делении, также работа с мнимой частью не предусмотрена) + +## 5. Операции с двоичными представлениями целых чисел +### 5.1 Двоичная инверсия ~ +```py +>>> dv1=9 +>>> dv2=~dv1 +>>> dv2 +-10 +``` +Почему результат отрицательный - используется дополнительный код (two's complement) для представления отрицательных чисел. Формула результата: + +**~x = -x - 1** +### 5.2 Двоичное "И" +```py +>>> 7&9 +1 +>>> 7&8 +0 +``` +### 5.3 Двоичное "Или" +```py +>>> 7|9 +15 +>>> 7|8 +15 +>>> 14|5 +15 +``` +### 5.4 Двоичное исключающее "Или" +```py +>>> 14^5 +11 +``` +### 5.5 Двоичное исключающее "Или" (Влево или вправо) +```py +>>> h=14 #Двоичное представление = 1110 +>>> g=h<<2 # Новое двоичное представление = 111000 +>>> g1=h>>1 # Новое двоичное представление = 0111 +>>> g2=h>>2 # Новое двоичное представление = 0011 +``` +Задание: + +Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции. + +Ответ: +```py +>>> a = 181 +>>> b = 108 +>>> a & b +36 +>>> a | b +253 +>>> a ^ b +217 +``` +По условию минимум 7 знаков: +```py +>>> bin(a)[2:] +'10110101' +>>> bin(b)[2:] +'1101100' +``` + +## 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 +'ля-ля-ля-ля-ля-' +>>> ['ку','-']*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 Проверка наличия заданного элемента в последовательности +```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' +``` +%g - placeholder для чисел + +%s - placeholder для строк + +```py +>>> 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=-12 +>>> zz +-12 +>>> zz+=5 +>>> zz-=3 +>>> stroka='Система' +>>> stroka+=' регулирования' +>>> zz +-10 +>>> stroka +'Система регулирования' +``` +### 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=) +```py +>>> zz/=2 +>>> zz*=5 +``` +Попробовал самостоятельно + +```py +>>> aaa = 5 +>>> aaa *= 3 +>>> aaa +15 +>>> aaa /= 5 +>>> aaa +3.0 +``` +### 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) +```py +>>> aaa = 5 +>>> aaa //= 2 +>>> aaa +2 + +>>> aaa = 5 +>>> aaa %= 2 +>>> aaa +1 + +>>> aaa=5 +>>> aaa **= 3 +>>> aaa +125 +``` +### 7.5. Множественное присваивание +```py +>>> w=v=10 +>>> n1,n2,n3=(11,-3,'all') + +>>> n1,n2,n3 +(11, -3, 'all') +>>> w,v +(10, 10) +``` +Задание: + +Самостоятельно проверьте, можно ли вместо кортежа справа использовать строку, список, словарь, множество? + +Ответ: + +Со списком работает поэлементно, со строками посимвольно, с множествами работает, но не в той очередности присваивания, со словарем работает, но нужно знать что присваивать - ключи либо значения + +## 8. Логические операции +### 8.1. Операции сравнения +```py +>>> 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 Создание больших логических выражений с использованием соединительных слов +```py +>>> a=17 +>>> b=-6 +>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1) +True +``` +Задание: + +Придумайте самостоятельно еще 2-3 примера сложных логических выражений. + +Ответ: +```py +>>> (a == b) and ('Vologda' in dic1) or ('Pskov' in dic1) +False +>>> (a > b) or 'book' in mnoz1 +True +>>> 'cap' in mnoz1 or a >= b +True +``` +### 8.4. Проверка ссылок переменных на один и тот же объект +```py +>>> w=v=10 +>>> w is v +True +>>> w1=['A','B'] +>>> v1=['A','B'] +>>> w1 is v1 +False +``` +Задание: + +Объясните результат + +Ответ: + +В начале присваивания двум переменным w и v значения 10 мы храним обе переменные в одной ячейке памяти, +затем мы по отдельности присвоили двум этим переменным списки, они хоть и одинаковые, но всё равно +переменные по отдельности претерпели изменения -> хранятся в разных ячейках памяти + +## 9. Операции с объектами, выполняемые с помощью методов +```py +>>> 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 Методы для работы со строками +```py +>>> stroka.find('пр') +5 +>>> stroka.find('пр') +5 +>>> stroka +'Микропроцессорная система управления' +>>> stroka.count("с") +4 +>>> stroka.replace(' у',' автоматического у') +'Микропроцессорная система автоматического управления' +>>> spis22=stroka.split(' ') +>>> spis22 +['Микропроцессорная', 'система', 'управления'] +>>> stroka.upper() +'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ' +>>> stroka3=" ".join(spis22) +>>> stroka3.partition("с") +('Микропроце', 'с', 'сорная система управления') +>>> stroka3.rpartition("с") +('Микропроцессорная си', 'с', 'тема управления') +>>> dont_shout_please = stroka.lower() +``` +```py +>>> strk1='Момент времени {}, значение = {}' +>>> strk1.format(1,89.7) +'Момент времени 1, значение = 89.7' +>>> strk2='Момент времени {1}, значение = {0}:{2}' +>>> strk2.format(36.7,2,'норма!') +'Момент времени 2, значение = 36.7:норма!' +# порядки расставлены так, как указаны индексы в строке strk2 - на позицию 0 ставится самый первый эл-нт передаваемый в format() и т.д. +``` +```py +>>> strk3='Момент времени {num}, значение = {znch}' +>>> strk3.format(znch=89.7,num=2) +'Момент времени 2, значение = 89.7' +``` +### 9.2. Методы для работы со списками. +```py +>>> spsk = [1, 'A-03-23', 5.0, (1, 2, 3), True] +>>> dir(spsk) +['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__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) +5.0 +>>> spsk +[1, 'A-03-23', (1, 2, 3), True] +>>> spsk.append('c') +>>> spsk +[1, 'A-03-23', (1, 2, 3), True, 'c'] +>>> spsk.insert(2,'a') +>>> spsk +[1, 'A-03-23', 'a', (1, 2, 3), True, 'c'] +>>> spsk.count('a') +1 +>>> spsk +[1, 'A-03-23', 'a', (1, 2, 3), True, 'c'] +``` +Задание: + +Проанализируйте смысл операций, выполненных с помощью этих методов + +Ответ: + +1) методом pop() удалили 2-ой эл-т списка (2-ой начиная с нуля) +2) добавили 'c' в конец списка (метод append() всегда добавляет элемент в конец списка) +3) методом insert() на позицию 2 (также начиная с нуля) вставили строку 'a' +4) методом count() посчитали количество вхождений элемента 'a' в список + +### 9.3. Самостоятельно создайте кортеж и изучите применение его методов. +```py +>>> my_tuple = ('str', 20, (1, 2, 3), True) +>>> my_tuple.count(20) +1 +>>> my_tuple.index(True) # позиция True в кортеже +3 +``` +### 9.4.Также самостоятельно изучите методы словарей и множеств. +**Словари** + +```py +>>> student = { + "name": "Viktor", + "age": 20, + "city": "Moscow", + "courses": ["Math", "Physics"], + "gpa": 2.85 +} +>>> student.get("name") +'Viktor' +>>> student.keys() +dict_keys(['name', 'age', 'city', 'courses', 'gpa']) +>>> student.values() +dict_values(['Viktor', 20, 'Moscow', ['Math', 'Physics'], 2.85]) +>>> student.update({"gpa": 4.5, "lazy": True}) +>>> student +{'name': 'Viktor', 'age': 20, 'city': 'Moscow', 'courses': ['Math', 'Physics'], 'gpa': 4.5, 'Lazy': True} +>>> student.pop("Lazy") +True +>>> student +{'name': 'Viktor', 'age': 20, 'city': 'Moscow', 'courses': ['Math', 'Physics'], 'gpa': 4.5} +>>> student.clear() +>>> student +{} +``` + +**Множества** + +```py +>>> A = {1, 2, 3, 4, 5} +>>> A.add(6) +>>> A +{1, 2, 3, 4, 5, 6} +>>> A.remove(6) +>>> A +{1, 2, 3, 4, 5} +>>> A.pop() +1 +>>> A +{2, 3, 4, 5} +>>> A.clear() +>>> A +set() +``` \ No newline at end of file From ab498611cf07a13bfaf84162faa6ce543f442633 Mon Sep 17 00:00:00 2001 From: byvs Date: Sun, 14 Sep 2025 20:51:48 +0300 Subject: [PATCH 2/2] task topic3 is done --- TEMA3/task.md | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 106 insertions(+) create mode 100644 TEMA3/task.md diff --git a/TEMA3/task.md b/TEMA3/task.md new file mode 100644 index 0000000..9ab2df6 --- /dev/null +++ b/TEMA3/task.md @@ -0,0 +1,106 @@ +# Общее контрольное задание по теме 3 + +Степанищев Виктор, А-03-23 + +## Задание +Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия: + +• Преобразовать восьмеричное значение 45 в целое число. + +• Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? + +• Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4. + +• Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. + +• Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка. + +• Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов. + +• Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. + +## Решение + +**1.** +```py +task1 = int('45', 8) +print(task1) +``` +Вывод +```py +37 +``` + + +**2.** +```py +D = {"усиление":23, "запаздывание":12, "постоянная времени":78} +D_keys, D_values = list(D.keys()), list(D.values()) +D_cort = tuple(D_keys + D_values) +print(D_cort) +``` +Вывод +```py +('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78) +``` +*Вопрос:* + +Чем отличается кортеж от списка? + +*Ответ:* + +Список изменяемый, кортеж неизменяемый + +**3.** +```py +task3 = ((1768 // 24.8) % 3)**2.4 +print(task3) +``` +Вывод +```py +5.278031643091577 +``` +**4.** +```py +task4 = (~(13 & 27)^14) << 2 +print(task4) +``` +Вывод +```py +-32 +``` +**5.** +```py +task5 = ['колебат', 'колебат', 'колебат', 'колебат'] +check = 'аткол' in (task5[2] + task5[3]) +print(check) +``` +Вывод +```py +True +``` +**6.** +```py +task6 = dir(D) +D_values, D_keys = D.values(), D.keys() +print(D_values) +print(D_keys) +``` +Вывод +```py +dict_values([23, 12, 78]) +dict_keys(['усиление', 'запаздывание', 'постоянная времени']) +``` +**7.** +```py +task7 = "Создать объект - символьную строку с текстом данного предложения" +only_words = task7.split(' ') +index_of_replace_symbol = only_words.index('-') +only_words[index_of_replace_symbol] = ',' +only_words.remove('данного') +print(only_words) +``` +Вывод +```py +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения'] +``` \ No newline at end of file