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

Шинкаренко Варвара, А-02-23

## 1. Настройка рабочего каталога

Перед началом работы со средой настроили рабочий каталог

```py
import os
os.chdir('C:\\Users\\LENOVO\\Desktop')
```

## 2. Изучение простых объектов

Присвоили значения двум объектам-переменным и рассмотрели разные способы их отображения:

```py
f1 = 16; f2 = 3
f1, f2
(16, 3)
f1; f2
16
3
```

Изучили как просмотреть все существующие объекты среды, а также как получить их атрибуты:

```py
dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2', 'os']
dir(f1)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_count', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'is_integer', 'numerator', 'real', 'to_bytes']
```

Определили классовую принадлежность объектов, а затем удалили их все и убедились в этом:

```py
type(f2)
<class 'int'>
f3 = 15.5
type(f3)
<class 'float'>
del f1, f2, f3
dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'os']
```

## 3. Изучение правил наименования объектов

Ввели несколько правильных и неправильных вариантов:

```py
gg1 = 1.6
hh1 = 'Строка'
73sr = 3
SyntaxError: invalid decimal literal
and = 7
SyntaxError: invalid syntax
```

При неверных названиях появляется диагностическое сообщение.

## 4. Изучение ключевых слов

Вывели список ключевых слов и сохранили его в переменной kw:

```py
import keyword
keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
kw = keyword.kwlist
kw
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
```

## 5. Изучение встроенных идентификаторов

Сначала получили идентификаторов:

```py
import keyword
keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
kw = keyword.kwlist
kw
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

```

После этого изучили несколько функций на практике:

```py
abs(-10)
10
len(kw)
35
len(hh1)
6
max(gg1, 3)
3
min(gg1, 3)
1.6
round(1.3)
1
round(gg1)
2
help(sorted)
Help on built-in function sorted in module builtins:

sorted(iterable, /, *, key=None, reverse=False)
    Return a new...
ww1 = [1, 8, 6, 10]
sorted(ww1)
[1, 6, 8, 10]
```

При необходимости пользовались командой help()

## 6. Имена чувствительны к регистру

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

```py
Gg1 = 45
Gg1
45
gg1
1.6
```

## 7. Изучение базовых типов объектов

### 7.1 Логический тип (bool)
Создали две логические переменные

```py
bb1 = True; bb2 = False
bb1; bb2
True
False
type(bb1)
<class 'bool'>
```
### 7.2 Изучили другие типы переменных

```py
ii1 = -1234567890
ff1 = -8.9876e-12
dv = 0b1101010
vsm1 = 0o52765
shest1 = 0x7109af6
ccl = 2-3j
a = 3.67; b = -0.
cc2 = complex(a,b)

```

### 7.3 Изучили строку символов

Для начала получили строку символов:

```py
ss1 = 'Это - строка символ'
```

Затем получили более сложную кострукцию, воспользовавшись экранированными последовательностями:

```py
ss1a = 'Это - \'строка символоов\',\n \t выводим на двух строках'
print(ss1a)
Это - 'строка символоов',
 	 выводим на двух строках
ss1b = "Меня зовут: \n Шинкаренко В. А."
print (ss1b)
Меня зовут: 
 Шинкаренко В. А.
```

Изучили задание многострочных строк с использованием тройных кавык:

```py

mnogo = """Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции"""
print(mnogo)
Нетрудно заметить, что в результате операции над числами разных типов получается число, имеющее более сложный тип из тех, которые учавствуют в операции
```

Попробуем обратиться к элементам строки, используя индексы символов (нумерация начинается с 0):

```py
ss1[0]
'Э'
ss1[8]
'р'
ss1[-2]
'о'
```

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

```py
ss1[6:9]
'стр' # Символы от 6го до 8го (Символ с 9м индексом не входит)
ss1[13:]
'символ' # Часть строки от 13го индекса и до конца
ss1[13:13]
'' # Сам 13й символ
ss1[:13]
'Это - строка ' # Наоборот, с начала и до 13го символа
ss1[5:-8]
' строк' # Символы от 5го до 8го м конца
ss1[3:17:2]
'  тоасм' # Символы с 3го индекса по 16й с шагом 2
ss1[17:3:-2]
'омсаот ' # Символы с 17го по 3й, при этом шаг делается в обратном направлении
# Получается примерно тот же результат, если заменить 17 на -4 (главное, что четное)
ss1[-4:3:-2]
'мсаот '
ss1[-6:3:-2]
'саот '
ss1[-2:3:-2]
'омсаот '
```

Попробуем изменить строку:

```py
ss1 = ss1[:4]+'='+ss1[5:]
ss1
'Это = строка символ'
```

Проведем все те же действия с другой строкой:

```py
bb1 = ss1b[3] + ' - ' + ss1b[17:20]
bb1
'я - кар'
bb2 = ss1b[3] + ' ' + ss1b[5:9] + ' ' + ss1b[15] + ss1b[17:20] + ss1b[28]
bb2
'я зову икарА'
bb3 = ss1b[:10] + ss1b[13:16] + ss1b[17:20] + ss1b[21] + ss1b[23]
bb3
'Меня зовут Шикарно'
```

Создали и отобразили несколько объектов разных типов:

```py
x1 = 16
type(x1)
<class 'int'>
x2 = 12.4
type(x2)
<class 'float'>
x3 = 'Буквы'
type(x3)
<class 'str'>
x4 = [1, 4, 9]
type(x4)
<class 'list'>
x5 = ['one', 'two', 'three']
type(x5)
<class 'list'>
x6 = True
type(x6)
<class 'bool'>
x7 = True, False
type(x7)
<class 'tuple'>

x1
16
x2
12.4
x3
'Буквы'
x4
[1, 4, 9]
x5
['one', 'two', 'three']
x6
True
x7
(True, False)
```

## 8. Изучение более сложных типов объектов

### 8.1 Тип объекта: список

Изучили создание и отображение списков:

```py
spis1 = [111, 'Spisok', 5-9j]
spis1
[111, 'Spisok', (5-9j)]
stup = [0,0,1,1,1,1,1,1,1]
stup
[0, 0, 1, 1, 1, 1, 1, 1, 1]
spis = [9, 67,
        69, 75, 45, 30,
        100]
spis
[9, 67, 69, 75, 45, 30, 100]
spis[-2]
30
stup[2:9]
[1, 1, 1, 1, 1, 1, 1]
spis[0] = 'Spisok' # Заменили один из элементов списка
spis
['Spisok', 67, 69, 75, 45, 30, 100]
len(spis) # Нашли длину списка
7
```

Изучили методы списка:

```py
help(spis1.append)
Help on built-in function append:

append(object, /) method of builtins.list instance
    Append object to the end of the list.

spis1.append('New item') # Добавили элемент в конец списка
spis1
[111, 'Spisok', (5-9j), 'New item']
spis1 + ['New item'] # Добавил только временно
[111, 'Spisok', (5-9j), 'New item', 'New item']
spis1
[111, 'Spisok', (5-9j), 'New item']
spis1.append(ss1b)
spis1
[111, 'Spisok', (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']
spis1.pop(1) # Удалили один элемент
'Spisok'
spis1
[111, (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']
spis1.insert(0, 'zero') # Вставляет элемент на место нужного индекса, все остальное двигает
spis1
['zero', 111, (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']
spis1.remove(111) # Удаляет нужный элемент, если такого нет, выдает ошибку
spis1
['zero', (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.']

spis1.extend('New item') # Расширяет список нужным элементом
spis1
['zero', (5-9j), 'New item', 'Меня зовут: \n Шинкаренко В. А.', 'N', 'e', 'w', ' ', 'i', 't', 'e', 'm']
ex1 = [-1, 20, -40, 15] # Сортировка без создания нового объекта
ex1.sort(key = abs, reverse = True)
ex1
[-40, 20, 15, -1]
ex1.reverse() # Переворот наоборот
ex1
[-1, 15, 20, -40]
excopy = ex1.copy() # Копирование объекта
excopy
[-1, 15, 20, -40]
ex1.index(-1) # Выдает индекс нужного элемента
0
ex1.count(-40) # Количество нужных элементов
1
ex1.clear() # Очищает объект
ex1
[]
```

Изучили создание вложенных списков:

```py
spis2 = [spis1, [1,2,3,4]]
spis2[0][1]
(5-9j)
spis2[1][0]
1
spis2[0][1] = 78
spis2
[['zero', 78, 'New item', 'Меня зовут: \n Шинкаренко В. А.', 'N', 'e', 'w', ' ', 'i', 't', 'e', 'm'], [1, 2, 3, 4]]
spis1 # Первый список тоже изменился
['zero', 78, 'New item', 'Меня зовут: \n Шинкаренко В. А.', 'N', 'e', 'w', ' ', 'i', 't', 'e', 'm']
# Собственный вложенный список:

let = 'лет'
mne = ['м', 'н', 'е']
age = 20
mne = ['М', 'н', 'е']
my_age = [mne, age, let, '!']
my_age
[['М', 'н', 'е'], 20, 'лет', '!']
```

### 8.2 Тип объекта: кортеж

Изучили создание данного типа объекта и работу с ним:

```py
kort1 = (222, 'Kortezh', 77 + 8j)
kort1 = kort1 + (ss1b,)
kort1
(222, 'Kortezh', (77+8j), 'Меня зовут: \n Шинкаренко В. А.')
kort2 = kort1[:2] + kort1[3:]
kort2
(222, 'Kortezh', 'Меня зовут: \n Шинкаренко В. А.')
kort1.index(222)
0
kort1.count(222)
1

word = 'World'
coma = ','
my_kortezh = ('H', 'e', 'l', 'l', 'o', coma, word, '!')
my_kortezh
('H', 'e', 'l', 'l', 'o', ',', 'World', '!')
```

### 8.3 Тип объекта: словарь

Изучили способы создания и управления словарей:

```py
dic1 = {'Saratov':145, 'Orel':56, 'Vologda':45}
dic1['Orel']
56
dic1['Pskov'] = 78
dic1
{'Saratov': 145, 'Orel': 56, 'Vologda': 45, 'Pskov': 78}
sorted(dic1.keys())
['Orel', 'Pskov', 'Saratov', 'Vologda']
sorted(dic1.values())
[45, 56, 78, 145]
dic2 = {1:'mean', 2:'standart deviation', 3:'correlation'}
dic3 = {'statistics':dic2, 'POAS':['base', 'elementary', 'programming']}
dic3
{'statistics': {1: 'mean', 2: 'standart deviation', 3: 'correlation'}, 'POAS': ['base', 'elementary', 'programming']}
dic3['statistics'][2]
'standart deviation'
dic4 = dict([(1, ['A', 'B', 'C']), (2, [4, 5]), ('Q', 'Prim'), ('Stroka', ss1b)])
dic5 = dict(zip(['A', 'B', 'C', 'Stroka'], [16, -3, 9, ss1b]))          

# Мой словарь:
my_kortezh
            
('H', 'e', 'l', 'l', 'o', ',', 'World', '!')
my_age
            
[['М', 'н', 'е'], 20, 'лет', '!']
my_dic = dict(zip(my_kortezh, my_age))
            
my_dic
            
{'H': ['М', 'н', 'е'], 'e': 20, 'l': '!'} # Количество элементов соотвествует минимальному количеству эементов 2х объектов
```

### 8.4 Тип объекта: множество

```py
mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
            
mnoz1
            
{'датчик', 'микропроцессор', 'линия связи', 'двигатель'}
len(mnoz1) # Нашли длину объекта
            
4
'датчик' in mnoz1
            
True
mnoz1.add('реле') # Добавили элементт
            
mnoz1.remove('линия связи') # Удалили элемент
            
mnoz1
            
{'двигатель', 'датчик', 'реле', 'микропроцессор'}          
mnoz_mine = {52, 'Ночь', 'День', my_kortezh, 'Ночь'}
            
mnoz_mine # Создали свой объект-множество
            
{'Ночь', 52, 'День', ('H', 'e', 'l', 'l', 'o', ',', 'World', '!')}
mnoz_mine.remove('Ночь')
mnoz_mine.add('День')
mnoz_mine
            
{52, 'День', ('H', 'e', 'l', 'l', 'o', ',', 'World', '!')}
```

## 9. Завершили сеанс работы.