From 2f2a816994b58eda92de4840c7231cf8d7e67fc2 Mon Sep 17 00:00:00 2001 From: BushmanovAS Date: Fri, 10 Oct 2025 11:29:05 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D1=82=D1=87=D0=B5=D1=82=20=D0=BF=D0=BE?= =?UTF-8?q?=20=D1=82=D0=B5=D0=BC=D0=B53?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- TEMA3/task.md | 60 ++ TEMA3/Отчет по теме 3.md | 867 ++++++++++++++++++++++++++++ 2 files changed, 927 insertions(+) create mode 100644 TEMA3/task.md create mode 100644 TEMA3/Отчет по теме 3.md diff --git a/TEMA3/task.md b/TEMA3/task.md new file mode 100644 index 0000000..f429788 --- /dev/null +++ b/TEMA3/task.md @@ -0,0 +1,60 @@ +# Общее контрольное задание по теме 3 + +## Задание +Реализовать, записать в текстовый файл и проанализировать результаты последовательности инструкций, выполняющих следующие действия: +- Преобразовать восьмеричное значение 45 в целое число. +- Создать объект-словарь D со значениями {"усиление":23, "запаздывание":12, "постоянная времени":78} и затем осуществить его преобразование в два списка: ключей и значений, а затем – эти два списка преобразовать в один кортеж. Чем отличается кортеж от списка? +- Напишите и выполните единое выражение, осуществляющее деление числа 1768 на 24.8 с округлением вниз, с определением после этого остатка от деления получившегося значения на 3 и затем возведения результата в степень 2.4. +- Напишите и выполните единое выражение, последовательно осуществляющее следующие операции: двоичное И для чисел 13 и 27, инверсия полученного значения, двоичное исключающее ИЛИ для полученного значения и числа 14, сдвиг полученного значения на два разряда влево. +- Создать список с 4 одинаковыми элементами 'колебат' и написать оператор проверки наличия комбинации символов 'аткол' в результате конкатенации второго и третьего элементов этого списка. +- Определить список методов, доступных у ранее созданного словаря D. Поочередно использовать его методы keys и values, определить, что можно получить с применением этих методов. +- Создать объект - символьную строку с текстом данного предложения. Из символьной строки создать список, элементами которого будут отдельные слова из созданной строки. Заменить в списке элемент «-» на «,». Удалить из списка элемент со значением «данного». Отобразить получившийся список. + +## Решение +``` +>>>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 diff --git a/TEMA3/Отчет по теме 3.md b/TEMA3/Отчет по теме 3.md new file mode 100644 index 0000000..0c50c16 --- /dev/null +++ b/TEMA3/Отчет по теме 3.md @@ -0,0 +1,867 @@ + +# Бушманов Артём, А-01-23 + +## 1. Запуск IDLE + +## 2. Преобразование простых базовых типов объектов. + +### 2.1. Преобразование в логический тип с помощью функции bool(<Объект>). +Примеры использования: + +``` +>>>logiz1 = bool(56) +>>>logiz1 +True +>>>logiz2 = bool(0) +>>>logiz2 +False +>>>logiz3 = bool("Beta") +>>>logiz3 +True +>>>logiz4 = bool(" ") +>>>logiz4 +True +``` + +### 2.2. Преобразование в целое десятичное число объекта с заданной системой счисления. осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной. +Примеры использования: +``` +>>>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' +``` +Как видно, выводится диагностическое сообщение. Выводится оно по причине того, что заданное число вещественное(float), а ожидается значение типа "int". + +Преобразование целых чисел или строк символов в вещественное число – с помощью функции float(<Объект>). +Примеры преобразований: +``` +>>>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. Преобразование десятичных чисел в другие системы счисления: +``` +>>>hh=123 +>>>hh +123 +>>>dv1=bin(hh) #Преобразование в строку с двоичным представлением +>>>dv1 +'0b1111011' +>>>vos1=oct(hh) # Преобразование в строку с восьмеричным представлением +>>>vos1 +'0o173' +>>>shs1=hex(hh) # Преобразование в строку с шестнадцатеричным представлением +>>>shs1 +'0x7b' +``` +Выполним обратные преобразования объектов dv1, vos1, shs1: +``` +>>>int(dv1,2) +123 +>>>int(vos1, 8) +123 +>>>int(shs1, 16) +123 + +``` + +## 3. Преобразования более сложных базовых типов объектов. + +### 3.1. Преобразование в строку символов с помощью функции str(<Объект>). +Примеры использования: +``` +>>>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(<Объект>). +Примеры преобразований: +``` +>>>spis1=list("Строка символов") #Заданная строка разделяется на символы +>>>spis1 +['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'] +>>>spis2=list((124,236,-15,908)) #Кортеж превращается в список +>>>spis2 +[124, 236, -15, 908] +>>>spis3=list({"A":1,"B":2,"C":9}) #Преобразование словаря в список +>>>spis3 +['A', 'B', 'C'] +``` +Инструкция, обеспечивающую создание из того же словаря списка с другими его частями: +``` +>>>spis4 = list({"A":1,"B":2,"C":9}.values()) +>>>spis4 +[1, 2, 9] +``` + +### 3.3. Преобразование элементов объектов в кортеж с помощью функции tuple(<Объект>). +Примеры преобразований +``` +>>>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. Удаление объектов. +Очистить оперативную память от ранее созданных объектов можно с помощью инструкции del. +Пример: +``` +>>>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'? +``` + +Создание строки со своей фамилией и инициалами, преобразование её в список, затем список – в кортеж и, наконец, кортеж – в строку. . +``` +>>>fam = list('Bushmanov') +>>>fam +['B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v'] +>>>kort = tuple(fam) +>>>kort +('B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v') +>>>strk = str(kort) +>>>strk +"('B', 'u', 's', 'h', 'm', 'a', 'n', 'o', 'v')" +``` + +## 4. Арифметические операции. + +### 4.1. Сложение и вычитание (+ и -) +``` +>>>12+7+90 # Сложение целых чисел +109 +>>>5.689e-1 - 0.456 #Вычитание вещественных чисел +0.11289999999999994 +>>>23.6+54 #Сложение вещественного и целого чисел +77.6 +>>>14-56.7+89 # Сложение и вычитание целых и вещественных чисел +46.3 +``` +### 4.2. Умножение (*) +``` +>>>-6.7*12 #Умножение вещественного числа на целое число +-80.4 +``` + +### 4.3. Деление (/). (Результатом деления всегда будет вещественное число!) +``` +>>>-234.5/6 #Деление вещественного числа на целое +-39.083333333333336 +>>>a=178/45 #Деление двух целых чисел – проверьте тип объекта a! +a +3.9555555555555557 +type(a) + +``` +### 4.4. Деление с округлением вниз (//). +Здесь результат может быть целым или вещественным. В нижеследующих операциях определите тип результата. +``` +>>>b=178//45 #Деление двух целых чисел +>>>b +3 +>>>type(b) + +>>>c=-24.6//12.1 #Деление двух вещественных чисел +>>>c +-3.0 +>>>type(c) + +>>>zz1 = 78.4 / 16 +>>>zz1 +4.9 +>>>type(zz1) + +>>>zz2 = 78.4 // 16 +>>>zz2 +4.0 +>>>type(zz2) + +>>>zz3 = 78 // 16 +>>>zz3 +4 +>>>type(zz3) + +``` + +### 4.5. Получение остатка от деления (%). +``` +>>>148 % 33 #Остаток от деления двух целых чисел +16 +>>>12.6 % 3.8 #Остаток от деления двух вещественных чисел +1.2000000000000002 +1.2000000000000002 +>>>36 % 12 +0 +>>>36.98 % 23.56 +>>>13.419999999999998 +``` + +### 4.6. Возведение в степень (**). +``` +>>>14**3 +2744 +>>>e=2.7**3.6 #Вещественное число возводится в вещественную степень +>>>e +35.719843790663525 +``` + +Попробуем проделать арифметические операции над комплексными числами. Создадим два +комплексных числа. + +``` +>>>comp1 = (5 + 3j) +>>>comp1 +(5+3j) +>>>type(comp1) + +>>>comp2 = (10 - 5j) +>>>comp2 +(10-5j) +>>>type(comp2) + +``` +Сложение: +``` +>>>comp1 + comp2 +(15-2j) +``` +Вычитание: +``` +>>>comp1 - comp2 +(-5+8j) +``` + +Умножение: +``` +>>>comp1 * comp2 +(65+5j) +``` + +Деление: +``` +>>>comp1 / comp2 +(0.28+0.44j) +``` + +Целочисленное деление: +``` +>>>comp1 // comp2 +Traceback (most recent call last): + File "", line 1, in + comp1 // comp2 +TypeError: unsupported operand type(s) for //: 'complex' and 'complex' +>>>comp1 // 2 +Traceback (most recent call last): + File "", line 1, in + comp1 // 2 +TypeError: unsupported operand type(s) for //: 'complex' and 'int' +``` +Как видим, целочисленное деление нельзя применять к комплексным числам. + +Взятие остатка от деления: +``` +>>>comp1 % comp2 +Traceback (most recent call last): + File "", line 1, in + comp1 % comp2 +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' +>>>comp1 % 2 +Traceback (most recent call last): + File "", line 1, in + comp1 % 2 +TypeError: unsupported operand type(s) for %: 'complex' and 'int' +``` +Как видим, взятие остатка от деления нельзя применять к комплексным числам. + +Возведение в степень: +``` +>>>comp1 ** comp2 +(-652921189.7700557+180781145.7454619j) +>>>comp1**5 +(-6100+2868j) +``` + +## 5. Операции с двоичными представлениями целых чисел. + +### 5.1. Двоичная инверсия (~). +Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0). +``` +>>>dv1 = 9 +>>>dv2 = ~dv1 +>>>dv2 +-10 +>>>bin(dv1) +'0b1001' +>>>bin(dv2) +'-0b1010' +``` +### 5.2. Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел +``` +>>>bin(7&9) +'0b1' +``` +Совпадение единиц только в первом разряде, поэтому итог - 0001 или просто 1 +``` +>>>bin(7&8) +'0b0' +``` +Совпадений единиц нет, итог - 0000 или просто 0 + +### 5.3. Двоичное «ИЛИ» (|) +Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0 +``` +bin(7|9) # 111 или 1001 = 1111 +'0b1111' +bin(7|8) # 111 или 1000 = 1111 +'0b1111' +bin(14|5) # 1110 или 0101 = 1111 +'0b1111' +``` +### 5.4. Двоичное «исключающее ИЛИ»(^) + +Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1. +``` +>>>bin(14^5) # 1110 исключающее или 0101 = 1011 +'0b1011' +``` +Значение в десятичном представление: +``` +>>>14^5 +11 +``` + +### 5.5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева. + +``` +>>>h=14 #Двоичное представление = 1110 +>>>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' +``` +Придумайте два двоичных числа, не менее чем с 7 знаками, и попробуйте выполнить с ними разные операции. + +Возьмем два двоичных числа: +1011001 (в десятичной системе это 89) +10001001 (в десятичной системе это 137) + +1. Двоичная инверсия +``` +>>>~89 +-90 +>>>bin(~89) +'-0b1011010' +``` + +2. Двоичное "И" +``` +>>>bin(89 & 137) +'0b1001' +``` + +3. Двоичное "ИЛИ" +``` +>>>bin(89 | 137) +'0b11011001' +``` + +4. Двоичное "исключающее ИЛИ" +``` +>>>bin(89^137) +'0b11010000' +``` + +5. Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева. +``` +>>>89 >> 2 +22 +>>>bin(89 >> 2) +'0b10110' +>>>137 << 3 +1096 +>>>bin(137 << 3) +'0b10001001000' +``` + +## 6. Операции при работе с последовательностями (строками, списками, кортежами). + +### 6.1. Объединение последовательностей (конкатенация)(+) +``` +>>>'Система '+'регулирования' #Соединение двух строк символов +'Система+ регулирования' +>>>['abc','de','fg']+['hi','jkl'] # Объединение двух списков +['abc', 'de', 'fg', 'hi', 'jkl'] +>>>('abc','de','fg')+('hi','jkl') # Объединение двух кортежей +('abc', 'de', 'fg', 'hi', 'jkl') +``` + +### 6.2. Повторение (*) +``` +>>>'ля-'*5 #Повторение строки 5 раз +'ля-ля-ля-ля-ля-' +>>>['ку','-']*3 #Повторение списка 3 раза +['ку', '-', 'ку', '-', 'ку', '-'] +>>>('кис','-')*4 #Повторение кортежа 4 раза +('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-') +``` +Создание списка со 100 отсчетами сигнала-ступеньки: +``` +>>>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) +``` +>>>stroka='Система автоматического управления' +'автомат' in stroka #Наличие подстроки в строке +True +>>>'ку' in ['ку','-']*3 #Наличие контекста в списке +True +>>>'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl') #Наличие контекста в кортеже +False +``` + +### 6.4. Подстановка значений в строку с помощью оператора «%» + +``` +>>>stroka='Температура = %g %s %g' +'Температура = %g %s %g' +>>>stroka % (16,' меньше ',25) +'Температура = %g %s %g' +``` +Вставка с использованием данных из словаря. +``` +>>>stroka='Температура = %(zn1)g %(sravn)s %(zn2)g' +>>>stroka % {'zn1':16,'sravn':' меньше ','zn2':25} +'Температура = 16 меньше 25' +``` +## 7. Оператор присваивания +### 7.1. Обычное присваивание значения переменной (=) +``` +>>>zz=-12 +>>>zz +-12 +``` + +### 7.2. Увеличение значения переменной на заданную величину (+=) или уменьшение (-=) +``` +>>>zz+=5 # Значение zz увеличивается на 5 +>>>zz +-7 +>>>zz-=3 # Значение уменьшается на 3 +>>>zz +-10 +``` + +Для последовательностей операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением. +``` +>>>stroka = 'Система' +>>>stroka +'Система' +>>>stroka += ' регулирования' +>>>stroka +'Система регулирования' +``` + +### 7.3. Умножение текущего значения переменной на заданную величину (*=) или деление (/=) +``` +>>>zz /= 2 +>>>zz +-5.0 +>>>zz*= 5 +>>>zz +-25.0 +>>>per = 2 +>>>per*=10 +>>>per +20 + ``` + +### 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=). +``` +>>>zz //= 2 +>>>zz +-13.0 +>>>zz %= -2 +>>>zz +-1.0 +>>>per **= 4 +>>>per +160000 +``` + +### 7.5. Множественное присваивание + w=v=10 # Переменным присваивается одно и то же значение + n1,n2,n3=(11,-3,'all') #Значения переменных берутся из кортежа +Самостоятельно проверьте, можно ли вместо кортежа справа использовать строку, список, словарь, множество? +1) Присваивание одного значения двум переменным +``` +>>>w = v =10 +>>>w, v +(10, 10) +``` +2) Присваивание кортежем +``` +n1, n2, n3 = (11, -3, 'all') +n1, n2, n3 +(11, -3, 'all') + +``` +3) Присваивание строкой +``` +>>>a1, a2, a3 = 'red', 'black' , 'blue' +>>>a1, a2, a3 +('red', 'black', 'blue') +``` +4) Присваивание списком +``` +>>>b1, b2, b3 = ["s", 67, None] +>>>b1, b2, b3 +('s', 67, None) +>>>b3 +>>>type(b3) + +``` +5) Присваивание словарем +``` +>>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3} +>>>c1, c2, c3 +('one', 'two', 'three') +``` +По умолчанию в словарях итерируются именно ключи. Если нужно задать значения, надо +указать дополнительно ".value": +``` +>>>c1, c2, c3 = {"one": 1, "two": 2, "three": 3}.values() +>>>c1, c2, c3 +(1, 2, 3) +``` +Если в каждую переменную надо положить именно и ключ, и значение одновременно, можно +использовать метод .items(), который каждую пару(ключ-значение) распределяет в отдельный +кортеж +``` +>>>d1, d2, d3 = {"one": 1, "two": 2, "three": 3}.items() +>>>d1 +('one', 1) +>>>d2 +('two', 2) +>>>d3 +('three', 3) + +``` + + +6) Присваивание множеством +``` +>>>m1, m2, m3 = {100, 23, 59} +>>>m1, m2, m3 +(59, 100, 23) +``` + +## 8. Логические операции + +### 8.1. Операции сравнение: равенство (= =), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) +``` +>>>w == v +True +>>>w != v +False +>>>w < v +False +>>>w > v +False +>>>w >= v +True +``` +Другие примеры: +``` +>>>0 == False +True +>>>0 == True +False +>>>100 != 1000 +True +>>>1200 > 100 +True +>>>1200 < 1000 +False +>>>1200 >= 1000 +True +``` + +### 8.2. Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре (in). + +Операции с множеством +``` +>>>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 +``` +### 8.3. Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not). +``` +>>>a=17 +>>>b=-6 +>>>(a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1) +True +``` +Собственные примеры: +``` +>>>((145) in dic1.values()) and not ('Rostov' in dic1) +True +>>>not(len(dic1) == 3) or (sum(dic1.values()) > 300) or ('ITAE' in dct1['Depart']) +False +``` +### 8.4. Проверка ссылок переменных на один и тот же объект (is). + +w=v=10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти +``` +>>>w is v +True +>>>w1 = ['A', 'B'] +>>>v1 = ['A', 'B'] +>>>w1 is v1 +``` +Но при этом: +``` +False +>>>w1 == v1 +True +``` +Основная разница "= =" и "is": +- is проверяет, являются ли две переменные ссылками на один и тот же объект в памяти +- == проверяет, равны ли значения объектов (содержимое одинаковое) +Переменные целочисленного типа были созданы в одну строку и имеют один и тот же адрес в памяти. `Словари были созданы в разных строках, и адреса разные, т.е. они ссылаются на разные участки в памяти, поэтому is возвращает False. + +## 9. Операции с объектами, выполняемые с помощью методов. +Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например, +``` +>>>stroka = 'Микропроцессорная система управления' +>>>dir(stroka) +['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__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. Методы для работы со строками. +``` +>>>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. +``` +>>>strk1 = 'Момент времени {}, значение = {}' +>>>strk1 +'Момент времени {}, значение = {}' +>>>strk1.format(1, 89.7) +'Момент времени 1, значение = 89.7' +``` +Можно указать порядок: +``` +>>>strk2='Момент времени {1}, значение = {0}:{2}' +>>>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. Методы для работы со списками. +Создайте произвольный список spsk, не менее чем с 5 элементами. Отобразите его атрибуты. +Последовательно обратитесь к методам этого списка с отображением каждый раз полученного списка: +``` +spsk = ["blue", 163, (1, 2), "green", 78.69] #Создаем список +spsk.pop(2) #Удаляем второй элемент из списка +(1, 2) #Удаленный элемент +spsk +['blue', 163, 'green', 78.69] +spsk.append('c') #Добавляем элемент в список, по умолчанию добавляется в конец +spsk +['blue', 163, 'green', 78.69, 'c'] +spsk.insert(2, 'a') #Добавление элемента в список с индексом два +spsk +['blue', 163, 'a', 'green', 78.69, 'c'] +spsk.count('a') #Подсчет элементов 'a' в списке +1 +``` + +### 9.3. Создание кортежа и изучение создания его методов. +``` +>>>cort = ('abc', 52.3, 'a', 167, 3 + 2j) +>>>dir(cort) +['__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'] +>>>cort.count('a') +1 +>>>cort.index(3+2j) +4 +``` +Благодаря функции dir видим, что кортеж имеет меньше атрибутов чем список. + +### 9.4. Методы словарей и множеств. +- Методы словарей +Возьмем уже ранее использованный словарь dic1 +``` +>>>dic1 +{'Saratov': 145, 'Orel': 56, 'Vologda': 45} +>>>dic1.keys() # Возвращение объектов, состоящих только из ключей. +>>>dict_keys(['Saratov', 'Orel', 'Vologda']) +>>dir(dic1) +['__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'] +>>>dic1.items() #Возвращение кортежей из пар ключ-значение +>>>dict_items([('Saratov', 145), ('Orel', 56), ('Vologda', 45)]) +>>>dic1.get("Saratov") #Возвращение значения по ключу +145 +>>>dic1.values() #Возвращение объекта только из значений +>>>dict_values([145, 56, 45]) +>>>dic1["key4"] = 49 #Вызов значения по ключу +>>>dic1 +{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'key4': 49} +>>>dic1_k = dic1.keys() #Создание отдельного объекта, чтобы положить в него dict_keys +>>>dic1_k +>>>dict_keys(['Saratov', 'Orel', 'Vologda', 'key4']) +>>>dic1.popitem() #Удаление последнего добавленного элемента +('key4', 49) +>>>dic1 +{'Saratov': 145, 'Orel': 56, 'Vologda': 45} +>>>dic1_k +>>>dict_keys(['Saratov', 'Orel', 'Vologda']) +>>>dic1.pop("Orel") #Удаление ключа и возвращение значения +56 +``` +- Методы множеств +``` +>>>mn = {1, "per", 35.8, "red", True, 153} #Создаем множество +>>>mn +{1, 35.8, 'per', 153, 'red'} +>>>dir(mn) +['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__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'] +>>>mn.add(6+3j) #Добавление элемента в конец множества +>>>mn +{1, 35.8, 'per', 153, 'red', (6+3j)} +>>>mn.remove(1) #Удаление элемента по значению +>>>mn +{35.8, 'per', 153, 'red', (6+3j)} +>>>mn.discard("red") #Удаление элемента по значению с возвратом None при отсутствии +>>>mn +{35.8, 'per', 153, (6+3j)} +{35.8, 'per', 153, (6+3j)} +>>>print(mn.discard(1000)) +None +>>>mn.pop() #Удаление и возвращение случайного элемента из множества +35.8 +>>>mn +{'per', 153, (6+3j)} +>>>mn.update({63, "klumba"}) #Добавление элементов +>>>mn +{'klumba', 'per', 153, 63, (6+3j)} +``` + +## 10. Сохранение созданного текстового файла протокола в своем рабочем каталоге. Завершение сеанса работы с IDLE. \ No newline at end of file