# Отчет по теме 3 **Антонов Дмитрий, А-03-23** ### 1.Начало работы, настройка текущего каталога ```py Python 3.13.7 (v3.13.7:bcee1c32211, Aug 14 2025, 19:10:51) [Clang 16.0.0 (clang-1600.0.26.6)] on darwin Enter "help" below or click "Help" above for more information. import os os.chdir('//Users//dmitrijantonov//Desktop//POAC//python-labs//TEMA3//') os.getcwd() '/Users/dmitrijantonov/Desktop/POAC/python-labs/TEMA3' ``` ### 2.Изучаю преообразование простых базовых типов объектов #### 2.1 Преобразование в логический тип ```py logiz1=bool(56) type(logiz1) logiz1 True logiz1=bool(0) type(logiz1) logiz1=bool(56) logiz2=bool(0) type(logiz2) logiz2 False logiz3=bool("Beta") type(logiz3) logiz3 True logiz4=bool("") logiz4 False type(logiz4) ``` #### 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") Traceback (most recent call last): File "", line 1, in tt5=int("98.76") ValueError: invalid literal for int() with base 10: '98.76' ``` - Объяснение - функция ожидает строку без дробной части ```py flt4=float("-inf") flt3=float("t") Traceback (most recent call last): File "", line 1, in flt3=float("t") ValueError: could not convert string to float: 't' flt3=float("-Infinity") flt3 -inf ``` - "inf" "-inf" "nan" эти слова допустимо переводить в строки #### 2.3 Преобразование десятичных чисел в другие системы счисления ```py hh=123 type(hh) dv1=bin(hh) #двоичную dv1 '0b1111011' vos1=oct(hh) #восьмеричную vos1 '0o173' shs1=hex(hh) #шестандацтиричную shs1 '0x7b' ``` - Убедился, что можно перевести только строку с указанием системы исчисления ```py int(hh,10) Traceback (most recent call last): File "", line 1, in int(hh,10) TypeError: int() can't convert non-string with explicit base int("100",9) 81 int(dv1,2) 123 int(vos1,8) 123 int(shs1,16) 123 type(vos1) ``` ### 3. Изучаю преобразования более сложных базовых типов объектов #### 3.1 Преобразование списков, словарей, кортежей, целых чисел, логических переменных в строку символов ```py strk1=str(23.6) strk2=str(logiz3) strk2 'True' logiz3 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] type(spis2) ``` - Преобразование ключей и значений словаря в список ```py spis3=list({"A":1,"B":2,"C":9}) spis3 ['A', 'B', 'C'] spis3=list({"A":1,"B":2,"C":9}.values()) spis3 [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') kort9=tuple({"A":1,"B":2,"C":9}.values()) kort9 (1, 2, 9) ``` #### 3.4 Удаление объектов из оперативной памяти и повторение преобразований объектов в разные типы ```py del strk5, kort8 ``` - проверил, что переменные удалились ```py dir(strk5) Traceback (most recent call last): File "", line 1, in dir(strk5) NameError: name 'strk5' is not defined. Did you mean: 'strk1'? dir() ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort7', 'kort9', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt5', 'vos1'] ``` - Выполнение преобразований ```py my_str = "Антонов Д.А" my_list = list(my_str) my_list ['А', 'н', 'т', 'о', 'н', 'о', 'в', ' ', 'Д', '.', 'А'] my_kort = tuple(my_list) my_kort ('А', 'н', 'т', 'о', 'н', 'о', 'в', ' ', 'Д', '.', 'А') new_str = str(my_kort) new_str "('А', 'н', 'т', 'о', 'н', 'о', 'в', ' ', 'Д', '.', 'А')" ``` ### 4.Арифметические операции #### 4.1 Сложение и вычитание ```py 12+7+90 109 5.689e-1 - 0.456 0.11289999999999994 5.689e-1 0.5689 23.6+54 77.6 14-56.7+89 46.3 ``` #### 4.2 Умножение и деление ```py -6.7*12 -80.4 -234.5/6 -39.083333333333336 a=178/45 type(a) a 3.9555555555555557 b = 2/2 b 1.0 type(b) ``` #### 4.3 Деление с округлением вниз ```py b=178//45 type(b) b 3 c=-24.6//12.1 ``` - Попробовал различные комбинации операций ```py type(c) c -3.0 d = 176.8 // 2 d 88.0 type(d) d = 17 // 2 d 8 type(d) d = 17 // 2.3 d 7.0 type(d) ``` #### 4.4 Получение остатка от деления ```py 148%33 16 12.6%3.8 1.2000000000000002 ``` - Попробовал смешанные комбинации типов чисел ```py 148%2.5 0.5 2.5%148 2.5 150.1%148 2.0999999999999943 150%148 2 1%2 1 164.9%40 4.900000000000006 164.9%40.555 2.680000000000007 ``` #### 4.5 Операция возведение в степень ```py 14**3 2744 e=2.7**3.6 e 35.719843790663525 type(14**3) ``` - Попробовал различные комбинации операций, обратил внимание на тип возращаемого результата ```py type(14**3.2) type(164.9%40.555) 2**2**2 16 2**9.5 724.0773439350247 5.5**2 30.25 0**2.2 0.0 type(0**2.2) 2*(1,2) (1, 2, 1, 2) 2*"1,2, " '1,2, 1,2, ' ``` #### 4.6 Применил изученные операции к комплексным числам ```py compl = 2 - 4j type(compl) compl-2+4j 0j compl+4j (2+0j) compl-4j (2-8j) compl*4j (16+8j) compl (2-4j) compl**4j (80.27247582648498-24.104840774806338j) compl**4 (-112+384j) compl/4 (0.5-1j) compl/4j (-1-0.5j) compl**2**1 (-12-16j) str(compl) '(2-4j)' ``` - Операции, которые нельзя выполнить над комплексными чсилами: деление с округлением вниз, взятие остатка от деления,преобразование в список и кортеж ```py compl//4j Traceback (most recent call last): File "", line 1, in compl//4j TypeError: unsupported operand type(s) for //: 'complex' and 'complex' compl//4 Traceback (most recent call last): File "", line 1, in compl//4 TypeError: unsupported operand type(s) for //: 'complex' and 'int' compl%4j Traceback (most recent call last): File "", line 1, in compl%4j TypeError: unsupported operand type(s) for %: 'complex' and 'complex' compl%4 Traceback (most recent call last): File "", line 1, in compl%4 TypeError: unsupported operand type(s) for %: 'complex' and 'int' list(compl) Traceback (most recent call last): File "", line 1, in list(compl) TypeError: 'complex' object is not iterable tuple(compl) Traceback (most recent call last): File "", line 1, in tuple(compl) TypeError: 'complex' object is not iterable ``` ### 5.Операции с двоичными представлениями целых чисел #### 5.1 Двоичная инверсия ```py dv1=9 dv1 9 ``` - В этом случае получается -10 из-за особенноси представления чисел в дополнительном коде. ```py dv2=~dv1 dv2 -10 ``` #### 5.2 Двоичное «И» ```py 7&9 1 7&8 0 ``` #### 5.3 Двоичное «ИЛИ» ```py 7|9 15 7|8 15 14|5 15 ``` #### 5.4 Двоичное «исключающее ИЛИ» ```py 14^5 11 ``` - Проверил какое получилось значение в десятичном представлении ```py type(14^5) int("1011",2) 11 ``` #### 5.5 Сдвиг двоичного представления на заданное число влево или вправо ```py h=14 h 14 bin(h) '0b1110' g=h<<2 g 56 g1=h>>1 g1 7 g2=h>>2 g2 2 ``` #### 5.6 Придумал два двоичных числа и попробовал выполнить с ними разные операции ```py bin(100) '0b1100100' first_binary = 100 #двоичное представление - 1100100 bin(150) '0b10010110' second_binary = 150 #двоичное представление - 10010110 first_binary&second_binary 4 100&150 4 bin(first_binary&second_binary) '0b100' first_binary|second_binary 246 bin(first_binary|second_binary) '0b11110110' first_binary^second_binary 242 bin(first_binary^second_binary) '0b11110010' first_binary<<2 400 first_binary>>1 50 first_binary>>2 25 first_binary>>second_binary 0 second_binary>>first_binary 0 ``` ### 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 ['ку','-']*2 True 'ку' in ['ку','-']*0 False 'ку' in ['ку','-']*4 True 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') False ``` #### 6.4 Изучил подстановка значений в строку с помощью оператора % ```py stroka='Температура = %g %s %g' stroka 'Температура = %g %s %g' stroka % (16,' меньше ',25) 'Температура = 16 меньше 25' stroka 'Температура = %g %s %g' ``` - Подставновка значений из словаря ```py stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' stroka % {'zn1':16,'sravn':' меньше ','zn2':25} 'Температура = 16 меньше 25' ``` ### 7. Операторы присваивания #### 7.1 Оператор "равно" ```py zz=-12 ``` #### 7.2 Операторы сложения и вычитания с изменением исходной переменной ```py zz+=5 zz -7 zz-=3 stroka='Система' stroka+=' регулирования' stroka 'Система регулирования' a = 'ПОАС' a + 'лаба3' 'ПОАСлаба3' a 'ПОАС' ``` #### 7.3 Оператор деления и умножения текущей переменной ```py zz/=2 zz -5.0 zz*-5 25.0 zz -5.0 zz*=5 string = 'лаба 3' string*=5 string 'лаба 3лаба 3лаба 3лаба 3лаба 3' ``` #### 7.4 Операторы деления переменной с округлением вниз и взятие остатка от деления ```py b = 100 b//=4 b 25 b%=8 b 1 ``` #### 7.5 Оператор возведения в степень ```py b**=100 b 1 b+=2 b**=15 b 14348907 ``` #### 7.6 Множественное присваивание ```py w=v=10 w 10 n1,n2,n3=(11,-3,'all') print(n1,n2,n3) 11 -3 all ``` - Проверил можно ли использовать множественное присваивание с объектами: строка, список, кортеж, словарь ```py n1,n2,n3='abc' print(n1,n2,n3) a b c n1,n2,n3=[11,-3,'all'] print(n1,n2,n3) 11 -3 all n1,n2,n3={11: 'a',3: 'b',5: 'c'} print(n1,n2,n3) 11 3 5 n1,n2,n3={'a','b','c'} print(n1,n2,n3) a c b ``` ### 8 Изучаю логические операции #### 8.1 Операции сравнения ```py w==v True w!=v False w>v False wv SyntaxError: invalid syntax w>=v True ``` #### 8.2 Проверка наличия заданного элемента в различных объектах - Проверка наличия элемента в множестве ```py mnoz1={'pen','book','pen','iPhone','table','book'} 'book' in mnoz1 True 'cap' in mnoz1 False ``` - Проверка наличия элемента в словаре ```py dic1={'Saratov':145, 'Orel':56, 'Vologda':45} 'Vologda' in dic1 True 'Pskov' in dic1 False ``` - Проверка наличия элемента среди значений словаря ```py 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 'UII' in dct1.values() False dct1['Depart'][1] == 'MM' False ``` #### 8.3 Создание больших логических выражений ```py a=17;b=-6 (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1) True ``` - Самостоятельно придумал составные логические выражения ```py (a>=b) and ('cap' in mnoz1) and not ('Pskov' in dic1) False (a==b) and ('cap' in mnoz1) and not ('Moscow' in dic1) False (a>=b) or ('cap' in mnoz1) or ('Moscow' in dic1) True ``` #### 8.4 Проверка ссылок переменных на один и тот же объект с помощью is - w и v ссылаются на один и тот же часток памяти ```py w = v = 10 w is v True ``` - w1 и v1 ссылаются на разные объекты в памяяти -> вывелось False ```py w1=['A','B'] v1=['A','B'] w1 is v1 False ``` ### 9.Операции с объектами, выполняемые с помощью методов: join, split и так далее #### 9.1 Методы для работы со строками - Посмотрел доступные методы для объекта типа str ```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'] stroka.find('пр') 5 stroka.count("с") 4 stroka.replace(' у',' автоматического у') 'Микропроцессорная система автоматического управления' stroka 'Микропроцессорная система управления' stroka.replace(' у',' автоматического ') 'Микропроцессорная система автоматического правления' ``` - split() Возвращает список подстрок, между которыми в строке стоит заданный разделитель ```py spis22=stroka.split(' ') spis22 ['Микропроцессорная', 'система', 'управления'] stroka.upper() 'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ' ``` - join() Возвращает строку, собранную из элементов списка ```py stroka3=" ".join(spis22) stroka3 'Микропроцессорная система управления' ``` - partition() Возвращает кортеж, с результатами поиска «с» слева/справа. Если элемент найден, то вернется кортеж с тремя частимя: до элемента, сам элемент, оставшаяся часть строки. В случаи отсутствия элемента, вернется кортеж с исходной строкой и None,None ```py stroka3.partition("с") ('Микропроце', 'с', 'сорная система управления') stroka3.rpartition("с") ('Микропроцессорная си', 'с', 'тема управления') ``` #### 9.2 Методы format для работы со строками ```py strk1='Момент времени {}, значение = {}' strk1.format(1,89.7) 'Момент времени 1, значение = 89.7' print(strk1) Момент времени {}, значение = {} ``` - В методе format можно указать номер элемента, который поставится на нужное место ```py 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.3 Методы для работы со списками - Посмотрел доступные методы ```py spsk = [1,2,3,4,5] 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'] ``` - Удаление элемента по номеру ```py spsk.pop(2) 3 spsk [1, 2, 4, 5] ``` - Добавление элемента ```py spsk.append('c') spsk [1, 2, 4, 5, 'c'] spsk.insert(2,'a') spsk [1, 2, 'a', 4, 5, 'c'] spsk.count('a') 1 ``` #### 9.3 Изучаю методы для работы с кортежами ```py cort = (1,2,3,4,5) dir(cort) ['__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'] cort.count(5) 1 cort.index(5) 4 ``` #### 9.4 Методы для работы со словарями ```py vocabulary = {1: 'первый',2: 'второй', 5: 'пятый'} vocabulary {1: 'первый', 2: 'второй', 5: 'пятый'} dir(vocabulary) ['__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'] vocabulary.values(); vocabulary.keys() dict_values(['первый', 'второй', 'пятый']) dict_keys([1, 2, 5]) ``` - При удалении из словаря обязательно нужно указать ключ, который хотим удалить ```py vocabulary.pop(1) 'первый' vocabulary {2: 'второй', 5: 'пятый'} vocabulary.items() dict_items([(2, 'второй'), (5, 'пятый')]) vocabulary.update({1: 'первый'}) vocabulary {2: 'второй', 5: 'пятый', 1: 'первый'} vocabulary[10] = 'ten' vocabulary {2: 'второй', 5: 'пятый', 1: 'первый', 10: 'ten'} ``` - Метод get вернет значение по ключу или же при отсутствии ключа - второй параметр из get() ```py vocabulary.get(2) 'второй' vocabulary.get(2,'ret') 'второй' vocabulary.get(11,'ret') 'ret' vocabulary.clear() vocabulary {} ``` #### 9.5 Методы для работы со множествами ```py my_set = {1,2,3,4,5} type(my_set) dir(my_set) ['__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'] my_set.update({6,7}) my_set {1, 2, 3, 4, 5, 6, 7} my_set.add(120) my_set {1, 2, 3, 4, 5, 6, 7, 120} my_set.pop() 1 my_set.pop() 2 my_set {3, 4, 5, 6, 7, 120} my_set.remove(120) my_set {3, 4, 5, 6, 7} ``` - При использовании copy() исходный объект не будет изменятся ```py new = my_set.copy() new {3, 4, 5, 6, 7} my_set.add(120) new {3, 4, 5, 6, 7} my_set {3, 4, 5, 6, 7, 120} ``` - Пересечение множеств и очистка ```py new.intersection(my_set) {3, 4, 5, 6, 7} new.add(1500) new.intersection(my_set) {3, 4, 5, 6, 7} new.clear();my_set.clear() my_set;new set() set() ```