Tema3/report.md

1 месяц назад · aca3da705d
--- a/TEMA3/report.md
+++ b/TEMA3/report.md
@ -0,0 +1,845 @@
+  # Отчёт по теме 3: "Операции с объектами"
+Филиппов Даниил Юрьевич, А-01-23
+
+ # 1. Запуск интерактивной оболочки IDLE
+ # 2. Преобразование простых базовых типов объектов
+ ## 2.1 Преобразование в логический тип с помощью функции bool(<Объект>)
+
+Выполним следующие инструкции и после каждой из них проверим получившееся значение:
+```py
+>>> logiz1=bool(56)
+>>> logiz1
+True
+>>> type(logiz1)
+<class 'bool'>
+>>> logiz2=bool(0)
+>>> logiz2
+False
+>>> type(logiz2)
+<class 'bool'>
+>>> logiz3=bool("Beta")
+>>> logiz3
+True
+>>> type(logiz3)
+<class 'bool'>
+>>> logiz4=bool("")
+>>> logiz4
+False
+>>> type(logiz4)
+<class 'bool'>
+```
+
+ ## 2.2 Преобразование в целое десятичное число объекта с заданной системой счисления 
+
+Осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.
+```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#20>", line 1, in <module>
+    tt5=int("98.76")
+ValueError: invalid literal for int() with base 10: '98.76'
+```
+При выполнении последней инструкции выдано диагностическое сообщение, это происходит
+потому, что команда int ожидает, что ей сообщат строку, похожую на тип int
+(только цифры, может быть знак в начале). Здесь есть точка, поэтому вознакает
+несоответствие.
+
+
+Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>)
+```py
+>>> 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
+>>> 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
+>>> 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(<Объект>)
+```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']
+```
+Как видно, такая команда вернула список только из ключей. Можно написать так,
+чтобы в список попали только значения:
+```py
+>>> 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')
+```
+
+
+ ## 3.4 Удаление объектов
+Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del
+```py
+>>> del strk5, kort8
+```
+
+Проверим, остались ли после этой операции объекты в оперативной памяти:
+```py
+>>> dir()
+['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'vos1']
+```
+
+
+Создадим строку с моей фамилией и инициалами. Преобразуем её в список, затем список - в кортеж, затем кортеж - в строку.
+```py
+>>> strk1='FilippovDY'
+>>> spis11=list(strk1)
+>>> spis11
+['F', 'i', 'l', 'i', 'p', 'p', 'o', 'v', 'D', 'Y']
+>>> kort11=tuple(spis11)
+>>> kort11
+('F', 'i', 'l', 'i', 'p', 'p', 'o', 'v', 'D', 'Y')
+>>> strk2=str(kort11)
+>>> strk2
+"('F', 'i', 'l', 'i', 'p', 'p', 'o', 'v', 'D', 'Y')"
+```
+
+
+ # 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  #Деление двух целых чисел
+>>> type(a)
+<class 'float'>
+>>> a
+3.9555555555555557
+```
+Результатом деления всегда будет вещественное число.
+
+
+ ## 4.4 Деление с округлением вниз (//)
+
+```py
+>>> b=178//45   #Деление двух целых чисел
+>>> type(b)
+<class 'int'>
+>>> b
+3
+>>> c=-24.6//12.1  #Деление двух вещественных чисел
+>>> type(c)
+<class 'float'>
+>>> c
+-3.0
+```
+Здесь результат может быть целым или вещественным.
+Попробуем смешанные комбинации типов чисел:
+
+```py
+>>> d=178//24.6
+>>> type(d)
+<class 'float'>
+>>> d
+7.0
+```
+
+ ## 4.5 Получение остатка от деления (%)
+
+```py
+>>> 148%33   #Остаток от деления двух целых чисел
+16
+>>> 12.6%3.8  #Остаток от деления двух вещественных чисел
+1.2000000000000002
+>>> 36%2.6
+2.199999999999999
+>>> 52.06%2
+0.060000000000002274
+```
+
+ ## 4.6 Возведение в степень (**)
+
+```py
+>>> 14**3  #Целое число возводится в целую степень
+2744
+>>> e=2.7**3.6  #Вещественное число возводится в вещественную степень
+>>> e
+35.719843790663525
+>>> 2.7**3
+19.683000000000003
+>>> 3**5.2
+302.71261832657075
+```
+
+Попробуем операции с участием комплексных чисел:
+```py
+>>> comp1 = (5 + 7j) #Создадим первое комплексное число
+>>> type(comp1)
+<class 'complex'>
+>>> comp2=(6-4j) #Создадим второе комплексное число
+>>> comp1+comp2 #Сумма комплексных чисел
+(11+3j)
+
+>>> comp1-comp2 #Разность комплексных чисел
+(-1+11j)
+
+>>> comp1*comp2 #Произведение комплексных чисел
+(58+22j)
+
+>>> comp1/comp2 #Частное комплексных чисел
+(0.03846153846153853+1.1923076923076923j)
+
+>>> comp1//comp2 #Частное комплексных чисел с округлением вниз
+Traceback (most recent call last):
+  File "<pyshell#108>", line 1, in <module>
+    comp1//comp2
+TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
+
+comp1%comp2 #Получение остатка от деления комплексных чисел
+Traceback (most recent call last):
+  File "<pyshell#109>", line 1, in <module>
+    comp1%comp2
+TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
+
+>>> comp1**comp2 #Возведение комплексного числа в комплексную степень
+(-17647296.212723836-4257726.663737518j)
+```
+
+
+ # 5. Операции с двоичными представлениями целых чисел
+ ## 5.1 Двоичная инверсия (~)
+Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
+
+```py
+>>> dv1=9
+>>> dv2=~dv1
+>>> dv2
+-10
+>>> dv1
+9
+>>> bin(dv1)
+'0b1001'
+>>> bin(dv2)
+'-0b1010'
+```
+
+Результат не совсем совпадает с ожидаемым видом "0110". Это происходит, потому что в python под инверсией подразумевается смена всех 0 на 1, 1 на 0, а еще смена знака, а знак
+в двоичных числах записывается с помощью дополнительного кода. 
+Было число 9 (1001), меняем все значения на противоположные (0110), затем надо поменять знак (это значит, что надо инвертировать все значения разрядов - будет 1001) и прибавить к полученному числу единицу (которая отвечает за знак), получаем число 1010.
+  
+Двоичная инверсия делает из числа n число -(n+1).
+
+
+ ## 5.2 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
+```py
+>>> 7&9    # 111 и 1001 = 0001
+1
+>>> bin(7&9)
+'0b1'
+7&8    # 111 и 1000 = 0000
+0
+bin(7&8)
+'0b0'
+```
+7 в двоичной системе счисления - 0111, а 9 в двоичной системе счисления - 1001. Совпадение единиц только в первом разряде, поэтому итог - 0001 или 1.
+
+8 в двоичной системе счисления - 1000, совпадений единиц нет, итог - 0000 или 0.
+
+
+ ## 5.3 Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
+
+```py
+>>> 7|9     # 111 или 1001 = 1111
+15
+>>> bin(7|9)
+'0b1111'
+>>> 7|8     # 111 или 1000 = 1111
+15
+>>> bin(7|8)
+'0b1111'
+>>> 14|5   # 1110 или 0101 = 1111
+15
+>>> bin(14|5)
+'0b1111'
+```
+
+7 в двоичной системе счисления - 0111, 9 в двоичной системе счисления - 1001.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+8 в двоичной системе счисления - 1000.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
+Возвращается 1, если хотя бы в одном из попарно одинаковых разрядов есть единица, поэтому итог - 1111
+
+
+ ## 5.4 Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
+
+```py
+>>> 14^5  # 1110 исключающее или 0101 = 1011
+11
+>>> bin(14^5)
+'0b1011'
+```
+
+14 в двоичной системе счисления - 1110, 5 в двоичной системе счисления - 0101.
+Возвращается 1, если оба разряда разные, поэтому итог - 1011
+
+
+ ## 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева
+
+```py
+>>> h=14   #Двоичное представление = 1110
+>>> bin(h)
+'0b1110'
+>>> g=h<<2  # Новое двоичное представление = 111000, сдвиг на два разряда влево
+>>> bin(g)
+'0b111000'
+>>> g1=h>>1  # Новое двоичное представление = 0111, сдвиг на один разряд вправо
+>>> bin(g1)
+'0b111'
+>>> g2=h>>2  # Новое двоичное представление = 0011, сдвиг на два разряда вправо
+>>> bin(g2)
+'0b11'
+```
+Слева можно добавить сколько угодно незначащих нулей.
+
+Возьмём два любых числа 52 и 30. Проведём с ними двоичные операции:
+```py
+>>> bin(52)
+'0b110100'
+>>> bin(30)
+'0b11110'
+>>> dv3=~52 # Инверсия числа 52
+>>> bin(dv3)
+'-0b110101'
+>>> bin(52|30) # Двоичное или
+'0b111110'
+>>> bin(52>>2) # сдвиг двоичного представления числа 52 на два разряда вправо
+'0b1101'
+```
+
+ # 6. Операции при работе с последовательностями (строками, списками, кортежами)
+ ## 6.1 Объединение последовательностей (конкатенация)(+)
+
+```py
+>>> 'Система '+'регулирования'  #Соединение двух строк символов
+'Система регулирования'
+>>> ['abc','de','fg']+['hi','jkl']  # Объединение двух списков
+['abc', 'de', 'fg', 'hi', 'jkl']
+>>> ('abc','de','fg')+('hi','jkl')  # Объединение двух кортежей
+('abc', 'de', 'fg', 'hi', 'jkl')
+```
+Конкатенировать словари и множества нельзя. Так как у словарей ключи должны быть
+уникальными.
+```py
+>>> {'one':1 , 'two':2} + {'three':3}
+Traceback (most recent call last):
+  File "<pyshell#90>", line 1, in <module>
+    {'one':1 , 'two':2} + {'three':3}
+TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
+```
+
+ ## 6.2 Повторение (*)
+```py
+>>> 'ля-'*5   #Повторение строки 5 раз
+'ля-ля-ля-ля-ля-'
+>>> ['ку','-']*3 #Повторение списка 3 раза
+['ку', '-', 'ку', '-', 'ку', '-']
+>>> ('кис','-')*4  #Повторение кортежа 4 раза
+('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
+
+>>> signal1=[0]*3+[1]*99 # Создание списка со 100 отсчётами сигнала-ступеньки
+>>> 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 Подстановка значений в строку с помощью оператора «%»
+Пример 1:
+```py
+>>> stroka='Температура = %g %s  %g'
+>>> stroka
+'Температура = %g %s  %g'
+>>> stroka % (16,' меньше ',25)
+'Температура = 16  меньше   25'
+```
+Пример 2:
+```py
+>>> stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
+>>> stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
+'Температура = 16  меньше   25'
+```
+Подстановка возвращает новую строку, но не перезаписывает исходную.
+Типы вставок для оператора %:
+    %s - строка
+    %d и %i - целое число (d - всегда десятичное, а i - десятичное или переведенное
+         в десятичное из другой системы счисления)
+    %f - число с плавающей точкой
+    %e - экспоненциальная форма записи числа
+    %g - автовыбор между e и f  
+    %.nf - число с плавающей точкой, но конкретным количеством знаков после запятой
+
+
+ # 7. Оператор присваивания
+ ## 7.1 Обычное присваивание значения переменной (=)
+```py
+>>> zz=-12
+>>> zz
+-12
+```
+
+ ## 7.2 Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
+```py
+>>> zz+=5   # Значение zz увеличивается на 5
+>>> zz
+-7
+>>> zz-=3  # Значение уменьшается на 3
+>>> zz
+-10
+```
+Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.
+```py
+>>> stroka='Система'
+>>> stroka+=' регулирования'
+>>> stroka
+'Система регулирования'
+```
+
+ ## 7.3 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
+```py
+>>> zz/=2
+>>> zz
+-5.0
+>>> zz*=5
+>>> zz
+-25.0
+```
+Для строк операция (*=) означает повторение текущего значения объекта заданное число раз.
+```py
+>>> stroka = 'Система'
+>>> stroka *= 3
+>>> stroka
+'СистемаСистемаСистема'
+```
+
+ ## 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=)
+```py
+>>> zz
+-0.5
+>>> zz//=4
+>>> zz
+-1.0
+>>> zz%=-0.2
+>>> zz
+-0.19999999999999996
+>>> zz**=5
+>>> zz
+-0.00031999999999999965
+```
+
+ ## 7.5 Множественное присваивание
+```py
+>>> w=v=10  # Переменным присваивается одно и то же значение
+>>> w
+10
+>>> v
+10
+>>> n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
+>>> n1,n2,n3
+(11, -3, 'all')
+>>> n1
+11
+```
+Проверим, можно ли использовать так строку, список, словарь, множество:
+```py
+>>> a1, a2, a3 = "a", "b", "c" # Строка
+>>> a1, a2, a3
+('a', 'b', 'c')
+>>> b1, b2, b3 = ["a", 1, None] # Список
+>>> b1
+'a'
+>>> b3
+>>> c1, c2, c3 = {"one": 1, "two": 2, "three": 3} # Словарь
+>>> c1, c2, c3
+('one', 'two', 'three')
+>>> m1, m2, m3 = {52, 0, 3} # Множество
+>>> m1, m2, m3
+```
+
+
+ # 8. Логические операции – при создании логических выражений, дающих в результате вычисления значения True или False.
+ ## 8.1 Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=)
+```py
+>>> w
+10
+>>> v
+10
+>>> w==v # Равенство
+True
+>>> w!=v # Не равно
+False
+>>> w<v # Меньше
+False
+>>> w<=v # Меньше или равно
+True
+```
+
+ ## 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также  проверка наличия ключа в словаре (in)
+Операции с множеством 
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+```
+
+Операции со словарем
+```py
+>>> mnoz1={'pen','book','pen','iPhone','table','book'}
+>>> 'book' in mnoz1
+True
+>>> 'cap' in mnoz1
+False
+>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
+>>> 'Vologda' in dic1
+True
+>>> 'Pskov' in dic1
+False
+>>> 56 in dic1.values()
+True
+>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']}
+>>> 'UII' in dct1['Depart']
+True
+>>> dct1['Depart'][1] == 'MM'
+False
+```
+
+ ## 8.3 оздание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not)
+```py
+>>> a=17
+>>> b=-6
+>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
+True
+```
+Пример сложного логического выражения:
+```py
+>>> (len(dic1) == 3) or (sum(dic1.values()) > 300) or ('IVTI' in dct1['Depart'])
+True
+```
+
+ ## 8.4 Проверка ссылок переменных на один и тот же объект (is)
+```py
+>>> w=v=10  #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти
+>>> w is v
+True
+>>> w1=['A','B']
+>>> v1=['A','B']
+>>> w1 is v1
+False
+>>> w1 == v1
+True
+```
+Оператор is проверяет, ссылаются ли объекты на один и тот же адрес в памяти. Переменные
+целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти.
+Списки были созданы в разных строках, и адреса у них разные, т.е. они ссылаются на разные
+участки в памяти, поэтому is возвращает False. 
+```py
+>>> w2=20
+>>> v2=20
+>>> w2 is v2
+True
+
+>>> a=10002
+>>> b=10002
+>>> a is b
+False
+
+>>> a=b=10002
+>>> a is b
+True
+```
+В Python возможности в плане оперирования памятью сведены к минимуму, и иногда использование памяти оптимизировано. Например, числа от -5 до 256 python подвергает интернированию, т.е. делает так, чтобы они ссылались на один участок памяти. Но с числами, не попадающими в этот диапазон, это не работает.
+
+
+ # 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("с")  #Возвращает кортеж с результатами поиска «с» справа
+('Микропроцессорная си', 'с', 'тема управления')
+```
+Форматирование строки осуществляется в случае, если необходимо в символьную строку подставить значения некоторых объектов, например, полученных в ходе выполнения программы. Часто такую строку затем используют для вывода результатов работы программы на экран или в файл протокола.
+```py
+>>> strk1='Момент времени {}, значение = {}'
+>>> strk1
+'Момент времени {}, значение = {}'
+>>> strk1.format(1,89.7)
+'Момент времени 1, значение = 89.7'
+```
+
+Можно указать порядок. Здесь цифры в фигурных скобках – это индексы, определяющие порядок использования аргументов формата. Поэтому такой способ называют основанным на позиционных аргументах.
+```py
+>>> strk2='Момент времени {1}, значение = {0}:{2}'
+>>> strk2.format(36.7,2,'норма!')
+'Момент времени 2, значение = 36.7:норма!'
+```
+
+Можно подставить имена аргументов-вставок, и тогда порядок подстановки может быть
+произвольным:
+```py
+>>> strk3='Момент времени {num}, значение = {znch}'
+>>> strk3
+'Момент времени {num}, значение = {znch}'
+>>> strk3.format(znch=89.7,num=2)
+'Момент времени 2, значение = 89.7'
+```
+
+ ## 9.2 Методы для работы со списками
+```py
+>>> spsk = [10, 'd', (1, 2), 'a', 3] # Создание списка
+>>> spsk
+[10, 'd', (1, 2), 'a', 3]
+
+>>> spsk.pop(2) # Удаление элемента по индексу
+(1, 2)
+>>> spsk
+[10, 'd', 'a', 3]
+
+>>> spsk.append('c') # Вставка элемента в конец
+>>> spsk
+[10, 'd', 'a', 3, 'c']
+
+>>> spsk.insert(2,'a') # Вставка элемента в конкретное место по индексу
+>>> spsk
+[10, 'd', 'a', 'a', 3, 'c']
+
+>>> spsk.count('a') # Подсчет количества элементов по значению
+2
+>>> spsk
+[10, 'd', 'a', 'a', 3, 'c']
+```
+
+ ## 9.3 Методы для работы с кортежами
+Кортежи неизменяемы, поэтому методов, связанных с удалением или добавлением элементов, нет.
+```py
+>>> cor = (1, 'a', 'b', 0.05, 10+3j) # Создание кортежа
+
+>>> cor.count(1) # Подсчет количества элементов по значению
+1
+
+>>> cor.index(0.05) # Поиск индекса первого вхождения
+3
+>>> cor.index('d') 
+Traceback (most recent call last):
+  File "<pyshell#172>", line 1, in <module>
+    cor.index('d')
+ValueError: tuple.index(x): x not in tuple
+```
+
+ ## 9.4 Методы для работы со словарями и множествами
+Методы словарей:
+```py
+>>> dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+
+>>> new_dct1=dct1.copy() # Создается копия, но новые значения ссылаются на предыдущие
+>>> new_dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']}
+
+>>> dct1.get('Depart') # Возвращение значения по ключу
+['UII', 'PM', 'VMSS', 'MM']
+
+>>> dct1.keys() # Возвращение объекта только из ключей
+dict_keys(['Institut', 'Depart', 'gruppa'])
+
+>>> dct1.values() # Возвращение объекта только из значений
+dict_values([['AVTI', 'IEE', 'IBB'], ['UII', 'PM', 'VMSS', 'MM'], ['A-01-15', 'A-02-15']])
+```
+Возвращаемые объекты dict_keys, dict_values, dict_items - объекты-итераторы. Они ссылаются на адреса ключей или значений в памяти, но не хранят значения. Также эти объекты автоматически обновляются при обновлении словаря.
+```py
+>>> new_dct1.clear() # Полное очищение списка
+>>> new_dct1
+{}
+
+>>> dct1.pop('Depart') # Удаление ключа и возвращение значения
+['UII', 'PM', 'VMSS', 'MM']
+>>> dct1
+{'Institut': ['AVTI', 'IEE', 'IBB'], 'gruppa': ['A-01-15', 'A-02-15']}
+```
+Методы множеств:
+```py
+>>> mnoz1={1, 'датчик', False, 256, 'двигатель'}
+>>> mnoz1
+{False, 256, 1, 'двигатель', 'датчик'}
+
+>>> mnoz1.add(10+7j) # Добавление элемента
+>>> mnoz1
+{False, 256, 1, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz2=mnoz1.copy() # Создание копии
+>>> mnoz2
+{False, 256, 1, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz1.remove(1) # Удаление элемента по значению
+>>> mnoz1
+{False, 256, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz2.clear() # Очищение множества
+>>> mnoz2
+set()
+
+>>> mnoz1.pop() # Удаление случайного элемента из множества
+False
+>>> mnoz1
+{256, 'двигатель', 'датчик', (10+7j)}
+
+>>> mnoz1.update({True, 'b'}) # Добавление элементов
+>>> mnoz1
+{256, True, 'b', 'двигатель', 'датчик', (10+7j)}
+```
+
+
+ # 10. Завершение сеанса работы со средой
+
+
+