# Отчет по теме 3

Лыкова Елизавета, А-01-23

## 1. Запуск IDLE, привязка католога, создание файла отчета.

```py
import os
os.chdir("C:\\Users\\Home\\Desktop\\python-labs\\TEMA3")
```

## 2. Преобразование простых базовых типов объектов.

## 2.1 Логическая функция bool.

```py
logiz1 = bool(56)
logiz1, type(logiz1)
(True, <class 'bool'>)
logiz2 = bool(0)
logiz2, type(logiz2)
(False, <class 'bool'>)
logiz3 = bool("Beta")
logiz3, type(logiz3)
(True, <class 'bool'>)
logiz4 = bool("")
logiz4, type(logiz4)
(False, <class 'bool'>)
```

## 2.2.1 Функция int.

```py
tt1 = int(198.6)
tt1, type(tt1)
(198, <class 'int'>)
tt2 = int('-76')
tt2, type(tt2)
(-76, <class 'int'>)
tt3 = int('B',16)
tt3, type(tt3)
(11, <class 'int'>)
tt4 = int('71',8)
tt4, type(tt4)
(57, <class 'int'>)
tt5 = int('98.76')
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    tt5 = int('98.76')
ValueError: invalid literal for int() with base 10: '98.76'
```

Диагностическое сообщение было выведено из-за того, что int ожидает в кавычках целое число, а не дробное.

## 2.2.2 Функция float.

```py
flt1 = float(789)
flt1, type(flt1)
(789.0, <class 'float'>)
flt2 = float(-6.78e2)
flt2, type(flt2)
(-678.0, <class 'float'>)
flt3 = float('Infinity')
flt3, type(flt3)
(inf, <class 'float'>)
flt4 = float('-inf')
flt4, type(flt4)
(-inf, <class 'float'>)
```

## 2.3. Другие системы счисления.

```py
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.

```py
strk1 = str(23.6)
strk1, type(strk1)
('23.6', <class 'str'>)
strk2 = str(logiz3)
strk2, type(strk2)
('True', <class 'str'>)
strk3 = str(['A','B','C'])
strk3, type(strk3)
("['A', 'B', 'C']", <class 'str'>)
strk4 = str(('A','B','C'))
strk4, type(strk4)
("('A', 'B', 'C')", <class 'str'>)
strk5 = str({'A':1,'B':2,'C':9})
strk5, type(strk5)
("{'A': 1, 'B': 2, 'C': 9}", <class 'str'>)
```

## 3.2 Функция list.

```py
spis1 = list('Строка символов')
spis1, type(spis1)
(['С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'], <class 'list'>)
spis2 = list((124,236,-15,908))
spis2, type(spis2)
([124, 236, -15, 908], <class 'list'>)
spis3 = list({'A':1,'B':2,'C':9})
spis3, type(spis3)
(['A', 'B', 'C'], <class 'list'>)
# Список со значениями
spis4 = list({'A':1,'B':2,'C':9}.values())
spis4, type(spis4)
([1, 2, 9], <class 'list'>)
# Словарь полностью
spis4 = list({'A':1,'B':2,'C':9}.items())
spis4, type(spis4)
([('A', 1), ('B', 2), ('C', 9)], <class 'list'>)
```

## 3.3 Функция tuple.

```py
kort7=tuple('Строка символов')
kort7, type(kort7)
(('С', 'т', 'р', 'о', 'к', 'а', ' ', 'с', 'и', 'м', 'в', 'о', 'л', 'о', 'в'), <class 'tuple'>)
kort8 = tuple(spis2)
kort8, type(kort8)
((124, 236, -15, 908), <class 'tuple'>)
kort9 = tuple({'A':1,'B':2,'C':9})
kort9, type(kort9)
(('A', 'B', 'C'), <class 'tuple'>)
```

## 3.4 Удаление объектов.

```py
del strk5, kort8
print(strk5)
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    print(strk5)
NameError: name 'strk5' is not defined
print(kort8)
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    print(kort8)
NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
imya = 'Lykova E.A'
imya
'Lykova E.A'
spis = list(imya)
spis
['L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A']
kort = tuple(spis)
kort
('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', 'A')
strk = str(kort)
strk
"('L', 'y', 'k', 'o', 'v', 'a', ' ', 'E', '.', '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, type(a)
(3.9555555555555557, <class 'float'>)
```

## 4.4 Деление с округлением вниз.

```py
b = 178//45
b, type(b)
(3, <class 'int'>)
c = -24.6//12.1
c, type(c)
(-3.0, <class 'float'>)
d = 178//12.1
d, type(d)
(14.0, <class 'float'>)
e = -24.6//45
e, type(e)
(-1.0, <class 'float'>)
```

## 4.5 Остаток от деления.

```py
148%33
16
12.6%3.8
1.2000000000000002
148%3.8
3.6000000000000068
12.6%33
12.6
```

## 4.6 Возведение в степень.

```py
14**3
2744
e = 2.7**3.6
e
35.719843790663525
14**3.6
13367.830445904418
2.7**3
19.683000000000003
c1 = 3 + 4j
c2 = 1 - 2j
c1 + c2
(4+2j)
c1 - c2
(2+6j)
c1 * c2
(11-2j)
c1/c2
(-1+2j)
c1//c2
Traceback (most recent call last):
  File "<pyshell#50>", line 1, in <module>
    c1//c2
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
c1%c2
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    c1%c2
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
c1** 2
(-7+24j)
```

Как мы видим, для работы с комплексными числами нельзя применять операции остатка от деления и деление с округлением вниз.

## 5. Операции с двоичным представдением целых чисел.

## 5.1 Двоичная инверсия.

```py
dv1 = 9
dv2 = ~dv1
bin(dv1)
'0b1001'
dv2
-10
bin(dv2)
'-0b1010'
```

## 5.2 Двоичное 'И'.

```py
7&9
1
bin(7&9)
'0b1'
7&8
0
bin(7&8)
'0b0'
```

## 5.3 Двоичное 'ИЛИ'.

```py
7|9
15
bin(7|9)
'0b1111'
7|8
15
bin(7|8)
'0b1111'
14|5
15
bin(14|5)
'0b1111'
```

## 5.4 Двоичное исключающее 'ИЛИ'.

```py
14^5
11
bin(14^5)
'0b1011'
```

## 5.5 Сдвиг двоичного представления на заданное число разрядов.

```py
l1 = 68
l2 = 71
bin(l1)
'0b1000100'
bin(l2)
'0b1000111'
bin(~l1)
'-0b1000101'
bin(~l2)
'-0b1001000'
bin(l1&l2)
'0b1000100'
bin(l1|l2)
'0b1000111'
bin(l1^l2)
'0b11'
bin(l1>>2)
'0b10001'
bin(l2<<1)
'0b10001110'
```

## 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
['ку', '-', 'ку', '-', 'ку', '-']
('кис','-')*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
'Температура = %g %s %g'
stroka % (16, 'меньше', 25)
'Температура = 16 меньше 25'
stroka = 'Температура = %(zn1)g%(sptavn)s %(zn2)g'
stroka
'Температура = %(zn1)g%(sptavn)s %(zn2)g'
stroka %{'zn1':16,'sptavn':'меньше','zn2':25}
'Температура = 16меньше 25'
```

## 7. Оператор присваивания.

## 7.1 Обычное присваивание.

```py
zz=-12
zz
-12
```

## 7.2 Увеличение значения на заданную величину.

```py
zz+=5
zz
-7
zz-=3
zz
-10
stroka = 'Система'
stroka+= 'регулирования'
stroka
'Системарегулирования'
```

## 7.3 Умножение на заданную величину.

```py
zz/=2
zz
-5.0
zz*=5
zz
-25.0
strokan = 'ля'
strokan *= 5
strokan
'ляляляляля'
```

## 7.4 Операция деления с округлением, получение остатка от деления и возведение в степень.

```py
ll = 77
ll//=3
ll
25
ll%=3
ll
1
ll**=7
ll
1
```

## 7.5 Множественное присваивание.

```py
w = v = 10
n1,n2,n3=(11,-3,'all')
w
10
v
10
n1
11
n2
-3
n3
'all'
a1,a2,a3 = 'na', 'no', 'nu'
a1,a2,a3
('na', 'no', 'nu')
a1,a2,a3 = 'abc'
a1,a2,a3
('a', 'b', 'c')
b1,b2,b3 = ['la','lo','lu']
b1,b2,b3
('la', 'lo', 'lu')
c1,c2,c3 = {'ha':1,'ho':2,'he':3}
c1,c2,c3
('ha', 'ho', 'he')
d1,d2,d3 = {'me','ma','mo'}
d1,d2,d3
('ma', 'me', 'mo')
```

## 8. Логические операции.

## 8.1 Операции сравнения.

```py
w == v
True
w != v
False
w < v
False
w > v
False
w <= v
True
w >= v
True
```

## 8.2 Проверка наличия заданного элемента.

```py
mnoz1 = {'pen','book','pen','iPhone','table','book'}
mnoz1
{'pen', 'table', 'iPhone', '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) or ('Saratov' in dic1) or ('deck' in mnoz1)
True
('Saratov' in dic1) and not (a<b) and not ('pen' in mnoz1)
False
```

## 8.4 Проверка ссылок на один и тот же объект.

```py
w=v=10
w is v
True
w1 =['A','B']
v1 = ['A','B']
w1 is v1
False
```

В первом случае обе переменные присваиваются к одному уже существующему в памяти объекту, когда как во втором переменные ипсользуют два разных списка.

## 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('c')
0
stroka.replace('у','автоматического у')
'Микропроцессорная система автоматического управления'
spis22=stroka.split(' ')
spis22
['Микропроцессорная', 'система', 'управления']
stroka.upper()
'МИКРОПРОЦЕССОРНАЯ СИСТЕМА УПРАВЛЕНИЯ'
stroka3=''.join(spis22)
stroka3
'Микропроцессорнаясистемауправления'
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 = [167, 'haha', 'meme', 89.7, 'sasalele']
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)
'meme'
spsk.append('с')
spsk
[167, 'haha', 89.7, 'sasalele', 'с']
spsk.insert(2,'a')
spsk
[167, 'haha', 'a', 89.7, 'sasalele', 'с']
spsk.count('a')
1
```

## 9.3 Методы работы с кортежом.

```py
tupl = (178, 'nana', 'jaja', 456, 90.4)
dir(tupl)
['__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']
tupl.count(456)
1
tupl.index('nana')
1
```

## 9.4 Методы словарей и множеств.

```py
slvr = {'A':'wot','B':45,'C':39,'D':'meme','F':'pepe'}
slvr
{'A': 'wot', 'B': 45, 'C': 39, 'D': 'meme', 'F': 'pepe'}
dir(slvr)
['__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']
slvr.keys()
dict_keys(['A', 'B', 'C', 'D', 'F'])
slvr.items()
dict_items([('A', 'wot'), ('B', 45), ('C', 39), ('D', 'meme'), ('F', 'pepe')])
slvr.values()
dict_values(['wot', 45, 39, 'meme', 'pepe'])
slvr.get('A')
'wot'
mnozh = {'haha', 763, 'ikk', 98.6, 'fsfs'}
dir(mnozh)
['__and__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__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']
mnozh.pop()
98.6
mnozh.pop()
'fsfs'
mnozh
{763, 'haha', 'ikk'}
mnozh.add('pfff')
mnozh
{'pfff', 763, 'haha', 'ikk'}
mnozh.remove('haha')
mnozh
{'pfff', 763, 'ikk'}
```