diff --git a/TEMA3/report.md b/TEMA3/report.md new file mode 100644 index 0000000..b844dd0 --- /dev/null +++ b/TEMA3/report.md @@ -0,0 +1,572 @@ +# Отчет по теме 3 +Бережков Дмитрий, А-01-23 + +## Начало работы. +Запуск IDLE, установление рабочего каталога. +## 2. Преобразование простых базовых типов объектов. +2.1 Преобразование в логический тип с помощью функции bool. +```py +>>> logiz1=bool(56) +>>> logiz2=(0) +>>> logiz3=bool("Beta") +>>> logiz4=bool("") +>>> logiz1 +True +>>>logiz2 +0 +>>> logiz3 +True +>>> logiz4 +False +``` +2.2 Преобразование в целое десятичное число / в вещественное число. +```py +>>> tt1=int(198.6) #Отбрасывается дробная часть +>>> tt2=int("-76") #Число - встроке символов, система по умолчанию - десятичная +>>> tt3=int("B",16) +>>> tt4=int("71",8) +>>> 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' +``` +int() ожидает увидеть целочисленное значение в строке. +```py +>>> flt1=float(789) +>>> flt2=float(-6.78e2) +>>> flt3=float("Infinity") +>>> flt4=float("-inf") +>>> flt1 +789.0 +>>> flt2 +-678.0 +>>> flt3 +inf +>>> flt4 +-inf +``` +2.3 Преобразование десятичных чисел в другие системы счисления: +```py +>>> hh=123 +>>> dv1=bin(hh) #Преобразование в строку с двоичным представлением +>>> vos1=oct(hh) # Преобразование в строку с восьмеричным представлением +>>> shs1=hex(hh) # Преобразование в строку с шестнадцатеричным представлением +>>> dv1 +'0b1111011' +>>> vos1 +'0o173' +>>> shs1 +'0x7b' +``` +Обратное преобразование: +```py +>>> int(dv1, 2) +123 +>>> int(vos1, 8) +123 +>>> int(shs1, 16) +123 +``` +## 3. Изучение преобразования более сложных базовых типов объектов. +3.1 Преобразование в строку символов. +```py +>>> strk1=str(23.6) +>>> strk2=str(logiz3) +>>> strk3=str(["A","B","C"]) #Преобразуем список +>>> strk4=str(("A","B","C")) #Преобразуем кортеж +>>> strk5=str({"A":1,"B":2,"C":9}) #Преобразуем словарь +>>> strk1 +'23.6' +>>> strk2 +'True' +>>> strk3 +"['A', 'B', 'C']" +>>> strk4 +"('A', 'B', 'C')" +>>> strk5 +"{'A': 1, 'B': 2, 'C': 9}" +``` +3.2 Преобразование элементов объекта в список. +```py +>>> spis1=list("Строка символов") #Заданная строка разделяется на символы +>>> spis2=list((124,236,-15,908)) #Кортеж превращается в список +>>> spis3=list({"A":1,"B":2,"C":9}) #Преобразование словаря в список +>>> spis1 +['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'] +>>> spis2 +[124, 236, -15, 908] +>>> spis3 +['A', 'B', 'C'] +``` +Придумал инструкцию, обеспечивающую создание из того же словаря списка с другими его частями: +```py +>>> spis3=list({"A":1,"B":2,"C":9}.values()) +>>> spis3 +[1, 2, 9] +``` +3.3 Преобразование элементов объектов в кортеж: +```py +>>> kort7=tuple('Строка символов') #Преобразование строки символов в кортеж +>>> kort8=tuple(spis2) #Преобразование списка в кортеж +>>> kort9=tuple({"A":1,"B":2,"C":9}) #Преобразование словаря в кортеж +>>> kort7 +('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в') +>>> kort8 +(124, 236, -15, 908) +>>> kort9 +('A', 'B', 'C') +``` +3.4 Удаление объектов: +```py +>>> 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'? +``` +Создал строку со своей фамилией и инициалами, преобразовал её в список, затем список в кортеж и, наконец кортеж в строку: +```py +>>> fio='Berezhkov D. A.' +>>> list_fio=list(fio) +>>> cort_fio=tuple(list_fio) +>>> str_fio=str(cort_fio) +>>> list_fio +['B', 'e', 'r', 'e', 'z', 'h', 'k', 'o', 'v', ' ', 'D', '.', ' ', 'A', '.'] +>>> cort_fio +('B', 'e', 'r', 'e', 'z', 'h', 'k', 'o', 'v', ' ', 'D', '.', ' ', 'A', '.') +>>> str_fio +"('B', 'e', 'r', 'e', 'z', 'h', 'k', 'o', 'v', ' ', 'D', '.', ' ', 'A', '.')" +``` +## 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 +3.9555555555555557 +type(a) + +``` +4.4 Деление с округлением вниз: +Здесь результат может быть целым или вещественным. +```py +>>> b=178//45 #Деление двух целых чисел +>>> b +3 +>>> c=-24.6//12.1 #Деление двух вещественных чисел +>>> c +-3.0 +>>> type(b) + +>>> type(c) + +>>> d=54.54//2 +>>> d +27.0 +>>> type(d) + +``` +4.5 Получение остатка от деления: +```py +>>> 148%33 #Остаток от деления двух целых чисел +16 +>>> 12.6%3.8 #Остаток от деления двух вещественных чисел +1.2000000000000002 +>>> 1337.1337%54 +41.13370000000009 +``` +4.6 Возведение в степень: +```py +>>> 14**3 #Целое число возводится в целую степень +2744 +>>> e=2.7**3.6 #Вещественное число возводится в вещественную степень +>>> e +35.719843790663525 +>>> 5**3.2 +172.4662076826519 +>>> (2+3j)**3 +(-46+9j) +``` +К комплексным числам можно применять следующие операции: + +сложение +вычитание +умножение +деление +возведение в степень +и нельзя следующие: +1) целочисленное деление +```py +>>> k1=1+4j +>>> k2=8-3j +>>> k2//k1 +Traceback (most recent call last): + File "", line 1, in + k2//k1 +``` +(целочисленное деление требует целой части, не мнимой) +2) остаток от деления +```py +k1%k2 +Traceback (most recent call last): + File "", line 1, in + k1%k2 +TypeError: unsupported operand type(s) for %: 'complex' and 'complex' +``` +(остаток от деления основан на целочисленном делении, также работа с мнимой частью не предусмотрена) +## 5. Операции с двоичными представлениями целых чисел. +5.1 Двоичная инверсия: +```py +>>> dv1=9 +>>> dv2=~dv1 +>>> dv2 +-10 +``` +Почему результат отрицательный - используется дополнительный код для представления отрицательных чисел +5.2 Двоичное «И»: +```py +>>> 7&9 # 111 и 1001 = 0001 +1 +>>> 7&8 # 111 и 1000 = 0000 +0 +``` +5.3 Двоичное «ИЛИ»: +```py +>>> 7|9 # 111 или 1001 = 1111 +15 +>>> 7|8 # 111 или 1000 = 1111 +15 +>>> 14|5 # 1110 или 0101 = 1111 +15 +``` +5.4 Двоичное исключающее "Или": +```py +14^5 # 1110 исключающее или 0101 = 1011 +11 +``` +5.5 Двоичное исключающее "Или" (Влево или вправо): +```py +>>> h=14 #Двоичное представление = 1110 +>>> g=h<<2 # Новое двоичное представление = 111000 +>>> g1=h>>1 # Новое двоичное представление = 0111 +>>> g2=h>>2 # Новое двоичное представление = 0011 +>>> h +14 +>>> bin(h) +'0b1110' +>>> g +56 +>>> g1 +7 +>>> g2 +3 +``` +Придумал два двоичных числа, не менее чем с 7 знаками, и попробовал выполнить с ними разные операции: +```py +>>> a=182 +>>> b=107 +>>> a&b +34 +>>> a|b +255 +>>> a^b +221 +``` +## 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 #Повторение строки 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 Проверка наличия заданного элемента в последовательности: +```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 +>>> zz +-12 +``` +7.2 Увеличение значения переменной на заданную величину или уменьшение: +```py +>>> zz+=5 # Значение zz увеличивается на 5 +>>> zz +-7 +>>> zz-=3 # Значение уменьшается на 3 +>>> zz +-10 +``` +7.3 Умножение текущего значения переменной на заданную величину или деление: +```py +>>> zz/=2 +>>> zz +-5.0 +>>> zz*=5 +>>> zz +-25.0 +>>> xx=5 +>>> xx*=3 +>>> xx +15 +>>> xx/=5 +>>> xx +3.0 +``` +7.4 Операции деления с округлением вниз, получения остатка от деления и возведения в степень: +```py +>>> xx=5 +>>> xx//=2 +>>> xx +2 +>>> xx=5 +>>> xx%=2 +>>> xx +1 +>>> xx=5 +>>> xx**=4 +>>> xx +625 +``` +7.5 Множественное присваивание: +```py +>>> w=v=10 # Переменным присваивается одно и то же значение +>>> n1,n2,n3=(11,-3,'all') #Значения переменных берутся из кортежа +>>> w,v +(10, 10) +>>> n1,n2,n3 +(11, -3, 'all') +``` +Проверил можно ли использовать множественное присваивание с объектами: строка, список, кортеж, словарь: +```py +>>> n1,n2,n3='abc' +>>> n1,n2,n3 +('a', 'b', 'c') +>>> n1,n2,n3=[11,-3,'all'] +>>> n1,n2,n3 +(11, -3, 'all') +>>> n1,n2,n3={11: 'a',3: 'b',5: 'c'} +>>> n1,n2,n3 +(11, 3, 5) +>>> n1,n2,n3={'a','b','c'} +>>> n1,n2,n3 +('b', 'a', 'c') +``` +## 8. Логические операции. +8.1 Операции сравнения: +```py +>>> w==v +True +>>> w!=v +False +>>> w>> w>v +False +>>> w<=v +True +>>> w>=v +True +``` +8.2 Проверка наличия заданного элемента в последовательности или во множестве, а также проверка наличия ключа в словаре: +```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']} +>>> 'UII' in dct1['Depart'] +True +>>> dct1['Depart'][1] == 'MM' +False +``` +8.3 Создание больших логических выражений с использованием соединительных слов: +```py +>>> a=17 +>>> b=-6 +>>> (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1) +True +>>> (a == b) and ('Vologda' in dic1) or ('Pskov' in dic1) +False +>>> (a > b) or 'book' in mnoz1 +True +``` +8.4 Проверка ссылок переменных на один и тот же объект: +```py +>>> w=v=10 #При таком присваивании переменные ссылаются на один и тот же объект в оперативной памяти +>>> w is v +True +>>> w1=['A','B'] +>>> v1=['A','B'] +>>> w1 is v1 +False +``` +В начале присваивания двум переменным w и v значения 10 мы храним обе переменные в одной ячейке памяти, затем мы по отдельности присвоили двум этим переменным списки, они хоть и одинаковые, но всё равно переменные по отдельности претерпели изменения, поэтому они хранятся в разных ячейках памяти. +## 9. Операции с объектами, выполняемые с помощью методов. +Полный список всех атрибутов любого объекта можно получить с использованием функции dir, например, +```py +>>> stroka='Микропроцессорная система управления' +>>> dir(stroka) +``` +9.1 Методы для работы со строками: +```py +>>> stroka.find('пр') #Возвращает номер позиции первого вхождения указанного контекста +5 +>>> stroka.count("с") #Подсчет числа вхождений строки “с” в stroka +4 +>>> stroka.replace(' у',' автоматического у') +'Микропроцессорная система автоматического управления' +>>> spis22=stroka.split(' ') #Возвращает список подстрок, между которыми в строке стоит заданный разделитель +>>> spis22 +['Микропроцессорная', 'система', 'управления'] +>>> stroka.upper() #Возвращает строку со всеми заглавными буквами +'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ' +>>> stroka3=" ".join(spis22) #Возвращает строку, собранную из элементов списка +>>> stroka3.partition("с") #Возвращает кортеж с результатами поиска «с» слева +('Микропроце', 'с', 'сорная система управления') +>>> stroka3.rpartition("с") #Возвращает кортеж с результатами поиска «с» справа +('Микропроцессорная си', 'с', 'тема управления') +>>> 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 = [1, 'A-01-23', 5.0, (1, 2, 3), True] +>>> 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) +5.0 +>>> spsk +[1, 'A-01-23', (1, 2, 3), True] +>>> spsk.append('c') +>>> spsk +[1, 'A-01-23', (1, 2, 3), True, 'c'] +>>> spsk.insert(2,'a') +>>> spsk +[1, 'A-01-23', 'a', (1, 2, 3), True, 'c'] +>>> spsk.count('a') +1 +``` +9.3 Создание кортежа и изучение применение его методов: +```py +>>> my_tuple = ('str', 20, (1, 2, 3), True) +>>> my_tuple.count(20) +1 +>>> my_tuple.index(True) # позиция True в кортеже +3 +``` +9.4 Изучение методов словарей и множеств: +```py +>>> student = { + "name": "Dima", + "age": 20, + "city": "Moscow", + "courses": ["Math", "Physics"], + "sr": 3.01 + } +>>> student.get("name") +'Dima' +>>> student.keys() +dict_keys(['name', 'age', 'city', 'courses', 'sr']) +>>> student.values() +dict_values(['Dima', 20, 'Moscow', ['Math', 'Physics'], 3.01]) +>>> student["sr"] = 4.1 +... +>>> student +{'name': 'Dima', 'age': 20, 'city': 'Moscow', 'courses': ['Math', 'Physics'], 'sr': 4.1} +>>> student.clear() +>>> student +{} +``` +```py +>>> A = {1, 2, 3, 4, 5} +>>> A.add(6) +>>> A +{1, 2, 3, 4, 5, 6} +>>> A.remove(6) +>>> A +{1, 2, 3, 4, 5} +>>> A.pop() +1 +>>> A +{2, 3, 4, 5} +>>> A.clear() +>>> A +set() +``` +