python-labs/TEMA3/lab3.md

Отчет

Тема 3.

Операции с объектами

Пункт 2.

Преобразование простых базисов типов объектов

2.1 Преобразование в логический тип с помощью функции bool(<Объект>)

>>>logiz1=bool(56)
>>>logiz1
True
>>>logiz2=bool(0)
>>>logiz2
False
>>>logiz3=bool("Beta")
>>>logiz3
True
>>>logiz4=bool("")
>>>logiz4
False

2.2 Преобразование в целое десятичное число

>>>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" содержит десятичную точку, поэтому возникает ошибка. Решить эту проблему можно так:

>>>tt5 = int(float("98.76"))
>>>tt5
98

2.3 Преобразование десятичных чисел в другие системы счисления

>>>hh=123
>>>dv1=bin(hh) #в двоичную сс
>>>dv1
'0b1111011'
>>>vos1=oct(hh) #в восьмеричную сс
>>>vos1
'0o173'
>>>shs1=hex(hh) #в шеснадцатеричную сс
>>>shs1
'0x7b'

Для проверки выполним обратные преобразования

>>>int (dv1,2)
123
>>int(vos1,8)
123
>>int(shs1,16)
123

Пункт 3.

Преобразование более сложных базовых типов объектов

3.1 Преобразование в строку символов с помощью функции str(<Объект>)

>>>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(<Объект>)

>>>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(<Объект>)

>>>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. Удаление объектов

>>>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
"('Ц', 'в', 'е', 'т', 'к', 'о', 'в', 'а', 'Т', 'А')"
>>> sttr = ''.join(k)
>>> sttr
'ЦветковаТА'

Пункт 4. Арифметические операции.

4.1. Сложение и вычитание (+ и -)

>>> 12+7+90
109
>>> 5.689e-1 - 0.456
0.11289999999999994
>>> 23.6+54
77.6
>>> 14-56.7+89
46.3

4.2. Умножение (*)

>>> -6.7*12
-80.4

4.3. Деление (/). Результатом деления всегда будет вещественное число!

>>> -234.5/6
-39.083333333333336
>>> a=178/45
>>> a
3.9555555555555557
>>> type(a)
<class 'float'>

4.4. Деление с округлением вниз (//). Здесь результат может быть целым или вещественным.

>>> b=178//45
>>> b
3
>>> type(b)
<class 'int'>
>>> c=-24.6//12.1
>>> c
-3.0
>>> type(c)
<class 'float'>

4.5. Получение остатка от деления (%).

>>> 148%33
16
>>> 12.6%3.8
1.2000000000000002
>>> 56.97%6
2.969999999999999

4.6. Возведение в степень (**).

>>> 14**3
2744
>>> e=2.7**3.6
>>> e
35.719843790663525
>>> d=2.7**3
>>> d
19.683000000000003

Попробуем проделать арифметические операции над комплексными числами. Создадим два комплексных числа

>>> 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)

>>> dv1=9
>>> dv2=~dv1
>>> dv2
-10

5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел

>>> 7&9
1
>>> 7&8
0

Проверим

>>> bin(7)
'0b111'
>>> bin(9)
'0b1001'
>>> bin(7&9)
'0b1'

5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0

>>> 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.

>>> 14^5  #1110 ^ 0101 = 1011
11
>>> bin(11)
'0b1011'
>>> bin(14)
'0b1110'
>>> bin(5)
'0b101'

5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.

>>> h=14
>>> bin(14)
'0b1110'
>>> g=h<<2
>>> bin(g)
'0b111000'
>>> g1=h>>1
>>> bin(g1)
'0b111'
>>> g2=h>>2
>>> bin(g2)
'0b11'

Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.

>>> 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. Объединение последовательностей (конкатенация)(+)

>>>'Система '+'регулирования'  #Соединение двух строк символов
'Система регулирования'
>>>['abc','de','fg']+['hi','jkl']  # Объединение двух списков
['abc', 'de', 'fg', 'hi', 'jkl']
>>>('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
('abc', 'de', 'fg', 'hi', 'jkl')

6.2 Повторение (*)

>>> 'ля-'*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)

>>> stroka='Система автоматического управления'
>>> 'автомат' in stroka
True
>>> 'ку' in ['ку','-']*3
True
>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')
False

6.4. Подстановка значений в строку с помощью оператора «%»

>>> 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
>>> zz%=5
>>> zz
4.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. Операции сравнение

>>> 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).

Операции с множеством

>>> 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. Создание больших логических выражений с использованием соединительных слов: логиче-ское «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not).

>>> 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).

>>> 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, например,

>>> 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. Методы для работы со строками

>>> 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

Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола.

>>> strk1='Момент времени {}, значение = {}'
>>> 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'

9.2. Методы для работы со списками.

>>> 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 Методы словарей

>>> d={'key1':1, 'key2':2,'key3':3,'key4':4}
Cоздание копии
```py
>>> d1=d.copy()
>>> d1
{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4}

Возвращение значения по ключу

>>> d.get('key3')
3

Возвращение кортежей из пар ключ-значение

>>> d.items() 
dict_items([('key1', 1), ('key2', 2), ('key3', 3), ('key4', 4)])

Возвращение объекта только из ключей

>>> d.keys() 
dict_keys(['key1', 'key2', 'key3', 'key4'])

Возвращение объекта только из значений

>>> d.values() 
dict_values([1, 2, 3, 4]) 

Добавление ключ-значения

>>> d['key5']=5 
>>> d
{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

Удаление ключ-значения

>>> d.pop('key1') 
1
>>> d
{'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

Очищение словаря

>>> d.clear()
>>> d
{}

Методы множеств

>>> mn={1,'dva',3.33}

Добавление элемента

>>> mn.add(4)
>>> mn
{1, 3.33, 4, 'dva'}

Создание копии

>>> cop=mn.copy()
>>> cop
{1, 3.33, 4, 'dva'}

Удаление элемента по значению

>>> mn.remove(1)
>>> mn
{3.33, 4, 'dva'}

Удаление элемента по значению

>>> mn.discard('dva')
>>> mn
{3.33, 4}

Очищение множества

>>> mn.clear()
>>> mn
set()

Удаление и возвращение случайного элемента из множества

>>> cop.pop()
1
>>> cop
{3.33, 4, 'dva'}

Добавление элементов

>>> cop.update({False,'t'})
>>> cop
{False, 3.33, 4, 't', 'dva'}

Общее контрольное задание

Преобразовать восьмеричное значение 45 в целое число.

>>> octv = '45'
>>> decv = int(octv, 8)
>>> decv
37

Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?

>>> 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.

>>> ((1768 // 24.8) % 3) ** 2.4
5.278031643091577

Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.

>>> ((~(13 & 27)) ^ 14) << 2
-32

Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.

>>> lst = ["колебат"] * 4
>>> lst[1] += lst[2]
>>> lst
['колебат', 'колебатколебат', 'колебат', 'колебат']
>>> lst.pop(2)
'колебат'
>>> lst
['колебат', 'колебатколебат', 'колебат']
>>> 'аткол' in lst[1]
True

Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.

>>> 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 особые объекты, которые ссылаются на элементы исходного словаря.

Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список.

>>> sen = "Создать объект - символьную строку с текстом данного предложения"
>>> senl = sen.split()
>>> senl
['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
>>> senl[senl.index("-")] = ","
>>> senl
['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения']
>>> senl.remove("данного")
>>> senl
['Создать', 'объект', ';', 'символьную', 'строку', 'с', 'текстом', 'предложения']