# Отчёт по Теме 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 "<pyshell#13>", line 1, in <module>
    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 "<pyshell#25>", line 1, in <module>
    int(dv1)
ValueError: invalid literal for int() with base 10: '0b1111011'
int(vos1)
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    int(vos1)
ValueError: invalid literal for int() with base 10: '0o173'
int(shs1)
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    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
<class 'float'>
b=25/5;b;type(b)
5.0
<class 'float'>
```
Результат деления - всегда вещественное число
## 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)
<class 'int'>
type(c)
<class 'float'>
```
```py
c2=12/3.99999
c2;type(c2)
3.00000750001875
<class 'float'>
c2=12//3.99999
c2;type(c2)
3.0
<class 'float'>
c3=12.000001//4;c3;type(c3)
3.0
<class 'float'>
c4=12//4;c4;type(c4)
3
<class 'int'>
c5=12//5;c5;type(c5)
2
<class 'int'>
```
Если хотя бы один элемент в выражении является вещественным числом, результат будет вещественным.
## 4.5. Получение остатка от деления
```py
148%33
16
12.6%3.8
1.2000000000000002
12%4
0
12%0
Traceback (most recent call last):
  File "<pyshell#79>", line 1, in <module>
    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)
<class 'complex'>
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 "<pyshell#95>", line 1, in <module>
    compl1//compl2
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
compl1//2
Traceback (most recent call last):
  File "<pyshell#96>", line 1, in <module>
    compl1//2
TypeError: unsupported operand type(s) for //: 'complex' and 'int'
2//compl1
Traceback (most recent call last):
  File "<pyshell#97>", line 1, in <module>
    2//compl1
TypeError: unsupported operand type(s) for //: 'int' and 'complex'
0.5//compl1
Traceback (most recent call last):
  File "<pyshell#98>", line 1, in <module>
    0.5//compl1
TypeError: unsupported operand type(s) for //: 'float' and 'complex'
compl1%compl2
Traceback (most recent call last):
  File "<pyshell#99>", line 1, in <module>
    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
w<v
False
w>v
False
w<=v
True
w>=v
True
5>8
False
(1+5j)>(-1-5j)
Traceback (most recent call last):
  File "<pyshell#90>", line 1, in <module>
    (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'}
```