From 60b1ff7d8c008d5b765c97d9901abb7f02c342b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=BC=D0=B8=D1=82=D1=80=D0=B8=D0=B9=20=D0=90=D0=BD?= =?UTF-8?q?=D1=82=D0=BE=D0=BD=D0=BE=D0=B2?= Date: Fri, 26 Sep 2025 10:34:42 +0300 Subject: [PATCH] task:done lab 3 --- TEMA3/report.md | 886 ++++++++++++++++++++++++++++++++++++++++++++++++ TEMA3/task.md | 87 +++++ TEMA3/test.md | 56 +++ 3 files changed, 1029 insertions(+) create mode 100644 TEMA3/report.md create mode 100644 TEMA3/task.md create mode 100644 TEMA3/test.md diff --git a/TEMA3/report.md b/TEMA3/report.md new file mode 100644 index 0000000..64d4b61 --- /dev/null +++ b/TEMA3/report.md @@ -0,0 +1,886 @@ +# Отчет по теме 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() +``` \ No newline at end of file diff --git a/TEMA3/task.md b/TEMA3/task.md new file mode 100644 index 0000000..c95a88d --- /dev/null +++ b/TEMA3/task.md @@ -0,0 +1,87 @@ +# Общее контрольное задание по теме 2 + +**Антонов Дмитрий, А-03-23** + +## Задание 1 +1. Преобразовать восьмеричное значение 45 в целое число. +## Решение +```py +int('45',8) +``` +## Задание 2 +2. Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная вре-мени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? +## Решение +```py +D = {"усиление":23, "запаздывание":12, "постоянная времени":78} + +klist = list(D.keys()); vallist = list(D.values()) +klist;vallist +['усиление', 'запаздывание', 'постоянная времени'] +[23, 12, 78] + +ktupl = tuple(klist);valtupl = tuple(vallist) +ktupl;valtupl +('усиление', 'запаздывание', 'постоянная времени') +(23, 12, 78) +``` +- Ответ: Кортеж является неизменяемым объектом в отличие от списка. В связи с свойством неязменяемости у кортежа нет некоторых методов, которые есть у списка. +## Задание 3 +3. Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округ-лением вниз, с определением после этого остатка от деления получившегося значения на 3 и за-тем возведения результата в степень 2.4. +## Решение +```py +((1768//24.8)%3)**2.4 +5.278031643091577 +``` +## Задание 4 +4. Напишите и выполните единое выражение, последовательно осуществляющее следующие опера-ции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. +## Решение +```py +(~((13&27))^14)<<2 +-32 +``` +## Задание 5 +5. Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка. +## Решение +```py +newList = ['колебат']*4 +newList +['колебат', 'колебат', 'колебат', 'колебат'] + +newList.append(newList[1]+newList[2]) +newList +['колебат', 'колебат', 'колебат', 'колебат', 'колебатколебат'] + +any('аткол' in element for element in newList) +True + +'аткол' in newList[1] + newList[2] +True +``` +## Задание 6 +6. Определить список методов, доступных у ранее созданного словаря D. Поочередно использо-вать его методы keys и values, определить, что можно получить с применением этих методов. +## Решение +```py +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'] + +D.keys() +dict_keys(['усиление', 'запаздывание', 'постоянная времени']) + +D.values() +dict_values([23, 12, 78]) +``` +## Задание 7 +7. Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. +## Решение +```py +string = "Создать объект - символьную строку с текстом данного предложения" + +new_list = string.replace('-',',').split(' ') +'данного' in new_list +True + +new_list.remove('данного') + +print(new_list) +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения'] +``` diff --git a/TEMA3/test.md b/TEMA3/test.md new file mode 100644 index 0000000..b73c91f --- /dev/null +++ b/TEMA3/test.md @@ -0,0 +1,56 @@ +# Индивидуальное контрольное задание по теме 3 + +**Антонов Дмитрий, А-03-23** + +## Задание +M1_18 +1) Можно ли, используя язык Python, создавать загрузочные программы, исполнимые в среде операционной системы? +- Да, можно, создая скрипт с рсширением .py + +2) Создайте объект-список с 20 убывающими по величине элементами, начиная от 115 с шагом 12. Напишите инструкцию, доказывающую, что создан объект именно требуемого типа. Напишите инструкцию отображения списка атрибутов созданного объекта. +### Решение + +```py +lst = [115 - 20*current for current in range(20)] +lst +[115, 95, 75, 55, 35, 15, -5, -25, -45, -65, -85, -105, -125, -145, -165, -185, -205, -225, -245, -265] +type(lst) + +dir(lst) +['__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'] +``` +3) Напишите инструкцию, проверяющую наличие в списке элемента со значением 47. Если его нет в списке, напишите инструкцию, добавляющую этот элемент в список так, чтобы не нарушить убывающий порядок элементов. Отобразите полученный список. +### Решение +- Способ 1 +```py +47 in lst +False +lst.insert(4,47) +lst +[115, 95, 75, 55, 47, 35, 15, -5, -25, -45, -65, -85, -105, -125, -145, -165, -185, -205, -225, -245, -265] +``` +- Способ 2 +```py +lst.append(47) +lst = sorted(lst,reverse=True) +lst +[115, 95, 75, 55, 47, 35, 15, -5, -25, -45, -65, -85, -105, -125, -145, -165, -185, -205, -225, -245, -265] +``` +4) Преобразуйте список в кортеж. Рассчитайте сумму 6 элементов кортежа, начиная с 5-го от начала. Выведите результат на экран в виде "Сумма элементов=ХХХ". +### Решение +```py +lst = tuple(lst) +sum_of_lst = sum(lst[4:4+6:1]) +print("Сумма элементов={}".format(sum_of_lst)) +Сумма элементов=22 + +``` + +5) Добавьте к кортежу элемент со значением 0. Удалите из него элемент со значением 55. Выведите полученный кортеж на экран. +### Решение +```py +lst=lst+(0,) +lst = lst[None:2:1]+lst[4:None:1] +lst +(115, 95, 47, 35, 15, -5, -25, -45, -65, -85, -105, -125, -145, -165, -185, -205, -225, -245, -265, 0) +``` \ No newline at end of file