Отчет по теме3

4 дней назад · 2f2a816994
--- a/TEMA3/task.md
+++ b/TEMA3/task.md
@ -0,0 +1,60 @@
 # Общее контрольное задание по теме 3
 ## Задание
 Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия:
 - Преобразовать восьмеричное значение 45 в целое число.
 - Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка?
 - Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4.
 - Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево.
 - Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка.
 - Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов.
 - Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки.  Заменить в списке элемент «-» на «,».  Удалить из списка элемент со значением  «данного». Отобразить получившийся список.
 ## Решение
 ```
 >>>celoe = int(vosm, 8)       
 >>>celoe         
 37
 >>>D = {"усиление":23, "запаздывание":12, "постоянная времени":78}       
 >>>spisok_klychey = list(D.keys())        
 >>>spisok_klychey          
 ['усиление', 'запаздывание', 'постоянная времени']
 >>>spisok_znach = list(D.values())          
 >>>spisok_znach         
 [23, 12, 78]
 >>>obsh_kort = tuple(spisok_klychey + spisok_znach)        
 >>>obsh_kort       
 ('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78)
 >>>dir(obsh_kort)        
 ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
 >>>result1 = ((1768 // 24.8) % 3) ** 2.4
 5.278031643091577
 >>>result2 = (~(13 & 27) ^ 14) << 2        
 >>>result2        
 -32
 >>>spisok_kolebat = ['колебат'] * 4        
 >>>spisok_kolebat          
 ['колебат', 'колебат', 'колебат', 'колебат']
 >>>komb = spisok_kolebat[1] +  spisok_kolebat[2]        
 >>>komb        
 'колебатколебат'
 >>>'аткол' in komb       
 True
 >>>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]) #Получаем список значений
 >>>obj = "Создать объект - символьную строку с текстом данного предложения."          
 >>>obj_l = obj.split()        
 >>>obj_l        
 ['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']3
 >>>obj_l[obj_l.index("-")] = ","        
 obj_l       
 ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']
 >>>obj_l.remove("данного")        
 >>>obj_l     
 ['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.']
 ```
--- a/TEMA3/Отчет
+++ b/TEMA3/Отчет
@ -0,0 +1,867 @@
 # Бушманов Артём, А-01-23
 ## 1. Запуск IDLE
 ## 2. Преобразование простых базовых типов объектов.
 ### 2.1.  Преобразование в логический тип с помощью функции bool(<Объект>).
 Примеры использования:
 ```
 >>>logiz1 = bool(56)
 >>>logiz1
 True
 >>>logiz2 = bool(0)
 >>>logiz2
 False
 >>>logiz3 = bool("Beta")
 >>>logiz3
 True
 >>>logiz4 = bool(" ")
 >>>logiz4
 True
 ```
 ### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления. осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.
 Примеры использования:
 ``` 
 >>>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#16>", line 1, in <module>
    tt5 = int("98,76")
 ValueError: invalid literal for int() with base 10: '98,76'
 ```
 Как видно, выводится диагностическое сообщение. Выводится оно по причине того, что заданное число вещественное(float), а ожидается значение типа "int".
 Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>).
 Примеры преобразований:
 ```
 >>>flt1 = float(789)
 >>>flt1
 789.0
 >>>flt2 = float(-6.78e2)
 >>>flt2
 -678.0
 >>>flt3 = float("Infinity")
 >>>flt3
 inf
 >>>flt4 = float("-inf")
 >>>flt4
 -inf
 ```
 ### 2.3.  Преобразование десятичных чисел в другие системы счисления:
 ```
 >>>hh=123
 >>>hh
 123
 >>>dv1=bin(hh)   #Преобразование в строку с двоичным представлением
 >>>dv1
 '0b1111011'
 >>>vos1=oct(hh)   # Преобразование в строку с восьмеричным представлением
 >>>vos1
 '0o173'
 >>>shs1=hex(hh)   # Преобразование в строку с шестнадцатеричным представлением
 >>>shs1
 '0x7b'
 ```
 Выполним обратные преобразования объектов dv1, vos1, shs1:
 ```
 >>>int(dv1,2)
 123
 >>>int(vos1, 8)
 123
 >>>int(shs1, 16)
 123
 ```
 ## 3. Преобразования более сложных базовых типов объектов.
 ### 3.1.  Преобразование в строку символов с помощью функции str(<Объект>).
 Примеры использования:
 ```
 >>>strk1 = str(23.6)
 >>>strk1
 '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')
 ```
 ### 3.4. Удаление объектов.
 Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del.
 Пример:
 ```
 >>>del strk5, kort8
 >>>strk5        
 Traceback (most recent call last):
  File "<pyshell#77>", line 1, in <module>
    strk5
 NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
 >>>kort8           
 Traceback (most recent call last):
  File "<pyshell#78>", line 1, in <module>
    kort8
 NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
 ```
 Создание строки со своей фамилией и инициалами, преобразование её в список, затем список – в кортеж и, наконец, кортеж – в строку. .
 ```
 >>>fam = list('Bushmanov')
 >>>fam
 ['B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v']
 >>>kort = tuple(fam)
 >>>kort
 ('B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v')
 >>>strk = str(kort)
 >>>strk
 "('B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v')"
 ```
 ## 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!
 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'>
 >>>zz1 = 78.4 / 16            
 >>>zz1             
 4.9
 >>>type(zz1)     
 <class 'float'>
 >>>zz2 = 78.4 // 16         
 >>>zz2           
 4.0
 >>>type(zz2)   
 <class 'float'>
 >>>zz3 = 78 // 16           
 >>>zz3          
 4
 >>>type(zz3) 
 <class 'int'>
 ```
 ### 4.5.  Получение остатка от деления (%).
 ```
 >>>148 % 33   #Остаток от деления двух целых чисел
 16
 >>>12.6 % 3.8  #Остаток от деления двух вещественных чисел
 1.2000000000000002
 1.2000000000000002
 >>>36 % 12            
 0
 >>>36.98 % 23.56            
 >>>13.419999999999998
 ```
 ### 4.6.  Возведение в степень (**). 
 ```
 >>>14**3  
 2744
 >>>e=2.7**3.6  #Вещественное число возводится в вещественную степень
 >>>e           
 35.719843790663525
 ```
 Попробуем проделать арифметические операции над комплексными числами. Создадим два
 комплексных числа.
 ```
 >>>comp1 = (5 + 3j)     
 >>>comp1      
 (5+3j)
 >>>type(comp1)          
 <class 'complex'>
 >>>comp2 = (10 - 5j)            
 >>>comp2             
 (10-5j)
 >>>type(comp2)  
 <class 'complex'>
 ```
 Сложение:
 ```
 >>>comp1 + comp2             
 (15-2j)
 ```
 Вычитание:
 ```
 >>>comp1 - comp2           
 (-5+8j)
 ```
 Умножение:
 ```
 >>>comp1 * comp2           
 (65+5j)
 ```
 Деление:
 ```
 >>>comp1 / comp2            
 (0.28+0.44j)
 ```
 Целочисленное деление:
 ```
 >>>comp1 // comp2      
 Traceback (most recent call last):
  File "<pyshell#129>", line 1, in <module>
    comp1 // comp2
 TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
 >>>comp1 // 2          
 Traceback (most recent call last):
  File "<pyshell#130>", line 1, in <module>
    comp1 // 2
 TypeError: unsupported operand type(s) for //: 'complex' and 'int'
 ```
 Как видим, целочисленное деление нельзя применять к комплексным числам.
 Взятие остатка от деления:
 ```
 >>>comp1 % comp2
 Traceback (most recent call last):
  File "<pyshell#131>", line 1, in <module>
    comp1 % comp2
 TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
 >>>comp1 % 2      
 Traceback (most recent call last):
  File "<pyshell#132>", line 1, in <module>
    comp1 % 2
 TypeError: unsupported operand type(s) for %: 'complex' and 'int'
 ```
 Как видим, взятие остатка от деления нельзя применять к комплексным числам.
 Возведение в степень:
 ```
 >>>comp1 ** comp2           
 (-652921189.7700557+180781145.7454619j)
 >>>comp1**5      
 (-6100+2868j)
 ```
 ## 5. Операции с двоичными представлениями целых чисел.
 ### 5.1.  Двоичная инверсия (~).
 Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
 ```
 >>>dv1 = 9          
 >>>dv2 = ~dv1            
 >>>dv2            
 -10
 >>>bin(dv1)          
 '0b1001'
 >>>bin(dv2)          
 '-0b1010'
 ```
 ### 5.2.  Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
 ```
 >>>bin(7&9)            
 '0b1'
 ```
 Совпадение единиц только в первом разряде, поэтому итог - 0001 или просто 1
 ```
 >>>bin(7&8)          
 '0b0'
 ```
 Совпадений единиц нет, итог - 0000 или просто 0
 ### 5.3.  Двоичное «ИЛИ» (|) 
 Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
 ```
 bin(7|9)     # 111 или 1001 = 1111
 '0b1111'
 bin(7|8)     # 111 или 1000 = 1111
 '0b1111'
 bin(14|5)   # 1110 или 0101 = 1111
 '0b1111'
 ```
 ### 5.4. Двоичное «исключающее ИЛИ»(^) 
 Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
 ```
 >>>bin(14^5)  # 1110 исключающее или 0101 = 1011
 '0b1011'
 ```
 Значение в десятичном представление:
 ```
 >>>14^5        
 11
 ```
 ### 5.5.  Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
 ```
 >>>h=14   #Двоичное представление = 1110
 >>>bin(h)          
 '0b1110'
 >>>g=h<<2  # Новое двоичное представление = 111000
 >>>g            
 56
 bin(g)  
 '0b111000'
 >>>g1=h>>1  # Новое двоичное представление = 0111
 >>>g1           
 7
 bin(g1)           
 '0b111'
 >>>g2=h>>2  # Новое двоичное представление = 0011
 >>>g2            
 3
 bin(g2)             
 '0b11'
 ```
 Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции.
 Возьмем два двоичных числа:
 1011001 (в десятичной системе это 89)
 10001001 (в десятичной системе это 137)
 1. Двоичная инверсия
 ```
 >>>~89            
 -90
 >>>bin(~89)         
 '-0b1011010'
 ```
 2. Двоичное "И"
 ```
 >>>bin(89 & 137)            
 '0b1001'
 ```
 3. Двоичное "ИЛИ"
 ```
 >>>bin(89 | 137)            
 '0b11011001'
 ```
 4. Двоичное "исключающее ИЛИ"
 ```
 >>>bin(89^137)             
 '0b11010000'
 ```
 5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
 ```
 >>>89 >> 2             
 22
 >>>bin(89 >> 2)             
 '0b10110'
 >>>137 << 3            
 1096
 >>>bin(137 << 3)          
 '0b10001001000'
 ```
 ## 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   #Повторение строки 5 раз
 'ля-ля-ля-ля-ля-'
 >>>['ку','-']*3 #Повторение списка 3 раза
 ['ку', '-', 'ку', '-', 'ку', '-']
 >>>('кис','-')*4  #Повторение кортежа 4 раза
 ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
 ```
 Создание списка со 100 отсчетами сигнала-ступеньки:
 ```
 >>>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'
 'Температура =  %g %s  %g'
 >>>stroka % (16,' меньше ',25)
 'Температура =  %g %s  %g'
 ```
 Вставка с использованием данных из словаря.
 ```
 >>>stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
 >>>stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
 'Температура = 16 меньше  25'
 ```
 ## 7. Оператор присваивания
 ### 7.1.  Обычное присваивание значения переменной (=)
 ```
 >>>zz=-12
 >>>zz
 -12
 ```
 ### 7.2. Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
 ```
 >>>zz+=5   # Значение zz увеличивается на 5
 >>>zz
 -7
 >>>zz-=3  # Значение уменьшается на 3
 >>>zz
 -10
 ```
 Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
 ```
 >>>stroka = 'Система'  
 >>>stroka
 'Система'           
 >>>stroka += ' регулирования'              
 >>>stroka            
 'Система регулирования'
 ```
 ### 7.3.  Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
 ```
 >>>zz /= 2             
 >>>zz             
 -5.0
 >>>zz*= 5            
 >>>zz             
 -25.0
 >>>per = 2          
 >>>per*=10          
 >>>per            
 20
 ```
 ### 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=).
 ```
 >>>zz //= 2             
 >>>zz             
 -13.0
 >>>zz %= -2             
 >>>zz             
 -1.0
 >>>per **= 4            
 >>>per              
 160000
 ```
 ### 7.5.  Множественное присваивание
    w=v=10  # Переменным присваивается одно и то же значение
    n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
 Самостоятельно проверьте, можно ли вместо кортежа справа использовать строку, список, словарь, множество?
 1) Присваивание одного значения двум переменным
 ```
 >>>w = v =10              
 >>>w, v            
 (10, 10)
 ```
 2) Присваивание кортежем 
 ```
 n1, n2, n3 = (11, -3, 'all')            
 n1, n2, n3            
 (11, -3, 'all')
 ```
 3) Присваивание строкой
 ```
 >>>a1, a2, a3 = 'red', 'black' , 'blue'         
 >>>a1, a2, a3         
 ('red', 'black', 'blue')
 ```
 4) Присваивание списком
 ```
 >>>b1, b2, b3 = ["s", 67, None]            
 >>>b1, b2, b3            
 ('s', 67, None)
 >>>b3         
 >>>type(b3)       
 <class 'NoneType'>
 ```
 5) Присваивание словарем
 ```
 >>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3}      
 >>>c1, c2, c3             
 ('one', 'two', 'three')
 ```
 По умолчанию в словарях итерируются именно ключи. Если нужно задать значения, надо
 указать дополнительно ".value":
 ```
 >>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3}.values()       
 >>>c1, c2, c3         
 (1, 2, 3)
 ```
 Если в каждую переменную надо положить именно и ключ, и значение одновременно, можно
 использовать метод .items(), который каждую пару(ключ-значение) распределяет в отдельный
 кортеж
 ```
 >>>d1, d2, d3 = {"one": 1, "two": 2, "three": 3}.items()              
 >>>d1            
 ('one', 1)
 >>>d2             
 ('two', 2)
 >>>d3             
 ('three', 3)
 ```
 6) Присваивание множеством
 ```
 >>>m1, m2, m3 = {100, 23, 59}            
 >>>m1, m2, m3             
 (59, 100, 23)
 ```
 ## 8. Логические операции 
 ### 8.1.  Операции сравнение: равенство (= =), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) 
 ```
 >>>w == v          
 True
 >>>w != v            
 False
 >>>w < v             
 False
 >>>w > v             
 False
 >>>w >= v             
 True
 ```
 Другие примеры:
 ```
 >>>0 == False             
 True
 >>>0 == True            
 False
 >>>100 != 1000          
 True
 >>>1200 > 100          
 True
 >>>1200 < 1000            
 False
 >>>1200 >= 1000           
 True
 ```
 ### 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']}
 >>>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
 ```
 Собственные примеры:
 ```
 >>>((145) in dic1.values()) and not  ('Rostov' in dic1)             
 True
 >>>not(len(dic1) == 3) or (sum(dic1.values()) > 300) or ('ITAE' in dct1['Depart'])          
 False
 ```
 ### 8.4. Проверка ссылок переменных на один и тот же объект (is).
 w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
 ```
 >>>w is v
 True
 >>>w1 = ['A', 'B']
 >>>v1 = ['A', 'B']
 >>>w1 is v1  
 ```
 Но при этом:
 ```      
 False
 >>>w1 == v1          
 True
 ```
 Основная разница "= =" и "is":
 - is проверяет, являются ли две переменные ссылками на один и тот же объект в памяти
 - == проверяет, равны ли значения объектов (содержимое одинаковое)
 Переменные целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти. `Словари были созданы в разных строках, и адреса разные, т.е. они ссылаются на разные участки в памяти, поэтому is возвращает False.
 ## 9. Операции с объектами, выполняемые с помощью методов.
 Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например,
 ```
 >>>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. Методы для работы со строками.
 ``` 
 >>>stroka.find('пр')   #Возвращает номер позиции первого вхождения указанного контекста или значение -1
 5
 >>>stroka.count("с")  #Подсчет числа вхождений строки “с” в stroka
 4
 >>>stroka.replace(' у',' автоматического у')
 'Микропроцессорная система автоматического управления'
 >>>spis22=stroka.split(' ')  #Возвращает список подстрок, между которыми в строке стоит  заданный разделитель
 >>>spis22           
 ['Микропроцессорная', 'система', 'управления']
 >>>stroka.upper()   #Возвращает строку со всеми заглавными буквами
 >>>stroka3=" ".join(spis22)  #Возвращает строку, собранную из элементов списка
 >>>stroka3         
 'Микропроцессорная система управления'
 >>>stroka3.partition("с")  #Возвращает кортеж с результатами поиска «с» слева
 ('Микропроце', 'с', 'сорная система управления')
 >>>stroka3.rpartition("с")  #Возвращает кортеж с результатами поиска «с» справа
 ('Микропроцессорная си', 'с', 'тема управления')
 ```
 Изучим метод format. 
 ```
 >>>strk1 = 'Момент времени {}, значение = {}'
 >>>strk1           
 'Момент времени {}, значение = {}'
 >>>strk1.format(1, 89.7)            
 'Момент времени 1, значение = 89.7'
 ```
 Можно указать порядок:
 ```
 >>>strk2='Момент времени {1}, значение = {0}:{2}'
 >>>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, не менее чем с 5 элементами. Отобразите его атрибуты.
 Последовательно обратитесь к методам этого списка с отображением каждый раз полученного списка:
 ```
 spsk = ["blue", 163, (1, 2), "green", 78.69] #Создаем список           
 spsk.pop(2) #Удаляем второй элемент из списка           
 (1, 2) #Удаленный элемент
 spsk          
 ['blue', 163, 'green', 78.69]
 spsk.append('c') #Добавляем элемент в список, по умолчанию добавляется в конец          
 spsk            
 ['blue', 163, 'green', 78.69, 'c']
 spsk.insert(2, 'a') #Добавление элемента в список с индексом два           
 spsk          
 ['blue', 163, 'a', 'green', 78.69, 'c']
 spsk.count('a') #Подсчет элементов 'a' в списке             
 1
 ```
 ### 9.3. Создание кортежа и изучение создания его методов.
 ```
 >>>cort = ('abc', 52.3, 'a', 167, 3 + 2j)
 >>>dir(cort)        
 ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
 >>>cort.count('a')         
 1
 >>>cort.index(3+2j)        
 4
 ```
 Благодаря функции dir видим, что кортеж имеет меньше атрибутов чем список.
 ### 9.4. Методы словарей и множеств.
 - Методы словарей
 Возьмем уже ранее использованный словарь dic1
 ```
 >>>dic1           
 {'Saratov': 145, 'Orel': 56, 'Vologda': 45}
 >>>dic1.keys() # Возвращение объектов, состоящих только из ключей.         
 >>>dict_keys(['Saratov', 'Orel', 'Vologda'])
 >>dir(dic1)          
 ['__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']
 >>>dic1.items()  #Возвращение кортежей из пар ключ-значение      
 >>>dict_items([('Saratov', 145), ('Orel', 56), ('Vologda', 45)])
 >>>dic1.get("Saratov") #Возвращение значения по ключу           
 145
 >>>dic1.values() #Возвращение объекта только из значений        
 >>>dict_values([145, 56, 45])
 >>>dic1["key4"] = 49 #Вызов значения по ключу      
 >>>dic1         
 {'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'key4': 49}
 >>>dic1_k = dic1.keys() #Создание отдельного объекта, чтобы положить в него dict_keys           
 >>>dic1_k        
 >>>dict_keys(['Saratov', 'Orel', 'Vologda', 'key4'])
 >>>dic1.popitem() #Удаление последнего добавленного элемента          
 ('key4', 49)
 >>>dic1          
 {'Saratov': 145, 'Orel': 56, 'Vologda': 45}
 >>>dic1_k           
 >>>dict_keys(['Saratov', 'Orel', 'Vologda'])
 >>>dic1.pop("Orel") #Удаление ключа и возвращение значения            
 56
 ```
 - Методы множеств
 ```
 >>>mn = {1, "per", 35.8, "red", True, 153} #Создаем множество
 >>>mn            
 {1, 35.8, 'per', 153, 'red'}
 >>>dir(mn)           
 ['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
 >>>mn.add(6+3j) #Добавление элемента в конец множества            
 >>>mn            
 {1, 35.8, 'per', 153, 'red', (6+3j)}
 >>>mn.remove(1) #Удаление элемента по значению            
 >>>mn            
 {35.8, 'per', 153, 'red', (6+3j)}
 >>>mn.discard("red") #Удаление элемента по значению с возвратом None при отсутствии            
 >>>mn           
 {35.8, 'per', 153, (6+3j)} 
 {35.8, 'per', 153, (6+3j)}
 >>>print(mn.discard(1000))            
 None
 >>>mn.pop() #Удаление и возвращение случайного элемента из множества            
 35.8
 >>>mn             
 {'per', 153, (6+3j)}
 >>>mn.update({63, "klumba"}) #Добавление элементов
 >>>mn 
 {'klumba', 'per', 153, 63, (6+3j)}
 ```
 ## 10. Сохранение созданного текстового файла протокола в своем рабочем каталоге. Завершение сеанса работы с IDLE.