From 55fa17468513ce26057e5f96c5d7cdc50b50ada8 Mon Sep 17 00:00:00 2001 From: Ksenia Date: Sat, 13 Sep 2025 18:21:42 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D1=82=D1=87=D1=91=D1=823?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA3/Отчет3.md | 717 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 717 insertions(+) create mode 100644 TEMA3/Отчет3.md diff --git a/TEMA3/Отчет3.md b/TEMA3/Отчет3.md new file mode 100644 index 0000000..4806ace --- /dev/null +++ b/TEMA3/Отчет3.md @@ -0,0 +1,717 @@ +# Отчет по Теме 3 + +Зеленкина Ксения, А-02-23 + +## 1. Начало работы. +Запустила интерактивную оболочку IDLE и открыла окно текстового редактора, куда буду фиксировать мои дальнейшие действия. + +## 2. Преобразование простых базовых типов объектов. +#### п. 2.1 +Преобразование в логический тип с помощью функции __bool(<Объект>)__. +```py +>>> logiz1=bool(56) +>>> print(type(logiz1)) + +>>> logiz2=bool(0) +>>> print(type(logiz2)) + +>>> logiz3=bool("Beta") +>>> print(type(logiz3)) + +>>> logiz4=bool("") +>>> print(type(logiz4)) + +``` + +#### п. 2.2 +Преобразуем в целое десятичное число объект с заданной системой счисления с помощью функции __int(<Объект>[,<Система счисления, в которой определен объект>])__. +```diff +>>> tt1=int(198.6) #Отбрасывается дробная часть +>>> print(tt1) + 198 +>>> tt2=int("-76") #Число – в строке символов, система по умолчанию - десятичная +>>> print(tt2) + -76 +>>> tt3=int("B",16) +>>> print(tt3) + 11 +>>> tt4=int("71",8) +>>> print(tt4) + 57 +>>> tt5=int("98.76") +>>> print(tt5) +- Traceback (most recent call last): +- File "C:/Users/user/OneDrive/Documents/ZelenkinaKs/python-labs/TEMA3/Pr1.py", line 19, - in +- tt5=int("98.76") +- ValueError: invalid literal for int() with base 10: '98.76' +``` +В последнее функции ошибка возникает потому, что функция int() не может преобразовывать строки с десятичной точкой (дробные числа) напрямую. +Исправленный вариант: +```py +>>> tt5 = int(float("98.76")) + 98 +``` +Функция int() со строковым аргументом требует, чтобы строка содержала только: +- Цифры (0-9) +- Знак минус (для отрицательных чисел) +- Буквы A-F (только для систем счисления выше 10) +- Без десятичных точек, запятых или других нечисловых символов + +Преобразуем целые чисела или строки символов в вещественное число – с помощью функции __float(<Объект>)__. +```py +>>> flt1=float(789) +>> print(flt1) + 789.0 +>>> flt2=float(-6.78e2) +>>> print(flt2) + -678.0 +>>> flt3=float("Infinity") +>>> print(flt3) + inf +>>> flt4=float("-inf") +>>> print(flt4) + -inf +``` + +#### п. 2.3 +Преобразование десятичных чисел в другие системы счисления: +```py +>> hh=123 +>> print(hh) + 123 +>>> dv1=bin(hh) #Преобразование в строку с двоичным представлением +>>> print(dv1) + 0b1111011 +>>> vos1=oct(hh) # Преобразование в строку с восьмеричным представлением +>>> print(vos1) + 0o173 +>>> shs1=hex(hh) # Преобразование в строку с шестнадцатеричным представлением +>>> print(shs1) + 0x7b +``` +## 3. Преобразования более сложных базовых типов объектов. +#### п. 3.1 +Преобразование в строку символов с помощью функции __str(<Объект>)__. +```py +>>> strk1=str(23.6) +>>> print(strk1) + 23.6 +>>> strk2=str(logiz3) +>>> print(strk2) + True +>>> strk3=str(["A","B","C"]) #Преобразуем список +>>> print(strk3) + ['A', 'B', 'C'] +>>> strk4=str(("A","B","C")) #Преобразуем кортеж +>>> print(strk4) + ('A', 'B', 'C') +>>> strk5=str({"A":1,"B":2,"C":9}) #Преобразуем словарь +>>> print(strk5) + {'A': 1, 'B': 2, 'C': 9} +``` + +#### п. 3.2 +Преобразование элементов объекта в список с помощью функции __list(<Объект>)__. +```py +>>> spis1=list("Строка символов") #Заданная строка разделяется на символы +>>> print(spis1) + ['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'] +>>> spis2=list((124,236,-15,908)) #Кортеж превращается в список +>>> print(spis2) + [124, 236, -15, 908] +>>> spis3=list({"A":1,"B":2,"C":9}) #Преобразование словаря в список +>>> print(spis3) + ['A', 'B', 'C'] +``` + +#### п. 3.3 +Преобразование элементов объектов в кортеж с помощью функции __tuple(<Объект>)__. +```py +>>> kort7=tuple('Строка символов') #Преобразование строки символов в кортеж +>>> print(kort7) + ('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в') +>>> kort8=tuple(spis2) #Преобразование списка в кортеж +>>> print(kort8) + (124, 236, -15, 908) +>>> kort9=tuple({"A":1,"B":2,"C":9}) #Преобразование словаря в кортеж +>>> print(kort9) + ('A', 'B', 'C') +``` + +#### п. 3.4 +Очистить оперативную память от ранее созданных объектов можно с помощью инструкции __del__. + ```py + >>> del strk5, kort8 +>>> print('strk5' in globals()) + False +>>> print('kort8' in globals()) + False + ``` + Данные переменные были удалены. + __Преобрращование ФИО:__ + ```py +>> FIO = "Зеленкина Кс. М." +>>> print(FIO) + Зеленкина Кс. М. +>>> listFIO = list(FIO) +>>> print(listFIO) + ['З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.'] +>>> kortFIO = tuple(listFIO) +>>> print(kortFIO) + ('З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.') +>>> strFIO = str(kortFIO) +>>> print(strFIO) + ('З', 'е', 'л', 'е', 'н', 'к', 'и', 'н', 'а', ' ', 'К', 'с', '.', ' ', 'М', '.') + ``` + ## 4. Арифметические операции. + #### п. 4.1 + Сложение и вычитание (+ и -): + ```py +>>> print(12+7+90) # Сложение целых чисел + 109 +>>> print(5.689e-1 - 0.456) #Вычитание вещественных чисел + 0.11289999999999994 +>>> print(23.6+54) #Сложение вещественного и целого чисел + 77.6 +>>> print(14-56.7+89) # Сложение и вычитание целых и вещественных чисел + 46.3 + ``` + +#### п. 4.2 + Умножение (*): + ```py + >>> print(-6.7*12) #Умножение вещественного числа на целое число + -80.4 + ``` +#### п. 4.3 +Деление (/): +```py +>>> print( -234.5/6) #Деление вещественного числа на целое + -39.083333333333336 +>>> a = (178/45) #Деление двух целых чисел – проверьте тип объекта a! +>>> print(a, type(a)) + 3.9555555555555557 +``` + +#### п. 4.4 +Деление с округлением вниз (//): +```py +>>> b=178//45 #Деление двух целых чисел +>>> c=-24.6//12.1 #Деление двух вещественных чисел +>>> print(b, c) + 3 -3.0 +``` +__Смешанные комбинации__ +```py +# Целое // Вещественное +d = 100 // 2.5 +e = -50 // 3.2 +print(type(d), type(e)) +print(d, e) +# Вещественное // Целое +f = 15.8 // 4 +g = -7.5 // 2 +print(type(f), type(g)) +print(f, g) +# Отрицательные числа +h = -100 // 3 +i = 100 // -3 +print(type(h), type(i)) +print(h, i) +print('\n') +``` + +#### п. 4.5 +Получение остатка от деления (%): +```py +>>> print(148 % 33) #Остаток от деления двух целых чисел + 16 +>>> print(12.6 % 3.8) #Остаток от деления двух вещественных чисел + 1.2000000000000002 +``` +Попробовала смешанные комбинации с данной операцией. + +#### п. 4.6 +Возведение в степень (**): +```py +>>> print(14**3) #Целое число возводится в целую степень + 2744 +>>> e = 2.7**3.6 #Вещественное число возводится в вещественную степень +>>> print(e) + 35.719843790663525 +``` +Попробовала смешанные комбинации с данной операцией. +```py +>>> print((3+4j) + (2-1j)) +>>> print((5+2j) - (1+3j)) +>>> print((2+3j) * (1-2j)) +>>> print((4+0j) * 2.5) +>>> print((6+8j) / (2+0j)) +>>> print((10+5j) / 2) +>>> print((1+1j)**2 ) + (5+3j) + (4-1j) + (8-1j) + (10+0j) + (3+4j) + (5+2.5j) + 2j +``` +```diff +>>> print((5+3j) // (2+1j)) +- unsupported operand type(s) for //: 'complex' and 'complex' +>>> print((8+4j) % (3+1j)) +- TypeError: unsupported operand type(s) for %: 'complex' and 'complex' +``` +Для комплексных чисел __допустимы__ следующие операции: +, -, *, /, ** +__Не допустимы:__ //, % + +## 5. Операции с двоичными представлениями целых чисел. +#### 5.1. +Двоичная инверсия (~). Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0). +```py +>>> dv1=9 +>>> dv2=~dv1 +>>> print(dv1, dv2) + 9 -10 +``` + +#### 5.2. +Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел +```py +>>> print(7&9) # 111 и 1001 = 0001 + 1 +>>> print(7&8) # 111 и 1000 = 0000 + 0 +``` + +#### 5.3. +Двоичное «ИЛИ» (|) – побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0. +```py +>>> print(7|9) # 111 или 1001 = 1111 + 15 +>>> print(7|8) # 111 или 1000 = 1111 + 15 +>>> print(14|5) # 1110 или 0101 = 1111 + 15 +``` + +#### 5.4. +Двоичное «исключающее ИЛИ»(^) - побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1. +```py +>>> print(14^5) # 1110 исключающее или 0101 = 1011 + 11 +``` + +#### 5.5. +Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева. +```py +>>> h =14 #Двоичное представление = 1110 +>>> print(h) + 14 +>>> g=h<<2 # Новое двоичное представление = 111000 +>>> print(g) + 56 +>>> g1=h>>1 # Новое двоичное представление = 0111 +>>> print(g1) + 7 +>>> g2=h>>2 # Новое двоичное представление = 0011 +>>> print(g2) + 3 +``` +Пример с 7-ми битными числами: +```py +>>> a = 0b1101010 # 106 (десятичное +>>> b = 0b1011011 # 91 (десятичное) +>>> print(a & b) + 74 +>>> print(a | b) + 123 +>>> print(a ^ b) + 49 +>>> print(a << 2) + 424 +>>> print(b >> 1) + 45 +>>> print(~a) + -107 +``` +## 6. Операции при работе с последовательностями (строками, списками, кортежами). +#### п. 6.1 +Объединение последовательностей (конкатенация)(+) +```py +>>> print('Система '+'регулирования') #Соединение двух строк символов + Система регулирования +>>> print(['abc','de','fg']+['hi','jkl']) # Объединение двух списков + ['abc', 'de', 'fg', 'hi', 'jkl'] +>>> print(('abc','de','fg')+('hi','jkl')) # Объединение двух кортежей + ('abc', 'de', 'fg', 'hi', 'jkl') +``` + +#### п. 6.2 +Повторение (*) +```py +>>> print('ля-'*5) #Повторение строки 5 раз + ля-ля-ля-ля-ля- +>>> print(['ку','-']*3) #Повторение списка 3 раза + ['ку', '-', 'ку', '-', 'ку', '-'] +>>> print(('кис','-')*4) #Повторение кортежа 4 раза + ('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-') +>>> signal1=[0]*3+[1]*99 +>>> print(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 +>>> print(signal2) + (0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0) +``` +#### п. 6.3 +Проверка наличия заданного элемента в последовательности (in): +```py +>>> stroka='Система автоматического управления' + Система автоматического управления +>>> print(stroka) +>>> print('автомат' in stroka) #Наличие подстроки в строке + True +>>> print('ку' in ['ку','-']*3) #Наличие контекста в списке + True +>>> print('ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')) #Наличие контекста в кортеже + False +``` + +#### п. 6.4 +Подстановка значений в строку с помощью оператора «%» +_Пример 1_ +```py +>>> stroka='Температура = %g %s %g' +>>> print(stroka) + Температура = %g %s %g +>>> print(stroka % (16,' меньше ',25)) + Температура = 16 меньше 25 +``` +_Пример 2_ +```py +>>> stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' +>>> print(stroka) + Температура = %(zn1)g %(sravn)s %(zn2)g +>>> print(stroka % {'zn1':16,'sravn':' меньше ','zn2':25}) + Температура = 16 меньше 25 +``` +## 7. Оператор присваивания +#### п. 7.1 +Обычное присваивание значения переменной (=): +```py +>>> zz=-12 +>>> print('zz = ' zz) + zz = -12 +``` + +#### п. 7.2 +Увеличение значения переменной на заданную величину (+=) или уменьшение (-=) +```py +>>> zz+=5 # Значение zz увеличивается на 5 +>>> print('zz + 5 = ', zz) + zz + 5 = -7 +>>> zz-=3 # Значение уменьшается на 3 +>>> print('zz - 3 = ', zz) + zz - 3 = -10 +>>> stroka='Система' +>>> print(stroka) + Система +>>> stroka+=' регулирования' +>>> print(stroka) + Система регулирования +``` + +#### п. 7.3 +Умножение текущего значения переменной на заданную величину (*=) или деление (/=) +```py +>>> zz/=2 +>>> print(zz) + -5.0 +>>> zz*=5 +>>> print(zz) + -25.0 +>>> stroka *= 2 +>>> print('stroka * 2 = ', stroka) + stroka * 2 = Система регулированияСистема регулирования +``` + +#### п. 7.4 +Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) изучите самостоятельно. +```py +>>> zz = zz1 =zz2 = 17 +>>> zz //= 5 +>>> print(zz) + 3 +>>> zz1 %= 5 +>>> print(zz1) + 2 +>>> zz2 **= 4 +>>> print(zz2) + 83521 +``` +Данные операции не применимы к строкам!!! + +#### п. 7.5 +Множественное присваивание: +```py +>>> w = v = 10 # Переменным присваивается одно и то же значение +>>> print(w, v) + 10 10 +>>> n1,n2,n3 = (11,-3,'all') #Значения переменных берутся из кортежа +>>> print(n1, n2, n3) + 11 -3 all +``` +Вместо кортежа справа используем строку, список, словарь, множество. +__Строка:__ +```py +>>> n1, n2, n3 = "11-" +>>> print(n1, n2, n3) + 1 1 - +``` +__Cписок:__ +```py +>>> n1, n2, n3 = [11, -3, 'all'] +>>> print(n1, n2, n3) + 11 -3 all +``` + +__Множество:__ +```py +>>> n1, n2, n3 = {11, -3, 'all'} +>>> print(n1, n2, n3) + 11 all -3 +``` + +__Словарь:__ +```py +>>> n1, n2, n3 = {11: 'a', -3: 'b', 'all': 'c'} +>>> print(n1, n2, n3) + 11 -3 all +``` +У __словаря__ распаковываются только ключи! + +## 8. Логические операции. +#### п. 8.1 +__Операции сравнение:__ равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) – придумайте примеры этих операций. +```py +>>> print(w == v) +>>> print(w != v) +>>> print(w < v) +>>> print(w > v) +>>> print(w <= v) +>>> print( w >= v) + True + False + False + False + True + True +``` + +#### п. 8.2 +Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in). +__Операции с множеством:__ +```py +>>> mnoz1={'pen','book','pen','iPhone','table','book'} +>>> print('book' in mnoz1) + True +>>> print('cap' in mnoz1) + False +``` +__Операции со словарём:__ +```py +>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45} +>>> print('Vologda' in dic1) + True +>>> print('Pskov' in dic1) + False +>>> print(56 in dic1.values()) + True +__Ещё примеры работ со словарём:__ +```py +>>> dct1={'Institut':['AVTI','IEE','IBB'],'Depart':['UII','PM','VMSS','MM'],'gruppa': ['A-01-15','A-02-15']} +>>> print('UII' in dct1['Depart']) + True +>>> dct1['Depart'][1] == 'MM' +>>> print(dct1) + {'Institut': ['AVTI', 'IEE', 'IBB'], 'Depart': ['UII', 'PM', 'VMSS', 'MM'], 'gruppa': ['A-01-15', 'A-02-15']} +``` + +#### п. 8.3 +Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). +```py +>>> a=17 +>>> b=-6 +>>> print((a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)) + True +``` + +__Придуманные сложные примеры:__ +_Пример 1:_ +```py +>>> x = 10 +>>> y = 20 +>>> z = 30 +>>> result = (x < y) and (y < z) or (x == 10) and not (z == 40) +>>> print(result) + True +``` +_Пример 2:_ +```py +>>> a = 5 +>>> b = 12 +>>> c = 8 +>>> d = 20 +>>> result = (a < b) and (b < d) or (c == 8) and not (d == 15) +>>> print(result) + True +``` + +#### п. 8.4 +Проверка ссылок переменных на один и тот же объект (is). +```py +>>> w=v=10 +>>> print(w is v) + True +>>> w1=['A','B'] +>>> v1=['A','B'] +>>> print(w1 is v1) + False +``` +__is__ проверяет идентичность объектов, а не равенство значений! + +## 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 +>>> print(stroka.find('пр')) + 5 +>>> print(stroka.count("с")) + 4 +>>> print(stroka.replace(' у',' автоматического у')) + Микропроцессорная система автоматического управления +>>> spis22=stroka.split(' ') +>>> print(spis22) + ['Микропроцессорная', 'система', 'управления'] +>>> print(stroka.upper()) + МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ +>>> stroka3=" ".join(spis22) +>>> print(stroka3) + Микропроцессорная система управления +>>> print(stroka3.partition("с")) + ('Микропроце', 'с', 'сорная система управления') +>>> print(stroka3.rpartition("с")) + ('Микропроцессорная си', 'с', 'тема управления') +``` +Изучила метод __format__: +```py +>>> strk1 = 'Момент времени {}, значение = {}' +>>> result1 = strk1.format(1, 89.7) +>>> print(result1) + Момент времени 1, значение = 89.7 +>>> strk2 = 'Момент времени {1}, значение = {0}:{2}' +>>> result2 = strk2.format(36.7, 2, 'норма!') +>>> print(result2) + Момент времени 2, значение = 36.7:норма! +>>> strk3 = 'Момент времени {num}, значение = {znch}' +>>> result3 = strk3.format(znch=89.7, num=2) +>>> print(result3) + Момент времени 2, значение = 89.7 +``` + +#### п. 9.2 +Методы для работы со списками: +Создадим произвольный список spsk, не менее чем с 5 элементами и отобразите его атрибуты. +Последовательно обратимся к методам этого списка с отображением каждый раз полученного списка: + +```py +>>> spsk = [10, 'apple', 3.14, 'banana', 42] +>>> print(spsk) + [10, 'apple', 3.14, 'banana', 42] +>>> print("Атрибуты списка:", dir(spsk)) + Атрибуты списка: ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] +>>> print(spsk.pop(2)) + 3.14 +>>> spsk.append('c') +>>> print(spsk) + [10, 'apple', 'banana', 42, 'c'] +>>> spsk.insert(2,'a') +>>> print(spsk) + [10, 'apple', 'a', 'banana', 42, 'c'] +>>> print(spsk.count('a')) + 1 +``` +Смысл выполненных операций: +- __pop()__ - убирает элемент +- __append()__ - добавляет в конец +- __insert()__ - Вставляет элемент на указанную позицию +- __count()__ - считает элементы + +#### п. 9.3 +Изучение применения основных методов кортежа: +```py +>>> kort = (1, 2, 3, 2, 4, 2, 5) +>>> print(kort) + (1, 2, 3, 2, 4, 2, 5) +>>> print(dir(kort)) + ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] +>>> print(kort.count(2)) + 3 +>>> print(kort.index(3)) # 2 (число 3 на позиции 2) + 2 +>>> print(kort.index(2, 3)) # 5 (число 2 начиная с позиции 3) + 3 +``` + +#### п. 9.4 +Изучение применения основных методов словарей и множеств: +__Словарь:__ +```py +>>> d = {'a': 1, 'b': 2, 'c': 3} +>>> print(d) + {'a': 1, 'b': 2, 'c': 3} +>>> print(dir(d)) + ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__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'] +>>> print(d.keys()) + dict_keys(['a', 'b', 'c']) +>>> print(d.values()) + dict_values([1, 2, 3]) +>>> d.update({'d': 4}) # Добавляет/обновляет элементы +>>> print(d) + {'a': 1, 'b': 2, 'c': 3, 'd': 4} +>>> removed = d.pop('b') # Удаляет ключ и возвращает значение +>>> print(removed) + 2 +``` + +__Множество:__ +```py +>>> s1 = {1, 2, 3, 4} +>>> s2 = {3, 4, 5, 6} +>>> print(dir(s1)) + ['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__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'] +>>> print("Множество 1:", s1) + Множество 1: {1, 2, 3, 4} +>>> print("Множество 2:", s2) + Множество 2: {3, 4, 5, 6} +>>> print(s1.union(s2)) #Объединение + {1, 2, 3, 4, 5, 6} +>>> print(s1.intersection(s2)) # {3, 4} - пересечение + {3, 4} +>>> print(s1.difference(s2)) #разность + {1, 2} +>>> s1.add(5) +>>> print(s1) + {1, 2, 3, 4, 5} +>>> s1.remove(1) +>>> print(s1) + {2, 3, 4, 5} +``` +## Завершение работы \ No newline at end of file