From 018b00b0d8c0c679f83fe709433c0d50b71a0dba Mon Sep 17 00:00:00 2001 From: Tsvetkova Tatyana Date: Sun, 28 Sep 2025 14:16:01 +0300 Subject: [PATCH] lab3 --- TEMA3/lab3.md | 771 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 771 insertions(+) create mode 100644 TEMA3/lab3.md diff --git a/TEMA3/lab3.md b/TEMA3/lab3.md new file mode 100644 index 0000000..27d9142 --- /dev/null +++ b/TEMA3/lab3.md @@ -0,0 +1,771 @@ +# Отчет +## Тема 3. +Операции с объектами +## Пункт 2. +Преобразование простых базисов типов объектов +## 2.1 Преобразование в логический тип с помощью функции bool(<Объект>) +```py +>>>logiz1=bool(56) +>>>logiz1 +True +>>>logiz2=bool(0) +>>>logiz2 +False +>>>logiz3=bool("Beta") +>>>logiz3 +True +>>>logiz4=bool("") +>>>logiz4 +False +``` +## 2.2 Преобразование в целое десятичное число +```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' +``` +Функция int() может преобразовывать в целое число только строки, которые содержат целое число (например, "98"). Строка "98.76" содержит десятичную точку, поэтому возникает ошибка. +Решить эту проблему можно так: +```py +>>>tt5 = int(float("98.76")) +>>>tt5 +98 +``` +## 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 +>>>strk=str(23.6) +>>>strk +'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 Преобразование элементов объекта в список с помощью функции 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'] +>>> spis4 = list({"A":1,"B":2,"C":9}.values()) +>>> spis4 +[1, 2, 9] +``` +## 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') +>>> kort9 = tuple(({"A":1,"B":2,"C":9}.values())) +>>> kort9 +(1, 2, 9) +``` +## 3.4. Удаление объектов +```py +>>>del strk5, kort8 +Проверим +>>>dir() +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1'] +Создадим строку со своей фамилией и инициалами, преобразуем её в список, затем список – в кортеж и, наконец, кортеж – в строку. +>>> f= 'ЦветковаТА' +>>> spis= list(f) +>>> spis +['Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А'] +>>> k=tuple(spis) +>>> k +('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А') +>>> kk=str(k) +>>> kk +"('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')" +``` +## Пункт 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) + +``` +## 4.5. Получение остатка от деления (%). +```py +>>> 148%33 +16 +>>> 12.6%3.8 +1.2000000000000002 +>>> 56.97%6 +2.969999999999999 +``` +## 4.6. Возведение в степень (**). +```py +>>> 14**3 +2744 +>>> e=2.7**3.6 +>>> e +35.719843790663525 +>>> d=2.7**3 +>>> d +19.683000000000003 +``` +Попробуем проделать арифметические операции над комплексными числами. Создадим два +комплексных числа +```py +>>> k1=(2+1j) +>>> k2=(1+2j) +>>> k1+k2 +(3+3j) +>>> k2-k1 +(-1+1j) +>>> k1*k2 +5j +>>> k1/k2 +(0.8-0.6j) +>>> k1**k2 +(-0.42589434775182566+0.7753703444218832j) +>>> k1//k2 +Traceback (most recent call last): + File "", line 1, in +TypeError: unsupported operand type(s) for //: 'complex' and 'complex' +>>> k1%k2 +Traceback (most recent call last): + File "", line 1, in +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' + +``` +## Пункт 5. Операции с двоичными представлениями целых чисел. + +## 5.1 Двоичная инверсия (~) +```py + dv1=9 +>>> dv2=~dv1 +>>> dv2 +-10 +``` +##5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел +```py +>>> 7&9 +1 +>>> 7&8 +0 +``` +Проверим +```py +>>> bin(7) +'0b111' +>>> bin(8) +'0b1000' +>>> bin(7&9) +'0b1' +``` +## 5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0 +```py +>>> 7|9 +15 +>>> 7|8 +15 +>>> 14|5 +15 +>>> bin(15) +'0b1111' +``` +## 5.4. Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1. +```py +>>> 14^5 +11 +>>> bin(11) +'0b1011' +>>> bin(14) +'0b1110' +>>> bin(5) +'0b101' +``` +## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева. +```py +>>> h=14 +>>> bin(14) +'0b1110' +>>> g=h<<2 +>>> bin(g) +'0b111000' +>>> g1=h>>1 +>>> bin(g1) +'0b111' +>>> g2=h>>2 +>>> bin(g2) +'0b11' +``` +Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции. +```py +>>> bin(76) +'0b1001100' +>>> bin(112) +'0b1110000' +>>> 76&112 +64 +>>> bin(64) +'0b1000000' +>>> 76|112 +124 +>>> bin(124) +'0b1111100' +>>> 76^112 +60 +>>> g=76<<2 +>>> g +304 +>>> bin(g) +'0b100110000' +``` +## 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. Проверка наличия заданного элемента в последовательности (in) +```py +>>> stroka='Система автоматического управления' +>>> 'автомат' in stroka +True +>>> 'ку' in ['ку','-']*3 +True +>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') +False +``` +## 6.4. Подстановка значений в строку с помощью оператора «%» +```py +>>> stroka='Температура=%g %s %g' +>>> stroka +'Температура=%g %s %g' +>>> stroka % (16,' меньше ',25) +'Температура=16 меньше 25' +>>> stroka % (66,' меньше ',77) +'Температура=66 меньше 77' +>>> stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' +>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25} +'Температура = 16 меньше 25' +``` +## 7. Оператор присваивания +## 7.1. Обычное присваивание значения переменной (=) +>>> zz=-12 +## 7.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=) +>>> zz+=5 +>>> zz +-7 +>>> zz-=3 +>>> zz +-10 +>>> stroka='Система' +>>> stroka+=' регулирования' +>>> stroka +'Система регулирования' +## 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=) +>>> zz/=2 +>>> zz +-5.0 +>>> zz*=5 +>>> zz +-25.0 +## 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) +>>> zz//=2 +>>> zz +-13.0 +>>> zz**=2 +>>> zz +169.0 +## 7.5. Множественное присваивание +Присваивание одного значения нескольким переменным +>>> w=v=10 +>>> w +10 +>>> v +10 +Присваивание кортежа +>>> n1,n2,n3=(11,-3,'all') +>>> n1,n2,n3 +(11, -3, 'all') +Присваивание списка +>>> a1,a2,a3=[1,2,3] +>>> a1,a2,a3 +(1, 2, 3) +Присваивание словаря +>>> s1,s2,s3={'один':1,'два':2,'три':3} +>>> s1,s2,s3 +('один', 'два', 'три') +Если необходимо присвоить значения, то это можно сделать через .values() +>>> s1,s2,s3={'один':1,'два':2,'три':3}.values() +>>> s1,s2,s3 +(1, 2, 3) +Если необходимо присвоить ключи и значения, то это можно сделать через .items() +>>> f1,f2,f3={'один':1,'два':2,'три':3}.items() +>>> f1,f2,f3 +(('один', 1), ('два', 2), ('три', 3)) +>>> f1 +('один', 1) +>>> f2 +('два', 2) +>>> f3 +('три', 3) +Присваивание множества +>>> m1,m2,m3={0,89,6} +>>> m1,m2,m3 +(0, 89, 6) +Присваивание строки +>>> c1,c2,c3='1','2','3' +>>> c1,c2,c3 +('1', '2', '3') +## 8. Логические операции (True или False) +## 8.1. Операции сравнение +```py +>>> v==w +True +>>> v!=w +False +>>> v>w +False +>>> v>> v>=w +True +>>> v<=w +True +>>> 5==4 +False +>>> 5!=4 +True +>>> 5>4 +True +>>> 5<4 +False +>>> 5>=4 +True +>>> 5<=4 +False +``` +## 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 +``` +Ещё пример работы со словарем: +```py +>>> 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==4)or(a==17) +True +>>> (5==4)and(a==17) +False +>>> ((5==4)and(a==17))or(not(5==4)and(a==17)) +True +## 8.4. Проверка ссылок переменных на один и тот же объект (is). +```py +>>> w=v=10 +>>> w1=['A','B'] +>>> v1=['A','B'] +>>> w1==v2 +Traceback (most recent call last): + File "", line 1, in +NameError: name 'v2' is not defined. Did you mean: 'v'? +>>> w1==v1 +True +>>> w1 is v1 +False +>>> w is v +True +``` +Оператор is сравнивает адреса объектов в памяти. Целые числа из одной строки хранятся по одному адресу, поэтому is возвращает True. Словари же, созданные отдельно, размещаются в разных местах памяти, и is для них дает False. +## Пункт 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. Методы для работы со строками +```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("с") #Возвращает кортеж с результатами поиска «с» справа +('Микропроцессорная си', 'с', 'тема управления') +``` +## Mетод format +Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола. +```py +>>> strk1='Момент времени {}, значение = {}' +>>> strk1 +'Момент времени {}, значение = {}' +>>> strk1.format(1,89.7) +'Момент времени 1, значение = 89.7' +>>> strk2='Момент времени {1}, значение = {0}:{2}' +``` +Здесь цифры в фигурных скобках – это индексы, определяющие порядок использования аргумен-тов формата. Поэтому такой способ называют основанным на позиционных аргументах. Например, +```py +>>> strk2.format(36.7,2,'норма!') +'Момент времени 2, значение = 36.7:норма!' +>>> strk3='Момент времени {num}, значение = {znch}' +``` +Здесь в скобках указаны имена аргументов – вставок. Поэтому такой способ основан на имено-ванных аргументах. +```py +>>> strk3.format(znch=89.7,num=2) +'Момент времени 2, значение = 89.7' +``` +## 9.2. Методы для работы со списками. +```py +>>> spsk = [1, (2, 3), 'hello Sergey Alexandrovich', 3.14 , 'pi'] +>>> spsk.pop(2) #Удаление элемента по индексу +'hello Sergey Alexandrovich' +>>> spsk.append('c') #Вставка элемента в конец +>>> spsk +[1, (2, 3), 3.14, 'pi', 'c'] +>>> spsk.insert(2,'a') #Вставка элемента в конкретное место по индексу +>>> spsk +[1, (2, 3), 'a', 3.14, 'pi', 'c'] +>>> spsk.count('a') #Подсчет количества элементов по значению +1 +## 9.3. Mетоды кортежей +У кортежей методов меньше, тк он являетя неизменяемым и методов на добавление/удаление объекта - нет +```py +>>> km2=(5,'пять', 5.55, 'мопсикии',4+1j) +>>> km2.count(5) +1 +>>> km2.index('мопсикии') +3 +``` +## 9.4 Методы словарей +```py +>>> d={'key1':1, 'key2':2,'key3':3,'key4':4} +Cоздание копии +```py +>>> d1=d.copy() +>>> d1 +{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4} +``` +Возвращение значения по ключу +```py +>>> d.get('key3') +3 +``` +Возвращение кортежей из пар ключ-значение +```py +>>> d.items() +dict_items([('key1', 1), ('key2', 2), ('key3', 3), ('key4', 4)]) +``` +Возвращение объекта только из ключей +```py +>>> d.keys() +dict_keys(['key1', 'key2', 'key3', 'key4']) +``` +Возвращение объекта только из значений +```py +>>> d.values() +dict_values([1, 2, 3, 4]) +``` +Добавление ключ-значения +```py +>>> d['key5']=5 +>>> d +{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5} +``` +Удаление ключ-значения +```py +>>> d.pop('key1') +1 +>>> d +{'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5} +``` +Очищение словаря +```py +>>> d.clear() +>>> d +{} +``` + +## Методы множеств + +```py +>>> mn={1,'dva',3.33} +``` +Добавление элемента +```py +>>> mn.add(4) +>>> mn +{1, 3.33, 4, 'dva'} +``` +Создание копии +```py +>>> cop=mn.copy() +>>> cop +{1, 3.33, 4, 'dva'} +``` +Удаление элемента по значению +```py +>>> mn.remove(1) +>>> mn +{3.33, 4, 'dva'} +``` +Удаление элемента по значению +```py +>>> mn.discard('dva') +>>> mn +{3.33, 4} +``` +Очищение множества +```py +>>> mn.clear() +>>> mn +set() +``` +Удаление и возвращение случайного элемента из множества +```py +>>> cop.pop() +1 +>>> cop +{3.33, 4, 'dva'} +``` +Добавление элементов +```py +>>> cop.update({False,'t'}) +>>> cop +{False, 3.33, 4, 't', 'dva'} +``` + +#Общее контрольное задание +Преобразовать восьмеричное значение 45 в целое число. +```py + +>>> octv = '45' +>>> decv = int(octv, 8) +>>> decv +37 +``` +Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, +"постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и +значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж +от списка? +```py +>>> D = {"усиление": 23, "запаздывание": 12, "постоянная времени": 78} +>>> keyD = list(D.keys()) +>>> keyD +['усиление', 'запаздывание', 'постоянная времени'] +>>> valD = list(D.values()) +>>> valD +[23, 12, 78] +>>> tupD = (keyD, valD) +>>> tupD +(['усиление', 'запаздывание', 'постоянная времени'], [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 +>>> lst = ["колебат"] * 4 +>>> lst[1] += lst[2] +>>> lst +['колебат', 'колебатколебат', 'колебат', 'колебат'] +>>> lst.pop(2) +'колебат' +>>> lst +['колебат', 'колебатколебат', 'колебат'] +>>> 'аткол' in lst[1] +True +``` + Определить список методов, доступных у ранее созданного словаря D. Поочередно +использовать его методы keys и values, определить, что можно получить с применением +этих методов. +```py +>>> D +{'усиление': 23, 'запаздывание': 12, 'постоянная времени': 78} +>>> dir(D) +['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', + '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', + '__getitem__', '__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]) +``` +#dict_keys и dict_values особые объекты, которые ссылаются на элементы исходного словаря. + + Создать объект - символьную строку с текстом данного предложения. Из символьной строки +создать список, элементами которого будут отдельные слова из созданной строки. Заменить в +списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить +получившийся список. +```py +>>> sen = "Создать объект - символьную строку с текстом данного предложения" +>>> senl = sen.split() +>>> senl +['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения'] +>>> senl[senl.index("-")] = "," +>>> senl +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения'] +>>> senl.remove("данного") +>>> senl +['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения'] +``` \ No newline at end of file