From 36f8fafbad48b941a0a6bd009e70a5a283d12ec8 Mon Sep 17 00:00:00 2001 From: TabolinIA Date: Mon, 29 Sep 2025 12:42:38 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D1=82=D1=87=D0=B5=D1=82=20=D0=A2=D0=B5?= =?UTF-8?q?=D0=BC=D0=B0=203?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA3/report3.md | 727 +++++++++++++++++++++++++++++++++++++++++++++++ TEMA3/task3.md | 59 ++++ 2 files changed, 786 insertions(+) create mode 100644 TEMA3/report3.md create mode 100644 TEMA3/task3.md diff --git a/TEMA3/report3.md b/TEMA3/report3.md new file mode 100644 index 0000000..33600cb --- /dev/null +++ b/TEMA3/report3.md @@ -0,0 +1,727 @@ +# Отчёт по Теме 3 +Таболин Иван А-01-23 +## 1. Запуск и настройка +Запустил IDLE и выполнил начальную настройку, установив рабочий каталог. +```py +import os +os.chdir('C:\\Users\\User\\Desktop\\python-labs\\TEMA3') +``` +## 2. Преобразование простых базовых типов объектов +## 2.1. Преобразование в логический тип +Функция bool() преобразует элемент в логическую переменную +```py +logiz1=bool(56);logiz1 +True +logiz2=bool(0);logiz2 +False +logiz3=bool("Beta");logiz3 +True +logiz4=bool("");logiz4 +False +``` +## 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");tt5 +Traceback (most recent call last): + File "", line 1, in + tt5=int("98.76");tt5 +ValueError: invalid literal for int() with base 10: '98.76' +``` +Преобразование целых чисел или строк в вещественное число с помощью 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. Преобразование десятичных чисел в другие СС +Преобразования в двоичную систему с помощью bin(), в восьмеричную систему с помощью oct(), в шестнадцатиричную систему с помощью hex() +```py +hh=123 +dv1=bin(hh);dv1 +'0b1111011' +vos1=oct(hh);vos1 +'0o173' +shs1=hex(hh);shs1 +'0x7b' +``` +Обратное преобразования +```py +int(dv1) +Traceback (most recent call last): + File "", line 1, in + int(dv1) +ValueError: invalid literal for int() with base 10: '0b1111011' +int(vos1) +Traceback (most recent call last): + File "", line 1, in + int(vos1) +ValueError: invalid literal for int() with base 10: '0o173' +int(shs1) +Traceback (most recent call last): + File "", line 1, in + int(shs1) +ValueError: invalid literal for int() with base 10: '0x7b' +``` +## 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":3});strk5 +"{'A': 1, 'B': 2, 'C': 3}" +``` +## 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') +kort99=tuple({"A":1,"B":2,"C":9}.values());kort99 +(1, 2, 9) +``` +## 3.4. Удаление объектов +Удаление объектов производится с помощью инструкции `del` +```py +del strk5, kort8 +dir() +['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'dv1', 'flt1', 'flt2', 'flt3', 'flt4', 'hh', 'kort1', 'kort7', 'kort9', 'kort99', 'logiz1', 'logiz2', 'logiz3', 'logiz4', 'os', 'shs1', 'spis1', 'spis2', 'spis3', 'spis4', 'strk1', 'strk2', 'strk3', 'strk4', 'tt1', 'tt2', 'tt3', 'tt4', 'tt6', 'vos1'] +``` +Создание строки с фамилией и инициалами и последующие преобразования: строка -> список -> кортеж -> строка +```py +my_name="TabolinIA" +my_name_spis=list(my_name);my_name_spis +['T', 'a', 'b', 'o', 'l', 'i', 'n', 'I', 'A'] +my_name_kort=tuple(my_name_spis);my_name_kort +('T', 'a', 'b', 'o', 'l', 'i', 'n', 'I', 'A') +my_name_str=str(my_name_kort);my_name_str +"('T', 'a', 'b', 'o', 'l', 'i', 'n', 'I', 'A')" +my_name==my_name_str +False +``` +## 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;type(a) +3.9555555555555557 + +b=25/5;b;type(b) +5.0 + +``` +Результат деления - всегда вещественное число +## 4.4. Деление с округлением вниз +```py +b=178//45 +b +3 +c=-24.6//12.1;c +-3.0 +c1=-24.6/12.1;c1 +-2.0330578512396698 +type(b) + +type(c) + +``` +```py +c2=12/3.99999 +c2;type(c2) +3.00000750001875 + +c2=12//3.99999 +c2;type(c2) +3.0 + +c3=12.000001//4;c3;type(c3) +3.0 + +c4=12//4;c4;type(c4) +3 + +c5=12//5;c5;type(c5) +2 + +``` +Если хотя бы один элемент в выражении является вещественным числом, результат будет вещественным. +## 4.5. Получение остатка от деления +```py +148%33 +16 +12.6%3.8 +1.2000000000000002 +12%4 +0 +12%0 +Traceback (most recent call last): + File "", line 1, in + 12%0 +ZeroDivisionError: integer modulo by zero +2.5%1 +0.5 +2.5%0.5 +0.0 +5%1.5 +0.5 +``` +## 4.6. Возведение в степень +```py +14**3 +2744 +e=2.7**3.6;e +35.719843790663525 + +2**2.5 +5.656854249492381 +2.5**2 +6.25 +True**4 +1 +0**2 +0 +2**0 +1 +-12**2 +-144 +(-12)**2 +144 +``` +Операции с комплексными числами +```py +compl1=(2-3j) +type(compl1) + +compl2=(3+5j) +sum_compl=compl1+compl2 +sum_compl +(5+2j) +razn_compl=compl2-compl1 +razn_compl +(1+8j) +proizved_compl=compl1*compl2;proizved_compl +(21+1j) +del_compl=compl2/compl1 +del_compl +(-0.6923076923076924+1.4615384615384617j) +compl1//compl2 +Traceback (most recent call last): + File "", line 1, in + compl1//compl2 +TypeError: unsupported operand type(s) for //: 'complex' and 'complex' +compl1//2 +Traceback (most recent call last): + File "", line 1, in + compl1//2 +TypeError: unsupported operand type(s) for //: 'complex' and 'int' +2//compl1 +Traceback (most recent call last): + File "", line 1, in + 2//compl1 +TypeError: unsupported operand type(s) for //: 'int' and 'complex' +0.5//compl1 +Traceback (most recent call last): + File "", line 1, in + 0.5//compl1 +TypeError: unsupported operand type(s) for //: 'float' and 'complex' +compl1%compl2 +Traceback (most recent call last): + File "", line 1, in + compl1%compl2 +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' +``` +Такие операции как сложение, вычитание, умножение и деление можно производить с комплексными числами, но операции целочисленного деления и взятия остатка от деления производить с комплексными числами нельзя. +## 5. Операции с двоичными представлениями целых чисел +## 5.1. Двоичная инверсия +Двоичная инверсия - значение каждого бита в представлении числа заменяется на противоположное с помощью `=~` +```py +dv1=9 +dv2=~dv1 +bin(dv1);bin(dv2) +'0b1001' +'-0b1010' +dv1;dv2 +9 +-10 +``` +Двоичная инверсия - это не только смена "1" на "0", а "0" на "1", но и смена знака. Это связано с тем, что двоичные числа представлены "по кругу". +9 -> -(9+1), то есть n -> -(n+1) +## 5.2 Двоичное И +Побитовое совпадение двоичных прдставлений чисел +```py +7&9 +1 +bin(7);bin(9);bin(7&9) +'0b111' +'0b1001' +'0b1' + +7&8 +0 +bin(7);bin(8);bin(7&8) +'0b111' +'0b1000' +'0b0' + +bin(7);bin(12);bin(7&12) +'0b111' +'0b1100' +'0b100' +int("0100",2) +4 +``` +## 5.3. Двоичное ИЛИ +Побитовое сравнение двоичных представлений чисел +```py +7|9;bin(7);bin(9);bin(7|9) +15 +'0b111' +'0b1001' +'0b1111' + +7|8;bin(7);bin(8);bin(7|8) +15 +'0b111' +'0b1000' +'0b1111' + +14|5;bin(14);bin(5);bin(14|5) +15 +'0b1110' +'0b101' +'0b1111' + +10|8;bin(10);bin(8);bin(10|8) + +10 +'0b1010' +'0b1000' +'0b1010' +``` +## 5.4. Двоичное исключающее ИЛИ +Побитовое сравнение двоичных представлений чисел, "0" получается только если оба сравниваемых разряда имеют одинаковые значения. +```py +14^5;bin(14);bin(5);bin(14^5) + +11 +'0b1110' +'0b101' +'0b1011' +``` +## 5.5. Сдвиг двоичного представления числа +Сдвиг двоичного представления числа на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями +```py +h=14;g=h<<2;bin(h);bin(g) + +'0b1110' +'0b111000' +g1=h>>1;bin(h);bin(g1) + +'0b1110' +'0b111' +g2=h>>2;bin(h);bin(g2) + +'0b1110' +'0b11' +``` +```py +dv3=int("100100101",2);dv4=int("101010101",2) + +dv5=~dv3;dv5;bin(dv3);bin(dv5) + +-294 +'0b100100101' +'-0b100100110' +dv3&dv4;bin(dv3);bin(dv4);bin(dv3&dv4) + +261 +'0b100100101' +'0b101010101' +'0b100000101' +dv3|dv4;bin(dv3);bin(dv4);bin(dv3|dv4) + +373 +'0b100100101' +'0b101010101' +'0b101110101' +dv3^dv4;bin(dv3);bin(dv4);bin(dv3^dv4) + +112 +'0b100100101' +'0b101010101' +'0b1110000' + +g3=dv3<<2;bin(dv3);bin(g3) + +'0b100100101' +'0b10010010100' +g3 + +1172 +g4=dv4>>3;bin(dv4);bin(g4);g4 + +'0b101010101' +'0b101010' +42 +``` +## 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 +['ку', '-', 'ку', '-', 'ку', '-'] +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 +``` +## 7.2. Увеличение значения переменной на заданную величину +`+=` увеличивает переменную, а `-=` - уменьшает +```py +zz+=5;zz +-7 +zz-=3;zz +-10 +``` +Для последовательностей эта операция означает конкатенацию +```py +stroka='Система' +stroka+='регулирования' +stroka +'Системарегулирования' +``` +## 7.3. Умножение текущего значения +Умножение текущего значения переменной на заданную величину с помощью `*=` или умножение с помощью `/=` +```py +zz/=2;zz +-5.0 +zz*=-5;zz +25.0 +``` +Для строк операция `*=` означает повторение текущего значения объекта заданное число раз +```py +str1='ля-' +str1*=5;str1=str1[:-1];str1 +'ля-ля-ля-ля-ля' +``` +## 7.4. Операции деления с округлением вниз, получения остатка от деления и возведения в степень +Деление с округлением вниз осуществляется с помощью `//=`, получение остатка от деления - `%=`, возведение в степень `**=` +```py +n1=10 +n1//=3 +n1 +3 +n1%=2;n1 +1 +n1=3;n1**=3;n1 +27 +``` +## 7.5. Множественное присваивание +```py +w=v=10;w;v +10 +10 +n1,n2,n3=(11,-3,'all');n1,n2,n3 +(11, -3, 'all') +n1,n2,n3=(11,-3,'Строка символов');n1;n2;n3 +11 +-3 +'Строка символов' +n1,n2,n3=(11,-3,[-1,-2,-3,-4,-5]);n1;n2;n3 +11 +-3 +[-1, -2, -3, -4, -5] +n1,n2,n3=(11,-3,{'A':1,"B":2,"C":3});n1;n2;n3 +11 +-3 +{'A': 1, 'B': 2, 'C': 3} +``` +## 8. Логические операции +Операции при создании логических выражений, дающих в результате вычисления значения True или False +## 8.1. Операции равенства, не равно, меньше, больше, меньше или равно, больше или равно +```py +w,v +(10, 10) +w==v +True +w!=v +False +wv +False +w<=v +True +w>=v +True +5>8 +False +(1+5j)>(-1-5j) +Traceback (most recent call last): + File "", line 1, in + (1+5j)>(-1-5j) +TypeError: '>' not supported between instances of 'complex' and 'complex' +``` +## 8.2. Проверка наличия заданного элемента в последовательности или во множестве, проверка наличия ключа в словаре +Проверка наличия выполняется с помощью `in` +```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']} +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 +dct1['Depart'][3]=='MM' +True +``` +## 8.3. Создание больших логических выражений с использованием соединительных слов +Логическое "И", логическое "ИЛИ", логическое "НЕ" +```py +a=17;b=-6 +(a>=b)and('book' in mnoz1) and not ('Pskov' in dic1) +True + +not (b>a) and (12==12) or not('pen' in mnoz1) +True +(('abc'=='def') or ('123'=='1234')) and ('1' in '0123') +False +``` +## Проверка ссылок переменных на один и тот же объект +Выполняется с помощью `is` +```py +w=v=10 +w is v +True +w1=['A','B'] +v1=['A','B'] +w1 is v1 +False +w1==v1 +True +``` +Так как переменные `w` и `v` были созданы вместе в одну строку, они имеют не только одно и то же значение, но и ссылаются на один и тот же участок памяти. +Списки `w1` и `v1` же созданы в разных строках и ссылаются на разные частки памяти, несмотря на одинаковое содержимое. +## Операции с объектами, выполняемые с помощью методов +Получение списка атрибутов объекта с помощью `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('пр') # возвращает номер позиции первого вхождения указанного контекста +5 +stroka.count("с") # подсчет числа вхождений строки “с” в stroka +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=['Apple','Banana','Watermelon','Pineapple','Orange'] +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) +'Watermelon' +spsk.append('c') + +spsk + +['Apple', 'Banana', 'Pineapple', 'Orange', 'c'] +spsk.insert(2,'a') + +spsk + +['Apple', 'Banana', 'a', 'Pineapple', 'Orange', 'c'] +spsk.count('a') + +1 +``` +Операция `.pop` удаляет из списка первый найденный элемент, который соответствует указанному контексту. +Операция `append` добавляет указанный элемент в конец списка. +Операция `insert` добавляет указанный элемент перед элементом с указанным индексом. +Операция `count` подсчитывает количество указанных элементов в списке. +## 9.3. Методы кортежей +```py +kort1=('Tabolin','Berezhkov','Krishtul','Filippov','Timchenko','Volodin') + +dir(kort1) + +['__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'] +kort1.count('Tabolin') + +1 +kort1.index('Berezhkov') + +1 +``` +## 9.4. Методы словарей и множеств +```py +dict1={"A":1,"B":2,"C":3} + +dir(dict1) + +['__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'] +dict2=dict1.copy() + +dict2 + +{'A': 1, 'B': 2, 'C': 3} +dict1.get('A') + +1 +``` +```py +mnoz1={'A','B','C','D'} + +mnoz1.add('F') + +mnoz1 + +{'A', 'D', 'F', 'C', 'B'} +mnoz1.remove('F') + +mnoz1 + +{'A', 'D', 'C', 'B'} +mnoz2=mnoz1.copy() + +mnoz1;mnoz2 + +{'A', 'D', 'C', 'B'} +{'A', 'B', 'C', 'D'} +``` diff --git a/TEMA3/task3.md b/TEMA3/task3.md new file mode 100644 index 0000000..c372370 --- /dev/null +++ b/TEMA3/task3.md @@ -0,0 +1,59 @@ +# Общее контрольное задание по Теме 3 +Таболин Иван, А-01-23 +## Задание +Реализовать, записать в текстовый файл и проанализировать результаты последовательности ин-струкций, выполняющих следующие действия: +• Преобразовать восьмеричное значение 45 в целое число. +• Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная време-ни":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? +• Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округ-лением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4. +• Напишите и выполните единое выражение, последовательно осуществляющее следующие опера-ции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. +• Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого спи-ска. +• Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов. +• Создать объект - символьную строку с текстом данного предложения. Из символьной строки соз-дать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. +## Решение +```py +import os +os.chdir('C:\\Users\\User\\Desktop\\python-labs\\TEMA3') +int('45',8) +37 +D={"усиление":23,"запаздывание":12,"постоянная времени":78} +spis_keys=list(D);spis_keys +['усиление', 'запаздывание', 'постоянная времени'] +spis_znach=list(D.values());spis_znach +[23, 12, 78] +kort1=tuple(spis_keys) +kort2=tuple(spis_znach) +kort=kort1+kort2 +kort +('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78) +``` +Кортеж отличается от списка тем, что его нельзя изменять +```py +((1768//24.8)%3)**2.4 +5.278031643091577 +(~(13&27)^14)<<2 +-32 +spis1=['колебат']*4 +'аткол' in spis1[1]+spis1[2] +True +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'] +``` +```py +D.keys() +dict_keys(['усиление', 'запаздывание', 'постоянная времени']) +D.values() +dict_values([23, 12, 78]) +``` +С помощью `keys` можно получить ключи словаря, а с помощью `values` - значения. +```py +str1='Создать объект - символьную строку с текстом данного предложения.' +spis2=str1.split() +spis2 +['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.'] +spis2.pop(2) +'-' +spis2.insert(2,',');spis2 +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.'] +spis2.remove('данного');spis2 +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.'] +```