# Отчёт по теме 3
Зеленкина Катерина Михайловна, А-02-23

## Пункт 1. Запуск оболочки IDLE

Установим рабочий каталог:

```py
import os
os.chdir(r'C:\Users\user\python-labs\TEMA3')
```

## Пункт 2. Простые базовые типы объектов.
### Пункт 2.1. Логический тип bool.

Воспользумеся функцией __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#11>", line 1, in <module>
    tt5=int("98.76"); tt5
ValueError: invalid literal for int() with base 10: '98.76'
```
__Пояснение__: Последняя функция выдаёт ошибку, потому что функция int() работает только с целочисленными строками. Для чисел с плавающей точкой нужно сначала использовать float(), а потом преобразовать в целое число.

#### Функция 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. Преобразование в другие системы счисления.

```py
>>> hh=123
>>> dv1=bin(hh); dv1
'0b1111011'
>>> vos1=oct(hh); vos1
'0o173'
>>> shs1=hex(hh); shs1
'0x7b'
```

Для проверки выполним обратные преобразования:

```py
>>> int(dv1,2)
123
>>> int(vos1,8)
123
>>> int(shs1,16)
123
```

## Более сложные базовые типы объектов.
### Пункт 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":9}); 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']
```

### Пункт 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#37>", line 1, in <module>
    strk5
NameError: name 'strk5' is not defined. Did you mean: 'strk1'?
>>> kort8
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    kort8
NameError: name 'kort8' is not defined. Did you mean: 'kort7'?
```
#### Создание своей строки.

```py
>>> a = 'Zelenkina K.M.'
>>> spisok = list(a); spisok, type(spisok) #Преобразование в список
(['Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.'], <class 'list'>)
>>> kort = tuple(spisok); kort; type(kort) #Преобразование в кортеж
('Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.')
<class 'tuple'>
>>> str0 = str(kort); str0; type(str0) #Преобразование в строку
"('Z', 'e', 'l', 'e', 'n', 'k', 'i', 'n', 'a', ' ', 'K', '.', 'M', '.')"
<class 'str'>
```

## Пункт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'>

>>> f = 100//20.5; f; type(f)
4.0
<class 'float'>
>>> p= 25.3//9; p; type(p)
2.0
<class 'float'>
```

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

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

>>> 45.3%9
0.29999999999999716
>>> 70%10.5
7.0
```

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

```py
>>> 14**3
2744
>>> e=2.7**3.6; e
35.719843790663525

>>> 2.7**3
19.683000000000003
>>> 3**2.7
19.419023519771343
```

### Операции с комплексными числами.

```py
>>> k=1+2j
>>> n=3+4j
>>> k+n
(4+6j)
>>> k-n
(-2-2j)
>>> k*n
(-5+10j)
>>> k/n
(0.44+0.08j)
>>> k//n
Traceback (most recent call last):
  File "<pyshell#75>", line 1, in <module>
    k//n
TypeError: unsupported operand type(s) for //: 'complex' and 'complex'
>>> k%n
Traceback (most recent call last):
  File "<pyshell#76>", line 1, in <module>
    k%n
TypeError: unsupported operand type(s) for %: 'complex' and 'complex'
```
__Вывод:__ к комплексным числа нельзя применять деление с округлением вниз и определения остатка


## Пункт 5. Операции с двоичными представлениями целых чисел. 
### Пункт 5.1. Двоичная инверсия.

Значение каждого бита в представлении числа заменяется на противоположное значение (0 на 1, 1 на 0).

```py
>>> dv1=9
>>> dv2=~dv1; dv2
-10
```

### Пункт 5.2. Двоичное «И»

```py
>>> 7&9
1
>>> 7&8
0
```

### Пункт 5.3. Двоичное «ИЛИ»

```py
>>> 7|9
15
>>> 7|8
15
>>> 14|5
15
```

### Пункт 5.4. Двоичное «исключающее ИЛИ»

```py
>>> 14^5
11
>>> bin(11)
'0b1011' - двоичное
```

В десятичном представлении получилось число «11»

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

```py
>>> h=14
>>> bin(h)
'0b1110'
>>> g=h<<2; g; bin(g)
56
'0b111000'
>>> g1=h>>1; g1; bin(g1)
7
'0b111'
>>> g2=h>>2; g2; bin(g2)
3
'0b11'
```

Придумала свои два двоичных знака:

```py
>>> a = 0b11011011
>>> b = 0b01101101
>>> bin(~a); bin(~b)
'-0b11011100'
'-0b1101110'
>>> bin(a&b)
'0b1001001'
>>> bin(a|b)
'0b11111111'
>>> bin(a^b)
'0b10110110'
>>> n=a<<2; n; bin(n)
876
'0b1101101100'
>>> n1=b>>3;n1;bin(n1)
13
'0b1101'
```

## Пункт 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
('кис', '-', 'кис', '-', 'кис', '-', 'кис', '-')
```

Пример. Создание списка со 100 отсчетами сигнала-ступеньки:

```py
>>> 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. Подстановка значений в строку.
__Пример1__

```py
>>> stroka='Температура = %g %s  %g'
>>> stroka % (16,' меньше ',25)
'Температура = 16  меньше   25'
```
__Пример 2.__ Вставка с использованием данных из словаря.

```py
>>> 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
-7
>>> zz-=3;zz
-10
```
Для последовательностей  операция (+=) означает конкатенацию текущего значения объекта с заданным дополнением.

```py
>>> stroka='Система'
>>> stroka+=' регулирования'; stroka
'Система регулирования'
```

### Пункт 7.3. Умножение (*=) или деление (/=)

```py
>>> zz/=2; zz
-5.0
>>> zz*=5; zz
-25.0
```
Для строк операция (*=) означает повторение текущего значения объекта заданное число раз:

```py
>>> stroka='Арбуз'
>>> stroka*=4; stroka
'АрбузАрбузАрбузАрбуз'
```
### Пункт 7.4. Операции деления с округлением вниз (//=), получения остатка от деления (%=) и возведения в степень(**=) 

```py
>>> zz=10
>>> zz//=4; zz #округление вниз
2
>>> zz%=6; zz #остаток от деления
2
>>> zz**=2;zz #возведение в степень
4
```

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

```py
>>> w=v=10; w; v
10
10
>>> n1,n2,n3=(11,-3,'all'); n1;n2;n3
11
-3
'all'
```

```py
>>> n1,n2,n3='yes'; n1;n2;n3
'y'
'e'
's'

>>> n1,n2,n3=[11,-3,'all']; n1;n2;n3
11
-3
'all'

>>> n1,n2,n3 = {'a1': 11, 'a2': -3, 'stroke': 'all'}; n1; n2; n3 #берутся ключи
'a1'
'a2'
'stroke'

>>> n = {'a1': 11, 'a2': -3, 'a3': 'all'}
>>> n1,n2,n3=n.values(); n1;n2;n3
11
-3
'all'

>>> n1,n2,n3 = {11, -3, 'all'}; n1;n2;n3
11
'all'
-3
```

## Пункт 8. Логические операции 
### Пункт 8.1. Операции сравнение

```py
>>> w
10
>>> v
10
>>> w==v
True
>>> z=8
>>> w!=z
True
>>> v<z
False
>>> w>z
True
>>> v<=z
False
>>> w>=z
True
```

### Пунтк 8.2. Проверка наличия заданного элемента
Операции с множеством:
```py
>>> mnoz1={'pen','book','pen','iPhone','table','book'}
>>> 'book' in mnoz1
True
>>> 'cap' in mnoz1
False
```

Операции со словарем:
```py
>>> dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
>>>'Vologda' in dic1
True
>>> 'Pskov' in dic1
False
>>> 56 in dic1.values()
True
```

Ещё пример работы со словарем:
```py
>>> 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
```
Придумала ещё 2 примера:
```py
>>> (a>b) and ('Piter' in dic1) and not ('pen' in mnoz1)
False
>>> not (a==b) and ('table' in mnoz1) and (b<a)
True
```

### Пункт 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("с")
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=[1,10,'bob',['a','b','c'],'hehe']; spsk
[1, 10, 'bob', ['a', 'b', 'c'], 'hehe']
>>> spsk.pop(2)
'bob'
>>> spsk
[1, 10, ['a', 'b', 'c'], 'hehe']
>>> spsk.append('c'); spsk
[1, 10, ['a', 'b', 'c'], 'hehe', 'c']
>>> spsk.insert(2,'a'); spsk
[1, 10, 'a', ['a', 'b', 'c'], 'hehe', 'c']
>>> spsk.count('a')
1
```

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

```py
>>> kor = ('sweets', 56, 'hehe', [3,2,1], 120); kor; type(kor)
('sweets', 56, 'hehe', [3, 2, 1], 120)
<class 'tuple'>
>>> dir(kor)
['__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']
>>> kor.count('hehe')
1
>>> kor.index(56)
1
>>> kor +=(10, 'home'); kor
('sweets', 56, 'hehe', [3, 2, 1], 120, 10, 'home')
>>>type(kor)
<class 'tuple'>
```

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

```py
sl = {'Gorod':'Moscow', 'Name': 'Katy', 'Age':19}; type(sl)
<class 'dict'>
dir(sl)
['__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']
sl.pop('Gorod')
'Moscow'
sl
{'Name': 'Katy', 'Age': 19}
sl.keys()
dict_keys(['Name', 'Age'])
sl.items()
dict_items([('Name', 'Katy'), ('Age', 19)])
sl.update({'Like': 'eat', 'Money':2000}); sl
{'Name': 'Katy', 'Age': 19, 'Like': 'eat', 'Money': 2000}
sl.values()
dict_values(['Katy', 19, 'eat', 2000])
```
#### 9.4.2. Методы со множествами

```py
>>> mnoch={1,2,3,4,5,'a'}
>>> type(mnoch)
<class 'set'>
>>> mnoch.add('hehe'); mnoch
{1, 2, 3, 4, 5, 'a', 'hehe'}
>>> mnoch.remove(1);mnoch
{2, 3, 4, 5, 'a', 'hehe'}
>>> mnoch1={'l','k',60}
>>> mnoch2=mnoch.union(mnoch1);mnoch2
{2, 3, 4, 5, 'a', 'k', 'hehe', 60, 'l'}
```

## Пункт 10. Закончила сеанс работы с IDLE