# Отчет
## Тема 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 "<pyshell#34>", line 1, in <module>
    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']
```
Создадим строку со своей фамилией и инициалами, преобразуем её в список, затем список – в кортеж и, наконец, кортеж – в строку. 
```py
>>> f= 'ЦветковаТА'
>>> spis= list(f)
>>> spis
['Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А']
>>> k=tuple(spis)
>>> k
('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')
>>> kk=str(k)
>>> kk
"('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')"
>>> sttr = ''.join(k)
>>> sttr
'ЦветковаТА'
```
## Пункт 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)
<class 'float'>
```
## 4.4. Деление с округлением вниз (//). Здесь результат может быть целым или вещественным. 
```py
>>> b=178//45
>>> b
3
>>> type(b)
<class 'int'>
>>> c=-24.6//12.1
>>> c
-3.0
>>> type(c)
<class 'float'>
```
## 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 "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
>>>k1//2
Traceback (most recent call last):
  File "<pyshell#115>", line 1, in <module>
    k1//2
TypeError: unsupported operand type(s) for //: 'complex' and 'int'
>>> k1%k2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
>>>k1%2
TypeError: unsupported operand type(s) for %: 'complex' and 'int'

```
## Пункт 5. Операции с двоичными представлениями целых чисел.

## 5.1 Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0)
```py
>>> dv1=9
>>> dv2=~dv1
>>> dv2
-10
```
## 5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
```py
>>> 7&9
1
>>> 7&8
0
```
Проверим 
```py
>>> bin(7)
'0b111'
>>> bin(9)
'0b1001'
>>> bin(7&9)
'0b1'
```
## 5.3  Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
```py
>>> 7|9  # 0111 или 1001 = 1111
15
>>> 7|8 # 0111 или 1000 = 1111

15
>>> 14|5 # 1110 или 0101 = 1111
15
>>> bin(15)
'0b1111'
```
## 5.4.	Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
```py
>>> 14^5  #1110 ^ 0101 = 1011
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. Обычное присваивание значения переменной (=)
```py
>>> zz=-12
```
## 7.2.	Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
```py
>>> zz+=5
>>> zz
-7
>>> zz-=3
>>> zz
-10
>>> stroka='Система'
>>> stroka+=' регулирования'
>>> stroka
'Система регулирования'
```
## 7.3.	 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
```py
>>> zz/=2
>>> zz
-5.0
>>> zz*=5
>>> zz
-25.0
```
## 7.4.	Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) 
```py
>>> zz//=2
>>> zz
-13.0
>>> zz**=2
>>> zz
169.0
>>> zz%=5
>>> zz
4.0
```
## 7.5. Множественное присваивание
Присваивание одного значения нескольким переменным 
```py
>>> w=v=10
>>> w
10
>>> v
10
```
Присваивание кортежа
```py
>>> n1,n2,n3=(11,-3,'all')
>>> n1,n2,n3
(11, -3, 'all')
```
Присваивание списка 
```py
>>> a1,a2,a3=[1,2,3]
>>> a1,a2,a3
(1, 2, 3)
```
Присваивание словаря 
```py
>>> s1,s2,s3={'один':1,'два':2,'три':3}
>>> s1,s2,s3
('один', 'два', 'три')
```
Если необходимо присвоить значения, то это можно сделать через .values()
```py
>>> s1,s2,s3={'один':1,'два':2,'три':3}.values()
>>> s1,s2,s3
(1, 2, 3)
```
Если необходимо присвоить ключи и значения, то это можно сделать через .items()
```py
>>> f1,f2,f3={'один':1,'два':2,'три':3}.items()
>>> f1,f2,f3
(('один', 1), ('два', 2), ('три', 3))
>>> f1
('один', 1)
>>> f2
('два', 2)
>>> f3
('три', 3)
```
Присваивание множества
```py
>>> m1,m2,m3={0,89,6}
>>> m1,m2,m3
(0, 89, 6)
```
Присваивание строки
```py
>>> 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<w
False
>>> 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 "<stdin>", line 1, in <module>
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
['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']
```