From e873575954052e9818626d6d830173367462c6fa Mon Sep 17 00:00:00 2001 From: ShinkarenkoVA Date: Sun, 28 Sep 2025 21:13:30 +0300 Subject: [PATCH] Tema 3 report --- TEMA3/TEMA3report.md | 769 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 769 insertions(+) create mode 100644 TEMA3/TEMA3report.md diff --git a/TEMA3/TEMA3report.md b/TEMA3/TEMA3report.md new file mode 100644 index 0000000..b10a280 --- /dev/null +++ b/TEMA3/TEMA3report.md @@ -0,0 +1,769 @@ +# Отчет по теме 3 + +Шинкаренко Варвара, А-02-23 + +## 1. Настройка рабочего каталога + +Запустили интерактивную оболочку IDLE. Перед началом работы со средой настроили рабочий каталог + +```py +import os +os.chdir('C:\\Users\\LENOVO\\Desktop\\python-labs\\TEMA3') +``` + +## 2. Преобразование простых базовых типов объектов. + +### 2.1 Преобразование в логический тип + +Изучили преобразование в логический тип с помощью функции bool(<..>) + +```py +logiz1 = bool(56) +logiz2 = bool(0) +logiz3 = bool("Beta") +logiz4 = bool("") +logiz1 +True +logiz2 +False +logiz3 +True +logiz4 +False +``` + +### 2.2 Преобразование в целое десятичное число + +Преобразование в целое десятичное число производится с указанием системы счисления, в которой определен объект. Если ничего не указывать, система счисления принимается десятичной + +```py +tt1 = int(198.6) +tt1 +198 +tt2 = int("-76") +tt2 +-76 +tt3 = int("B", 16) +tt3 +11 +tt4 = int('71', 8) +tt4 +57 +tt5 = int(98.76) +tt5 = int("98.76") +Traceback (most recent call last): + File "", line 1, in + tt5 = int("98.76") +ValueError: invalid literal for int() with base 10: '98.76' +``` + +В последнем случае возникает ошибка, так как тип 98.76 это float, число с плавающей точкой, а значит напрямую из строки в целое число преобразовать не получится; int ожидает, что в строке будет целое число. Надо сначала преобразовать 98.76 во float и только потом делать 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 +``` + +Теперь можно исправить ошибку: + +```py +tt5 = int(float("98.76")) +tt5 +98 +``` + +### 2.3 Преобразование десятичных чисел в другие системы счисления + +```py +hh = 123 +dv1 = bin(hh) # Преобразование в строку с двоичным представлением +dv1 +'0b1111011' +vos1 = oct(hh) # Строка с восьмеричным представлением +vos1 +'0o173' +shs1 = hex(hh) # Шестнадцатеричное представление +shs1 +'0x7b' +``` + +Выполним проверку, с помощью обратного преобразования: + +```py +int(dv1, 2) +123 +int(vos1, 8) +123 +int(shs1, 16) +123 +``` + +## 3. Преобразование более сложных базовых типов объектов + +### 3.1 Преобразование в строку символов + +```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 Преобразование элементов объекта в список + +```py +spis1 = list("Строка символов") + +spis1 + +['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'] +spis2 = list((124, 236, -15, 908)) + +spis2 + +[124, 236, -15, 908] +spis3 = list({"A":1, "B":2, "C":9}) + +spis3 + +['A', 'B', 'C'] + +spis4 = list({"A":1, "B":2, "C":9}.values()) + +spis4 + +[1, 2, 9] +``` + +### 3.3 Преобразование элементов объектов в кортеж + +```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 Удаление объектов + +```py +del strk5, kort8 + +dir() + +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'fio', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'kortf', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'spisf', 'strk1', 'strk2', 'strk3', 'strk4', 'strkf', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1'] +``` + +Создали строку со своей фамилией и инициалами и совершили некоторые преобразования: + +```py +fio = "Шинкаренко В. А." + +spisf = list(fio) + +spisf + +['Ш', 'и', 'н', 'к', 'а', 'р', 'е', 'н', 'к', 'о', ' ', 'В', '.', ' ', 'А', '.'] +kortf = tuple(spisf) + +kortf + +('Ш', 'и', 'н', 'к', 'а', 'р', 'е', 'н', 'к', 'о', ' ', 'В', '.', ' ', 'А', '.') +strkf = str(kortf) + +strkf + +"('Ш', 'и', 'н', 'к', 'а', 'р', 'е', 'н', 'к', 'о', ' ', 'В', '.', ' ', 'А', '.')" +``` + +## 4. Арифметические операции + +### 4.1 Сложение и вычитание + +```py +12 + 7 + 90 + +109 +5.689e-1 - 0.456 + +0.11289999999999994 +23.6 + 54 + +77.6 +14 - 56.7 + 89 + +46.3 +``` + +### 4.2 Умножение + +```py +-6.7 * 12 + +-80.4 +``` + +### 4.3 Деление + +```py +-234.5 / 6 + +-39.083333333333336 +a = 178 / 45 +a + +3.9555555555555557 +type(a) + + # Тип всегда вещественное число +``` + +### 4.4 Деление с округлением вниз + +```py +b = 178//45 + +b + +3 +type(b) + + +c = -24.6//12.1 + +c + +-3.0 +type(c) + + # Тип может быть и целым, и вещественным +``` + +### 4.5 Получение остатка от деления + +```py +148%33 + +16 +12.6%3.8 + +1.2000000000000002 +20%6 + +2 + +8452.845%45.68 + +2.0449999999993977 +``` + +### 4.6 Возведение в степень + +```py +14**3 + +2744 +e = 2.7**3.6 + +e + +35.719843790663525 +4**0.5 + +2.0 +81**0.25 + +3.0 +1024**0.1 + +2.0 +0.0016**0.25 + +0.2 +``` + +Проведем некоторые операции над комплексными числами: + +```py +c1 = (1 + 5j) + +c2 = (2 + 3j) + +c1+c2 + +(3+8j) +c1-c2 + +(-1+2j) +c1*c2 + +(-13+13j) +c1/c2 + +(1.307692307692308+0.5384615384615384j) +c1//c2 + +Traceback (most recent call last): + File "", line 1, in + c1//c2 +TypeError: unsupported operand type(s) for //: 'complex' and 'complex' +c1%c2 + +Traceback (most recent call last): + File "", line 1, in + c1%c2 +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' +c1**c2 + +(0.09216679049807401+0.4120908574408883j) +``` + +Вывод: нельзя применять деление с округлением вниз и получение остатка для комплекных чисел + +## 5. Операции с двоичным представлением чисел + +### 5.1 Двоичная инверсия + +Замена 1 на 0 и наоборот: + +```py +dv1 = 9 +dv2 = ~dv1 +dv2 +-10 +bin(dv1) +'0b1001' +bin(dv2) +'-0b1010' +``` + +### 5.2 Двоичное "И" + +```py +bin(7&9) +'0b1' +bin(7&8) +'0b0' +``` + +### 5.3 Двоичное "ИЛИ" + +```py +bin(7|9) +'0b1111' +bin(7|8) +'0b1111' +bin(14|5) +'0b1111' +``` + +### 5.4 Двоичное "исключающее ИЛИ" + +```py +bin(14^5) +'0b1011' +14^5 +11 +``` + +### 5.5 Сдвиг двоичного представления влево или вправо + +```py +h = 14 +bin(h) +'0b1110' +g = h<<2 +bin(g) +'0b111000' +g1 = h>>1 +bin(g1) +'0b111' +g2 = h>>2 +bin(g2) +'0b11' +bin(7563) +'0b1110110001011' +bin(~7563) +'-0b1110110001100' +bin(7563>>23) +'0b0' +bin(7563>>3) +'0b1110110001' +bin(7563>>5) +'0b11101100' +bin(7563<<5) +'0b111011000101100000' +bin(7563<<1) +'0b11101100010110' +``` + +## 6. Операции при работе с последовательностями + +### 6.1 Объединение последовательностей (конкатенация) + +```py +'Система' + 'регулирования' +'Системарегулирования' +'Система' + ' ' + 'регулирования' +'Система регулирования' +['abc', 'de', 'fg'] + ['hi', 'jkl'] +['abc', 'de', 'fg', 'hi', 'jkl'] +('abc', 'de', 'fg') + ('hi', 'jkl') +('abc', 'de', 'fg', 'hi', 'jkl') +``` + +### 6.2 Повторение + +```py +'ля-'*5 +'ля-ля-ля-ля-ля-' +['ку', '-']*3 +['ку', '-', 'ку', '-', 'ку', '-'] +('ку', '-')*4 +('ку', '-', 'ку', '-', 'ку', '-', 'ку', '-') +signal1 = [0]*3 + [1]*99 +signal1 +[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] +signal2 = (0,)*3 + (1,)*5 + (0,)*7 +signal2 +(0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0) +``` + +### 6.3 Проверка наличия заданного элемента в последовательности + +```py +stroka = 'Система автоматического управления' +'автомат' in stroka +True +'ку' in ['ку', '-']*3 +True +'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') +False +``` + +### 6.4 Подстановка значений в строку + +```py +stroka = 'Температура = %g %s %g' +stroka % (16, 'меньше', 25) +'Температура = 16 меньше 25' +stroka = 'Температура = %(zn1)g %(sravn)s %(zn2)g' +stroka % {'zn1':16,'sravn':'меньше', 'zn2':25} +'Температура = 16 меньше 25' +``` + +## 7. Оператор присваивания + +### 7.1 Обычное присваивание значения переменной + +```py +zz = -12 +zz +-12 +``` + +### 7.2 Увеличение и уменьшение значения переменной + +```py +zz = -12 +zz +-12 +zz += 5 +zz +-7 +zz -= 3 +zz +-10 +stroka = 'Система' +stroka += ' регулирования' +stroka +'Система регулирования' +``` + +### 7.3 Умножение и деление значения переменной на число + +```py +zz /= 2 +zz +-5.0 +zz *= 5 +zz +-25.0 +``` + +### 7.4 Деление с округлением вниз, получение остатка от деления и возведение в степень + +```py +zz //= 3 +zz +-9.0 +zz %=5 +zz +1.0 +zz *= 22 +zz +22.0 +zz **= 0.5 +zz +4.69041575982343 +``` + +### 7.5 Множественное присваивание + +```py +w = v = 10 +w +10 +v +10 +n1, n2, n3 = (11, -3, 'all') +n1 +11 +n1, n2, n3 = [11, -3, 'all'] +n1 +11 +n1, n2, n3 = {'a':1, 'b':2, 'c':3} + +n1 + +'a' +n1, n2, n3 = {'a':1, 'b':2, 'c':3}.values() + +n1 + +1 +n1, n2, n3 = {1, 2, 3} + +n1 + +1 +n1, n2, n3 = '1,2' + +n1, n2, n3 + +('1', ',', '2') +``` + +## 8. Логические операции + +### 8.1 Операции сравнения + +```py +w == v +True +w != v +False +w < v +False +w > 2 +True +w <= v +True +w >= v +True +``` + +### 8.2 Проверка наличия заданного элемента в последовательности + +```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] == 'PM' +True +dct1['Depart'][1] == 'MM' +False +``` + +### 8.3 Создание больших логических выражений + +```py +(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1) +True +(a>=b) and ('book' in mnoz1) or ('Pskov' in dic1) +True +(dct1['Institut'][2] == 'IBB') and not ('cap' in mnoz1) +True +not((dct1['Institut'][1] == 'IBB') or ('cap' in mnoz1) and ('Kostroma' in dic1)) +True +``` + +### 8.4 Проверка ссылок переменных на один и тот же объект + +```py +w = v = 10 +w is v +True +w1 = ['A', 'B'] +v1 = ['A', 'B'] +w1 is v1 +False +``` +Разница в том, что в первом случае мы записали присваивание в одной строке, поэтому объекты w и v ссылаются на один и тот же адрес. Когда же мы присваиваем пусть и одно и то же занчение, но на разных строках, то и переменные ссылаются на разный адрес. +Это можно проверить, повторив операцию со списком, но записав в одну строку: + +```py +w2 = v2 = ['test', '1'] +w2 is v2 +True +``` + +## 9. Операции с объектами, выполняемые с помощью методов + +Получение списка всех атрибутов объекта: + +```py +stroka = 'Микропроцессорная система управления' +dir(stroka) +['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', ' ... +``` + +### 9.1 Методы для работы со строками + +```py +stroka.find('пр') +5 +stroka.count('с') +4 +stroka.replace('у', 'автоматического у') +'Микропроцессорная система автоматического управления' +spis22 = stroka.split(' ') +spis22 +['Микропроцессорная', 'система', 'управления'] +stroka.upper() +'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ' +stroka3 = " ".join(spis22) +stroka3 +'Микропроцессорная система управления' +stroka3.partition("с") +('Микропроце', 'с', 'сорная система управления') +stroka3.rpartition("с") +('Микропроцессорная си', 'с', 'тема управления') +``` +Изучили метод format: + +```py +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 Методы для работы со списками + +```py +spsk = ['гк', 'м', 'н', 'киж', 'е'] +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'] +spsk.pop(2) +'н' +spsk.append('с') +spsk +['гк', 'м', 'киж', 'е', 'с'] +spsk.insert(2, 'а') +spsk +['гк', 'м', 'а', 'киж', 'е', 'с'] +spsk.count('а') +1 +``` + +## 9.3 Методы для работы с кортежами + +```py +kort = ('кот', 1, 'собака', 2, 'рыбки') +kort.count(1) +1 +kort.index(2) +3 +``` + +## 9.4 Методы для работы со словарями и множествами + +```py +dic = {'кот':3, 'собака':1, 'рыбки':12, 'кролик':2} +dic.values() +dict_values([3, 1, 12, 2]) +dic.keys() +dict_keys(['кот', 'собака', 'рыбки', 'кролик']) +dic.pop('кот') +3 +dic['кролик'] = 5 +dic +{'собака': 1, 'рыбки': 12, 'кролик': 5} +dic.clear() +dic +{} +``` + +Проделаем операции над множествои: + +```py +mn = {'food', 9 + 7j, 't', 78, 'red'} +mn.add('blue') +mn.remove('red') +mn +{'t', (9+7j), 'food', 'blue', 78} +mn.pop() +'t' +mn.symmetric_difference('t') +{'blue', 78, 't', 'food', (9+7j)} +mn.discard('t') +mn +{(9+7j), 'food', 'blue', 78} +mn.issubset('blue') +False +``` + +## 10. Завершили сеанс работы со средой. \ No newline at end of file