Добавлен отчёт TEMA3

4 недель назад · cac315d9a9
--- a/TEMA3/report.md
+++ b/TEMA3/report.md
@ -0,0 +1,601 @@
 # Отчёт по теме 3
 Соловьёва Екатерина, А-01-23
 ## 1. Начало работы с оболочкой IDLE.
 ## 2.	Преобразование простых базовых типов объектов.
 ## 2.1.	 Преобразование в логический тип с помощью функции bool(<Объект>).
 ```py
 logiz1=bool(56)
 logiz2=bool(0)
 logiz3=bool("Beta")
 logiz4=bool("")
 logiz1
 True
 logiz2
 False
 logiz3
 True
 logiz4
 False
 ```
 * False : Пустые значения, ноль и None.
 * True : Почти все остальное.
 ## 2.2.	Преобразование в целое десятичное число объекта с заданной системой счисления.
 Осуществляется с помощью функции int(<Объект>[,<Система счисления, в которой определен объект>]). По умолчанию система счисления принимается десятичной.
 ```py
   tt1=int(198.6) #Функция получает уже готовое число 198.6 (тип float) и просто отбрасывает дробную часть.
   tt1
   198
   tt2=int("-76")  #Число – в строке символов, система по умолчанию - десятичная
   tt2
   -76
   tt3=int("B",16)
   tt3
   11
   tt4=int("71",8) #"71"(8)= 7 × 8¹ + 1 × 8⁰ = 7 × 8 + 1 × 1 = 56 + 1 = 57
   tt4 = int(71, 8)
 Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module> #Это вызовет ошибку, потому что функция int() не может применить систему счисления к уже готовому числу.
    tt5=int("98.76")
 Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    tt5=int("98.76")
 ValueError: invalid literal for int() with base 10: '98.76' #int() не умеет обрабатывать дробные числа в строках - она ожидает только целые числа.
 ```
 ## 2.3.	 Преобразование целых чисел или строк символов в вещественное число – с помощью функции 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.4.	 Преобразование десятичных чисел в другие системы счисления.
 ```py
 hh=123
 dv1=bin(hh)
 dv1
 '0b1111011'
 vos1=oct(hh)
 vos1
 '0o173'
 shs1=hex(hh)
 shs1
 '0x7b'
 ```
 Выполню обратные преобразования объектов: 
 ```py
 dv1=int(dv1,2)
 dv1
 123
 vos1=int(vos1,8)
 vos1
 123
 shs1=int(shs1,16)
 shs1
 123
 ```
 ## 3.	Изучите преобразования более сложных базовых типов объектов.
 ## 3.1.	 Преобразование в строку символов с помощью функции str(<Объект>).
 ```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})#Преобразуем словарь
 print(strk1)
 23.6
 print(strk2)
 True
 print(strk3)
 ['A', 'B', 'C']
 print(strk4)
 ('A', 'B', 'C')
 print(strk5)
 {'A': 1, 'B': 2, 'C': 9}
 ```
 ## 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
 spis3 = list({"A":1,"B":2,"C":9}.values()) #cписок значений
 spis3
 [1, 2, 9]
 spis3 = list({"A":1,"B":2,"C":9}.items()) #cписок пар (ключ, значение)
 spis3
 [('A', 1), ('B', 2), ('C', 9)]
 spis3 = [value for value in {"A":1,"B":2,"C":9}.values() if value % 2 == 0] #cписок только четных значений
 spis3
 [2]
 ```
 ## 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')
 ```
 ## 3.4. Удаление объектов.
 Проверю остались ли объекты в оперативной памяти после применения операции del: 
 ```py
 del strk5, kort8
 strk5
 Traceback (most recent call last):
  File "<pyshell#98>", line 1, in <module>
    strk5
 NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
 kort8
 Traceback (most recent call last):
  File "<pyshell#99>", line 1, in <module>
    kort8
 NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
 ```
 Создам строку со своей фамилией и инициалами, преобразую её в список, затем список – в кортеж, кортеж – в строку
 ```py
 fio='Solovyova E D'
 spis0=list(fio)
 spis0
 ['S', 'o', 'l', 'o', 'v', 'y', 'o', 'v', 'a', ' ', 'E', ' ', 'D']
 kort0=tuple(spis0)
 kort0
 ('S', 'o', 'l', 'o', 'v', 'y', 'o', 'v', 'a', ' ', 'E', ' ', 'D')
 strk0=str(kort0)
 strk0
 "('S', 'o', 'l', 'o', 'v', 'y', 'o', 'v', 'a', ' ', 'E', ' ', 'D')"
 ```
 ## 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 #Деление двух целых чисел 
 type(a)
 <class 'float'>
 a
 3.9555555555555557
 ```
 ## 4.3 Деление с округлением вниз (//). 
 Здесь результат может быть целым или вещественным. 
 ```py
 b=178//45 #Деление двух целых чисел
 b
 3
 type(b)
 <class 'int'>
 c=-24.6//12.1 #Деление двух вещественных чисел
 c
 -3.0
 type(c)
 <class 'float'>
 d = 56 // 6.01 #Деление целого числа на вещественное
 d
 9.0
 type(d)
 <class 'float'>
 e = 7.54// 2 #Деление вещественного числа на целое
 e
 3.0
 type(e)
 <class 'float'>
 f = -15 // 4 #Деление отрицательных чисел
 f
 -4 
 type(f)
 <class 'int'>
 ```
 Вывод:
 * int - если оба операнда целые
 * float - если хотя бы один операнд вещественный
 ## 4.5.	 Получение остатка от деления (%).
 Формула остатка от деления:
 a % b = a - b * (a // b)
 ```py
 148%33 #Остаток от деления двух целых чисел
 16
 12.6%3.8 #Остаток от деления двух вещественных чисел
 1.2000000000000002
 20 % 3.5 #Остаток от деления целого на вещественное
 2.5
 -17 % 5 Остаток от деления отрицательного на целое
 3
 15.7 % 4 #Остаток от деления вещественного на целое  
 3.6999999999999993
 ```
 ## 4.6.	 Возведение в степень (**). 
 ```py
 14**3 #Целое число возводится в целую степень
 2744
 e=2.7**3.6 #Вещественное число возводится в вещественную степень
 14**3.6 #Целое число возводится в вещественную степень
 13367.830445904418
 2.7**3 #Вещественное число возводится в целую степень
 19.683000000000003
 ```
 операции недоступные с комплексными числами:
 * Целочисленное деление
 z // 2  
 * Остаток от деления  
 z % 2   
 *Сравнения (<, >, <=, >=)
 z > 2 
 Доступные: 
 * Сложение
 * Вычитание  
 * Умножение
 * Деление
 * Возведение в степень
 ## 5.	Операции с двоичными представлениями целых чисел.
 ## 5.1.	 Двоичная инверсия (~). 
 Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).
 ```py
 dv1=9
 dv2=~dv1
 dv2
 -10
 ```
 В Python операция ~x эквивалентна -x - 1, а работает это так:
 9:   0000 1001
 ~9:  1111 0110
 ## 5.2.	 Двоичное «И» (&) – побитовое совпадение двоичных представлений чисел
 ```py
 7&9 # 0111 и 1001 = 0001
 1
 7&8 # 0111 и 1000 = 0000
 0
 ```
 ## 5.3.	 Двоичное «ИЛИ» (|) 
 Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда равны 0
 ```py
 7|9 # 111 или 1001 = 1111
 15
 7|8 # 111 или 1000 = 1111
 15
 14|5 # 1110 или 0101 = 1111
 15
 ```
 ## 5.4.	Двоичное «исключающее ИЛИ»(^)
 Побитовое сравнение двоичных представлений чисел и 0 получается, только если оба сравниваемых разряда имеют одинаковые значения – оба 0 или оба 1.
 ```py
 14^5 # 1110 исключающее или 0101 = 1011
 11
 ```
 ## 5.5.	 Сдвиг двоичного представления на заданное число разрядов влево (<<) или вправо (>>) с дополнением нулями, соответственно справа или слева.
 ```py
  h=14   #Двоичное представление = 1110
  g=h<<2  # Новое двоичное представление = 111000
  g
  56
  g1=h>>1  # Новое двоичное представление = 0111
  g1
  7
  g2=h>>2  # Новое двоичное представление = 0011
  g2
  3
 ```
 Свои примеры:
 ```py
 k=245
 bin(245)
 '0b11110101'
 k<<2
 980
 k>>3
 30
 bin(456)
 '0b111001000'
 t=456
 t>>5
 14
 t<<14
 7471104
 ```
 ## 6.	Операции при работе с последовательностями (строками, списками, кортежами).	
 ## 6.1.	 Объединение последовательностей (конкатенация)(+) 
 ```py
    'Система '+'регулирования'  #Соединение двух строк символов
    ['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.	 Проверка наличия заданного элемента в последовательности (in)
 ```py
 stroka='Система автоматического управления'
    'автомат' in stroka  #Наличие подстроки в строке
    True
    'ку' in ['ку','-']*3  #Наличие контекста в списке
    True
    'ля-' in ('abc', 'de', 'fg', 'hi', 'jkl')  #Наличие контекста в кортеже
    False
 ```
 ## 6.4.	Подстановка значений в строку с помощью оператора «%»
 ```py
 # Пример 1.
  stroka='Температура = %g %s  %g'
  stroka % (16,' меньше ',25)
 # Пример 2. Именованная подстановка из словаря.
  stroka='Температура = %(zn1)g %(sravn)s  %(zn2)g'
  stroka % {'zn1':16,'sravn':' меньше ','zn2':25}
 ```
 ## 7.	Оператор присваивания
 ## 7.1.	 Обычное присваивание значения переменной (=)
 ```py
 zz=-12
 ```
 ## 7.2.	Увеличение значения переменной на заданную величину  (+=) или уменьшение (-=)
 ```py
 zz+=5   # Значение zz увеличивается на 5
 zz-=3  # Значение уменьшается на 3
 stroka='Система'
 stroka+=' регулирования'
 ```
 ## 7.3.	 Умножение текущего значения переменной на заданную величину (*=) или деление (/=)
 ```py
 zz=10
 zz/=2
 zz
 5.0
 zz*=5
 zz
 25.0
 ```
 ## 7.4.	Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=).
 ```py
 x=166
 x//=10 #округление вниз
 x
 16
 x%=2 #получение остатка от деления 
 x
 0
 x=167
 x=2
 x**=4 #возведение в степень
 x
 16
 ```
 ## 7.5.	 Множественное присваивание
 ```py
    w=v=10  # Переменным присваивается одно и то же значение
    n1,n2,n3=(11,-3,'all')  #Значения переменных берутся из кортежа
 ```
 Проверим можно ли вместо кортежа справа использовать строку, список, словарь, множество
 ```py
    n1, n2, n3 = "11", "-3", "all"
    n1,n2,n3=[11,-3,'all']
    n1, n2, n3 = {11, -3, 'all'}
    print(n1, n2, n3)
    11 -3 all
    n1, n2, n3 = {'a': 1, 'b': 2, 'c': 3}
    print(n1, n2, n3)
    a b c
 ```
 Вывод: всё работает, но в случае словаря присваиваются ключи
 ## 8.	Логические операции – при создании логических выражений, дающих в результате вычисления значения True или False.
 ## 8.1.	 Операции сравнение: равенство (==), не равно (!=), меньше (<), больше (>), меньше или равно (<=), больше или равно (>=) 
 ```py
 w=10
 v=20
 w==v
 False
 w!=v
 True
 w<v
 True
 w>v
 False
 w<=v
 True
 w>=v
 False
 ```
 ## 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']}
 'UII' in dct1['Depart']
 True
 dct1['Depart'][1] == 'MM'
 False
 ```
 ## 8.3.	 Создание больших логических выражений с использованием соединительных слов: логическое «И» (and), логическое «ИЛИ» (or), логическое «НЕ» (not).
 ```py
 a=17
 b=-6
 (a>=b) and ('book' in mnoz1) and not ('Pskov' in dic1)
 True
 x = 10
 y = 5
 name = "Anna"
 (x > y) and (len(name) == 4) and not (y < 0)
 True
 price=3000
 color='blue'
 price1=4000
 (price<price1) and (color=='red')
 False
 ```
 ## 8.4.	Проверка ссылок переменных на один и тот же объект (is).
 ```py
 w=v=10
 w is v
 True
 w1=['A','B']
 v1=['A','B']
 w1 is v1
 False
 ```
 Вывод: is проверяет, ссылаются ли переменные на один и тот же объект в памяти, а не на одинаковые значения
 ## 9.	Операции с объектами, выполняемые с помощью методов.
 ```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("с")
 4
 stroka.replace(' у',' автоматического у')
 'Микропроцессорная система автоматического управления'
 spis22=stroka.split(' ')
 stroka.upper()
 'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
 stroka3=" ".join(spis22)
 stroka3.partition("с")
 ('Микропроце', 'с', 'сорная система управления')
 stroka3.rpartition("с")
 ('Микропроцессорная си', 'с', 'тема управления')
 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=['a','b','c','d','e','f'] # удалить второй по счёту элемент
 spsk.pop(2)
 'c'
 spsk
 ['a', 'b', 'd', 'e', 'f']
 spsk.append('c') # Добавть с в конец списка
 spsk
 ['a', 'b', 'd', 'e', 'f', 'c']
 spsk.insert(2,'a') # Вставить a на позицию с индексом 2
 spsk
 ['a', 'b', 'a', 'd', 'e', 'f', 'c']
 spsk.count('a') # Подсчёт количества 'а' в списке
 2
 ```
 ## 9.3.	Самостоятельное создание кортежа и применение его методов.
 ```py
 kort = (1, 2, 3, 2, 4, 2, 5)
 len(kort)
 7
 max(kort)
 5
 min(kort)
 1
 sorted(kort)
 [1, 2, 2, 2, 3, 4, 5]
 kort.index(2)
 1
 kort.count(2)
 3
 ```
 ## 9.3.	Самостоятельное создание словаря и множества, применение их методов.
 ```py
 dict = {'a': 1, 'b': 2, 'c': 3} 
 dict.keys() # Все ключи
 dict_keys(['a', 'b', 'c'])
 dict.values()# Все значения
 dict_values([1, 2, 3])
 dict.items()# Пары ключ-значение
 dict_items([('a', 1), ('b', 2), ('c', 3)])
 dict.update({'d': 4, 'e': 5})# Добавляет новые пары
 dict
 {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
 dict.pop('b') # Удаляет ключ 'b' и возвращает значение
 {'a': 1, 'c': 3, 'd': 4, 'e': 5}
 ```
 Множества
 ```py
 mnoz1 = {1, 2, 3, 4, 5}
 mnoz2 = {4, 5, 6, 7, 8}
 mnoz1.union(mnoz2) # Объединение
 {1, 2, 3, 4, 5, 6, 7, 8}
 mnoz1.intersection(mnoz2)# Пересечение
 {4, 5}
 mnoz1.difference(mnoz2) # разность (возвращает элементы, которые есть в mnoz1, но нет в mnoz2)
 {1, 2, 3}
 mnoz1.symmetric_difference(mnoz2)# Симметричная разность возвращает элементы, которые есть только в одном из множеств
 {1, 2, 3, 6, 7, 8}
 mnoz1.add(6) # Добавляет элемент
 mnoz1
 {1, 2, 3, 4, 5, 6}
 mnoz2.remove(3)# Удаляет конкретный элемент (ошибка если нет)
 Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    mnoz2.remove(3)
 KeyError: 3
 mnoz1.remove(3) 
 mnoz1
 {1, 2, 4, 5, 6}
 ```