From 1ad19e2c7d61725f9ebd7a2dcd160f607058748e Mon Sep 17 00:00:00 2001 From: PodolskyNK Date: Sat, 11 Oct 2025 21:42:47 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D0=BB=20?= =?UTF-8?q?=D0=BE=D1=82=D1=87=D0=B5=D1=82=20=D0=B8=20=D0=9E=D0=9A=D0=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA3/report.md | 805 ++++++++++++++++++++++++++++++++++++++++++++++++ TEMA3/task.md | 62 ++++ 2 files changed, 867 insertions(+) create mode 100644 TEMA3/report.md create mode 100644 TEMA3/task.md diff --git a/TEMA3/report.md b/TEMA3/report.md new file mode 100644 index 0000000..00a8c35 --- /dev/null +++ b/TEMA3/report.md @@ -0,0 +1,805 @@ +# Отчет по теме 3 +## Подольский Никита, А-01-23 +### 1. Запуск IDLE + +### 2. Преобразование простых типов объектов +#### 2.1 Функция `bool()` +```python +>>> logiz1=bool(56) +>>> logiz1 +True +>>> logiz2=bool(0) +>>> logiz2 +False +>>> logiz3=bool('Beta') +>>> logiz3 +True +>>> logiz4=bool(" ") +>>> logiz4 +True +``` + +#### 2.2 Преобразование в целое десятичное число объекта с заданной системой счисления +```python +>>> 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' +``` + +В последней инструкции `tt5=int("98.76")` возникает ошибка, потому что функция `int()` ожидает строку, представляющую целое число, а не вещественное (дробное) число. + + Функция `float()` +```python +>>> 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 Преобразование десятичных чисел в другие системы счисления +``` python +>>> hh=123 +>>> dv1=bin(hh) #Преобразование в строку с двоичным представлением +>>> dv1 +'0b1111011' + +>>> vos1=oct(hh) # Преобразование в строку с восьмеричным представлением +>>> vos1 +'0o173' + +>>>shs1=hex(hh) # Преобразование в строку с шестнадцатеричным представлением +>>> shs1 +'0x7b' + +>>> int(dv1,2) +123 +>>> int(vos1,8) +123 +>>> int(shs1, 16) +123 +``` + +### 3. Изучение преобразования более сложных типов объектов +#### 3.1 Преобразование в строку символов с помощью функции `str()` +```python +>>> 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 Преобразование элементов объекта в список с помощью функции `list()` +``` python +>>> 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'] +``` + +##### Создание из того же словаря списка с другими частями +```python +>>> spis31=list({"A":1,"B":2,"C":9}.values()) +spis31 +[1, 2, 9] +``` + +#### 3.3 Преобразование элементов объектов в кортеж с помощью функции `tuple()` +```python +>>> 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 Удаление объектов +```python +>>> del strk5, kort8 +>>> strk5 +Traceback (most recent call last): + File "", line 1, in + strk5 +NameError: name 'strk5' is not defined. Did you mean: 'strk1'? +>>> kort8 +Traceback (most recent call last): + File "", line 1, in + kort8 +NameError: name 'kort8' is not defined. Did you mean: 'kort7'? +``` + +##### Создание строки с фамилией и инициалами и ее преобразования +``` python +>>> fam = "Podolsky" +>>> im = "N" +>>> ot = "K" +>>> fio = fam + im+ ot +>>> fio +'PodolskyNK' +>>> listfio=list(fio) +>>> listfio +['P', 'o', 'd', 'o', 'l', 's', 'k', 'y', 'N', 'K'] +>>> kort = tuple(listfio) +>>> kort +('P', 'o', 'd', 'o', 'l', 's', 'k', 'y', 'N', 'K') +>>> strkfio = str(kort) +>>> strkfio +"('P', 'o', 'd', 'o', 'l', 's', 'k', 'y', 'N', 'K')" +``` + +### 4. Арифметические операции +#### 4.1 Сложение и вычитание +```python +>>> 12+7+90 # Сложение целых чисел +109 +>>> 5.689e-1 - 0.456 #Вычитание вещественных чисел +0.11289999999999994 +>>> 23.6+54 #Сложение вещественного и целого чисел +77.6 +>>> 14-56.7+89 # Сложение и вычитание целых и вещественных чисел +46.3 +``` + +#### 4.2 Умножение +``` python +>>> -6.7*12 #Умножение вещественного числа на целое число +-80.4 +``` + +#### 4.3 Деление +``` python +>>> -234.5/6 #Деление вещественного числа на целое +-39.083333333333336 +>>> a=178/45 #Деление двух целых чисел – проверьте тип объекта a! +>>> a +3.9555555555555557 +>>> type(a) + +``` + +#### 4.4 Деление с округлением вниз (//) +``` python +>>> b=178//45 #Деление двух целых чисел +>>> b +3 +>>> type(b) + + +>>> c=-24.6//12.1 #Деление двух вещественных чисел +>>> c +-3.0 +>>> type(c) + + +>>> z = 52 // 2.5 +>>> z +20.0 +>>> type (z) + + +>>> zz = 52.5 // 7 +>>> zz +7.0 +>>> type (zz) + +``` + +#### 4.5 Получение остатка от деления (%) +``` python +>>> 148%33 #Остаток от деления двух целых чисел +16 +>>> 12.6%3.8 #Остаток от деления двух вещественных чисел +1.2000000000000002 +>>> 148 % 3.8 +3.6000000000000068 +>>> 12.6 % 3 +0.5999999999999996 +``` + +#### 4.6.  Возведение в степень ** +``` python +>>> 14**3 #Целое число возводится в целую степень148 % 3.8 +2744 + +>>> e=2.7**3.6 #Вещественное число возводится в вещественную степень +>>> e +35.719843790663525 + +>>> 5**2.5 +55.90169943749474 + +>>> 2.5**5 +97.65625 +``` + +##### Другие арифметические операции над комплексными числами +###### Сложение +``` python +>>>> z1 = 2 + 3j +>>> z2 = 4 - 5j +>>> sum_result = z1 + z2 +>>> sum_result +(6-2j) +``` +###### Вычитание +``` python +>>> sub_result = z1 - z2 +>>> sub_result +(-2+8j) +``` +###### Умножение +``` python +>>> mul_result = z1 * z2 +>>> mul_result +(23+2j) +``` +###### Деление +``` python +>>> delen = z1 / z2 +>>> delen +(-0.17073170731707318+0.5365853658536587j) +``` + +###### Возведение в степень +``` python +>>> e = 5**(2+1j) # Получится комплексное число (complex) +>>> e +(-0.9657992483483834+24.98133767058701j) + +>>> f = (3+4j)**2 # Получится комплексное число (complex) +>>> f +(-7+24j) + +>>> g = (2+3j)**1.5 # Получится комплексное число (complex) +>>> g +(0.6603660276815663+6.814402636366296j) +``` + +###### Деление с округлением вниз +``` python +>>> z1 // z2 +Traceback (most recent call last): + File "", line 1, in + z1 // z2 +TypeError: unsupported operand type(s) for //: 'complex' and 'complex' + +>>> z1 // 2 +Traceback (most recent call last): + File "", line 1, in + z1 // 2 +TypeError: unsupported operand type(s) for //: 'complex' and 'int' +``` +Видим, что деление с округлением вниз нельзя использовать с комплексными числами + +###### Взятие остатка от деления + ``` python +>>> z1 % z2 +Traceback (most recent call last): + File "", line 1, in + z1 % z2 +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' + +>>> z1 % 2 +Traceback (most recent call last): + File "", line 1, in + z1 % 2 +TypeError: unsupported operand type(s) for %: 'complex' and 'int' + ``` + Взятие остатка от деления нельзя так же применять к комплексным числам + +### 5. Операции с двоичными представлениями целых чисел +#### 5.1 Двоичная инверсия (~) +``` python +>>> dv1=9 +>>> dv2 = ~dv1 +>>> dv2 +-10 +>>> bin(dv1) +'0b1001' +>>> bin(dv2) +'-0b1010' +``` + +#### 5.2 Двоичное И (&) +``` python +>>> bin(7&9) +'ob1' +>>> bin (7&8) +'0b0' +``` + +#### 5.3 Двоичное ИЛИ (|) +``` python +>>> bin(7|9) # 111 или 1001 = 1111 +'0b1111' +>>> bin(7|8) # 111 или 1000 = 1111 +'0b1111' +>>> bin(14|5) # 1110 или 0101 = 1111 +'0b1111' +``` + +#### 5.4 Двоичное исключающее ИЛИ (^) +``` python +>>> bin(14^5) # 1110 исключающее или 0101 = 1011 +'0b1011' + +>>>14^5 +11 +``` + +#### 5.5 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева. +``` python +>>> h=14 +>>> bin(h) +'0b1110' + +>>> g=h<<2 # Новое двоичное представление = 111000 +>>> g +56 +>>> bin(g) +'0b111000' + +>>> g1=h>>1 # Новое двоичное представление = 0111 +>>> g1 +7 +>>> bin(g1) +'0b111' + +>>> g2=h>>2 # Новое двоичное представление = 0011 +>>> g2 +3 +>>> bin(g2) +'0b11' +``` + +``` python +a = 0b1011101 # это 93 в десятичной системе +b = 0b1100110 # это 102 в десятичной системе +``` + +##### Инверсия +``` python +>>> ainv = ~a +>>> binv = ~b +>>> ainv +-94 +>>> binv +-103 +>>> bin(a) +'0b1011101' +>>> bin (b) +'0b1100110' +``` + +##### Двоичное И + ``` python +>>> andres = a & b +>>> andres +68 +>>> bin(andres) +'0b1000100' + ``` + +##### Двоичное ИЛИ +``` python +>>> orres = a | b +>>> orres +127 +>>> bin(orres) +'0b1111111' +``` + +##### Двоичное исключающее ИЛИ +``` python +>>> isclres = a ^ b +>>> isclres +59 +>>> bin(isclres) +'0b111011' +``` + +##### Сдвиг влево на 2 разряда +``` python +>>> shleft = a << 2 +>>> shleft +372 +>>> bin(shleft) +'0b101110100' +``` + +##### Сдвиг вправо на 3 разряда +``` python +>>> shright = b >> 3 +>>> shright +12 +>>> bin(shright) +'0b1100' +``` + +### 6.  Операции при работе с последовательностями (строками, списками, кортежами) +#### 6.1 Объединение последовательностей (конкатенация)(+) +``` python +>>> 'Система '+'регулирования' #Соединение двух строк символов +'Система регулирования' +>>> ['abc','de','fg']+['hi','jkl'] # Объединение двух списков +['abc', 'de', 'fg', 'hi', 'jkl'] +>>> ('abc','de','fg')+('hi','jkl') # Объединение двух кортежей +('abc', 'de', 'fg', 'hi', 'jkl') +``` + +#### 6.2 Повторение * + ``` python +>>> 'ля-'*5 #Повторение строки 5 раз +'ля-ля-ля-ля-ля-' +>>> ['ку','-']*3 #Повторение списка 3 раза +['ку', '-', 'ку', '-', 'ку', '-'] +>>> ('кис','-')*4 #Повторение кортежа 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 Проверка наличия заданного элемента в последователности (in) +``` python +>>> stroka='Система автоматического управления' +'автомат' in stroka #Наличие подстроки в строке +True +>>> 'ку' in ['ку','-']*3 #Наличие контекста в списке +True +>>> 'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') #Наличие контекста в кортеже +False +``` + +#### 6.4 Подстановка значений в строку с помощью оператора "%" +``` python +>>> 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 Обычное присваивание значения переменной (=) +```python +zz = -12 +``` + +#### 7.2 Увеличение значения переменной на заданную величину (+=) или уменьшение (-=) +``` python +>>> zz+=5 # Значение zz увеличивается на 5 +>>> zz +-7 +>>> zz -= 3 # Значение zz уменьшается на 3 +>>> zz +-10 +``` + +``` python +>>> stroka='Система' +>>> stroka+=' регулирования' +>>> stroka +'Система регулирования' +``` + +#### 7.3 Умножение текущего значения переменной на заданную величину ( * = ) или деление (/=) +``` python +>>> zz/=2 +>>> zz +-5.0 +>>> zz*=5 +>>> zz +-25.0 +``` + +``` python +>>> stroka2='привет' +>>> stroka2*=3 +>>> stroka2 +'приветприветпривет' +``` + +#### 7.4 Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(** =) +``` python +>>> zz //= 2 +>>> zz +-13.0 +>> zz %= -2 +>> zz +-1.0 +>> step = 21 +>> step **= 4 +>> step +194481 +``` + +#### 7.5 Множественное присваивание +``` python +>>> w=v=10 # Переменным присваивается одно и то же значение +>>> n1,n2,n3=(11,-3,'all') #Значения переменных берутся из кортежа +``` + +##### Присваивание кортежу +``` python +>>> a1, a2, a3 = "a", "b", "c" # Строка +>>> a1, a2, a3 +('a', 'b', 'c') +>>> b1, b2, b3 = ["a", 1, None] # Список +>>> b1 +'a' +>>> b3 +>>> c1, c2, c3 = {"one": 1, "two": 2, "three": 3} # Словарь +>>> c1, c2, c3 +('one', 'two', 'three') +>>> m1, m2, m3 = {52, 0, 3} # Множество +>>> m1, m2, m3 +(0, 3, 52) +``` + +### 8. Логические операции - при создании логических выражений, дающих в результате вычисления значения  True или False +#### 8.1 Операции сравнение: равенство ( = = ), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) +``` python +>>> w +10 +>>> v +10 +>>> w==v # Равенство +True +>>> w!=v # Не равно +False +>>> w>> w<=v # Меньше или равно +True +``` + +#### 8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in) +##### Операции с множеством +``` python +>>> 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] == 'MM' +False +``` + +#### 8.3 Создание больших логических выражений с использованием соединительных слов. + +``` python +>>> a=17 +>>> b=-6 +>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1) +True +``` + +```python +>>> (a < 20 or b == -6) and not ('pen' in mnoz1) +False +>>> not (a == 0) and ('Moscow' in dic1 or 'book' not in mnoz1) +False +``` + +#### 8.4 Проверка ссылок переменных на один и тот же объект (is) + +``` python +>>> w=v=10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти +>>> w is v +True +>>> w1=['A','B'] +>>> w1 +['A', 'B'] +>>> v1=['A','B'] +>>> v1 +['A', 'B'] +>>> w1 is v1 +False +``` + +Когда создаю переменные w и v с одним числом, они ссылаются на один и тот же объект в памяти, поэтому `w is v` выдаёт True. +А когда создаю два одинаковых списка, w1 и v1, то это уже два разных объекта, хоть и одинаковых по содержанию, поэтому `w1 is v1` выдаёт False. + +### 9. Операции с объектами, выполняемые с помощью методов +``` python +>>> 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 Методы для работы со строками +``` python +>>> stroka.find('пр') #Возвращает номер позиции первого вхождения указанного контекста или значение -1 +5 +>>> stroka.count("с") #Подсчет числа вхождений строки “с” в stroka +4 +>>> stroka.replace(' у',' автоматического у') +'Микропроцессорная система автоматического управления' +>>> spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит за-данный разделитель +>>> spis22 +['Микропроцессорная', 'система', 'управления'] +>>> stroka.upper() #Возвращает строку со всеми заглавными буквами +'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ' +>>> stroka3=" ".join(spis22) #Возвращает строку, собранную из элементов списка +>>> stroka3 +'Микропроцессорная система управления' +>>> stroka3.partition("с") #Возвращает кортеж с результатами поиска «с» слева +('Микропроце', 'с', 'сорная система управления') +>>> stroka3.rpartition("с") #Возвращает кортеж с результатами поиска «с» справа +('Микропроцессорная си', 'с', 'тема управления') +``` + +Метод `format` в Python применяется для красивого и удобного подставления данных внутрь строки. В строке делаются специальные “места” — фигурные скобки {}, а внутрь них можно подставить значения через `.format(...)`. + +``` python +>>> strk1='Момент времени {}, значение = {}' +>>> strk1.format(1,89.7) +'Момент времени 1, значение = 89.7' +``` + +``` python +>>> strk2='Момент времени {1}, значение = {0}:{2}' +>>> strk2.format(36.7,2,'норма!') +'Момент времени 2, значение = 36.7:норма!' +``` + +#### 9.2 Методы для работы со списками +``` python +>>> spsk = ["apple", 52, (6, 9), "macbook", 52.52] #Создаю произвольный список +>>> spsk.pop(2) # Удаляет элемент с индексом 2 +(6, 9) +>>> spsk.append('c') # Добавляет в конец списка элемент 'c' +>>> spsk +['apple', 52, 'macbook', 52.52, 'c'] +>>> spsk.insert(2,'a') # Вставляет элемент 'a' на место индекса 2 +>>> spsk +['apple', 52, 'a', 'macbook', 52.52, 'c'] +>>> spsk.count('a') # Подсчитывает количество 'a', которые встречаются в списке +1 +``` + +#### 9.3 Самостоятельно создайте кортеж и изучите применение его методов. +``` python +>>> my_tuple = (5, 2, 7, 2, 9, 2) +>>> count_2 = my_tuple.count(2) # Считает, сколько раз 2 встречается в кортеже +>>> count_2 +3 +>>> index_7 = my_tuple.index(7) # Находит индекс первого появления 7 в кортеже +>>> index_7 +2 +>>> my_tuple +(5, 2, 7, 2, 9, 2) +``` + +#### 9.4 Словари и множества +#### Словари +``` python +>>> d = {'name': 'Оля', 'age': 20} +>>> d.get('age') +20 +>>> d.get('city', 'Москва') +'Москва' +>>> list(d.keys()) +['name', 'age'] +>>> list(d.values()) +['Оля', 20] +>>> list(d.items()) +[('name', 'Оля'), ('age', 20)] +>>> d.update({'city': 'Москва'}) +>>> d +{'name': 'Оля', 'age': 20, 'city': 'Москва'} +>>> d.pop('age') +20 +>>> d +{'name': 'Оля', 'city': 'Москва'} +>>> d.clear() +>>> d +{} +>>> d2 = d.copy() +>>> d2 +{} +``` + +#### Множество + +``` python +>>> s = {1, 2, 3} +>>> s.add(4) +s +{1, 2, 3, 4} +>>> s.remove(2) +>>> s +{1, 3, 4} +>>> s.discard(3) +>>>> s +{1, 4} +>>> x=s.pop() +>>> x +1 +>>> x,s +1 {4} +>>> s.clear() +>>> s +>>> set() +>>> s2=s.copy() +>>> s.update([5,6]) +>>> s +{5, 6} +>>> s3 = s.union({7, 8}) +>>> s3 +{8, 5, 6, 7} +>>> s4 = s.intersection({5, 6, 9}) +>>> s4 +{5, 6} +>>> s5 = s.difference({4, 6}) +>>> s5 +{5} +>>> s6 = s.symmetric_difference({5, 9}) +>>> s6 +{9, 6} +>>> {5}.issubset(s) +True +>>> s.issuperset({5}) +True +>>> {10, 11}.isdisjoint(s) +True +``` + +### 10. Завершил работу со средой diff --git a/TEMA3/task.md b/TEMA3/task.md new file mode 100644 index 0000000..2bf850d --- /dev/null +++ b/TEMA3/task.md @@ -0,0 +1,62 @@ +# Общее контрольное задание по теме 3 +Подольский Никита, А-01-23 +## Задание +Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия: + +- Преобразовать восьмеричное значение 45 в целое число. +- Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? +- Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4. +- Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. +- Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка. +- Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов. +- Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. + +## Решение +```python +>>>celoe = int(vosm, 8) +>>>celoe +37 +>>>D = {"усиление":23, "запаздывание":12, "постоянная времени":78} +>>>spisok_klychey = list(D.keys()) +>>>spisok_klychey +['усиление', 'запаздывание', 'постоянная времени'] +>>>spisok_znach = list(D.values()) +>>>spisok_znach +[23, 12, 78] +>>>obsh_kort = tuple(spisok_klychey + spisok_znach) +>>>obsh_kort +('усиление', 'запаздывание', 'постоянная времени', 23, 12, 78) +>>>dir(obsh_kort) +['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] +>>>result1 = ((1768 // 24.8) % 3) ** 2.4 +5.278031643091577 +>>>result2 = (~(13 & 27) ^ 14) << 2 +>>>result2 +-32 +>>>spisok_kolebat = ['колебат'] * 4 +>>>spisok_kolebat +['колебат', 'колебат', 'колебат', 'колебат'] +>>>komb = spisok_kolebat[1] + spisok_kolebat[2] +>>>komb +'колебатколебат' +>>>'аткол' in komb +True +>>>dir(D) +['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__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]) #Получаем список значений +>>>obj = "Создать объект - символьную строку с текстом данного предложения." +>>>obj_l = obj.split() +>>>obj_l +['Создать', 'объект', '-', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.']3 + +>>>obj_l[obj_l.index("-")] = "," +obj_l +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'данного', 'предложения.'] +>>>obj_l.remove("данного") +>>>obj_l +['Создать', 'объект', ',', 'символьную', 'строку', 'с', 'текстом', 'предложения.'] + +``` \ No newline at end of file