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

Туровец Евгений, А-02-23

## 1. Запуск.

### 1.1 Запуск оболочки IDLE и установка рабочего каталога.

```py
import os
os.chdir('C:\Program Files (x86)\учёха 3 курс\pythonsky\python-labs\TEMA2')
```

![](1.png)

### 1.2 Текстового редактора и его сохранение в рабочий каталог

![](1.2.png)

В дальнейшем мы будем прописывать инстукции в данный текстовый редактор

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

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

познакомимся с операциями присваивания и выводом их значений

```py
f1=16; f2=3
f1,f2
```
Вывод:
```
(16, 3)
```
```py
f1;f2

```
Вывод:
```
16
3
```
### 2.2 Функция dir()

Познакомимся с функцией dir(), которая выводит объекты, уже существующие в среде питона
```py
dir()

```
Вывод:
```
['__annotations__', '__builtins__', '__doc__', '__file__',
 '__loader__', '__name__', '__package__', '__spec__', 'f1', 'f2']
```
```py
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']
```

### 2.3 Функция type()

Для определения класса объекта воспользуемся функцией type()

```py
type(f1)
```
Вывод:
```
<class 'int'>
```

### 2.4 Функция del()

Удалим переменные f1, f2:

```py
del f1,f2
dir()
```
Вывод:
```
['__annotations__', '__builtins__', '__doc__', '__file__',
 '__loader__', '__name__', '__package__', '__spec__']
```
Как мы видим, переменных f1,f2 нет в памяти

## 3-4. Правила именования и сохранение списка под именем:

Были введены некоторые предложенные команды, две из которых не соответствовали правилам именования:

![](3.png)

В первом случае получаем ошибку синтаксиса, т.к переменная начинается с цифры,
а во втором т.к нейминг переменной совпадает с ключевым словом

Создадим список и запишем его в переменную a
![](4.png)

## 5. Встроенные идентификаторы.

### 5.1  Вывод списка встроенных идентификаторов:

![](5.1.png)

### 5.2 Изучение назначения функций:

#### 5.2.1 Функция ABS:

![](abs.png)

#### 5.2.2 Функция len:

Создадиим последовательность чисел от 0 до 99, чтобы понять функционал len()

![](len.png)

На выводе получаем длину последовательности

#### 5.2.3 Функция max,min

![](minmax.png)

#### 5.2.4 Функция pow

![](pow.png)

#### 5.2.5 Функция round

![](round.png)

#### 5.2.6 Функция sorted

![](sorted.png)

#### 5.2.7 Функция sum

![](sum.png)

#### 5.2.8 Функция zip

![](zip.png)
 
Функция zip() объединяет несколько интегрируемых объектов в кортежи,
но т.к функция возвращает итератор, то чтобы увидеть результат - нужно перобразовать его в список

## 6. Типы объектов.

![](6.png)

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

int — целые числа (положительные, отрицательные или нуль).
float — числа с плавающей точкой (дробные числа).
complex — комплексные числа (имеют действительную и мнимую части).
str — строковый тип данных для хранения текстовой информации. Строка может содержать буквы, цифры, пробелы, символы.
bool в Python — это логический тип, принимать только два значения: True и False.

### 7.1 Логический тип:

![](7.1.png)

### 7.2 Иные простые типы:

![](7.2.png)

### 7.3 Строка символов:

Одинарные и двойные ковычки несут один и тот же смысл

Чтобы изменить вывод теста можно использовать "экранированные последовательности"

![](7.3.png)

#### Создадим строку по шаблону:

```py
ss1b= 'Меня зовут: \n Туровец Е.Ю'
print(ss1b)
```
Вывод:

```
Меня зовут: 
 Туровец Е.Ю
```
#### Создадим строку со значением объекта при помощи тройных кавычек:

![](7.4.png)

При выводе такой строки не будет появлятьс символ приглашения - >>> , до следующего вводв тройных кавычек.

#### К элементам строки можно обращаться используя индексацию:

![](7.5.png)

Можно также делать срезы текста

![](7.6.png)

![](7.7.png)

В данном случае 17 можно заменить на -4, т.к это тот же элемент, если считать с конца

![](7.8.png)

В таком случае мы переопределяем элемент по индексом 4

Сделаем срез текста присвоенного переменной ss1b:

![](7.9.png)

## 8. Списки, кортежи, словари и множества.

```py
help(list)
```
Вывод:
```
Help on class list in module builtins:

class list(object)
 |  list(iterable=(), /)
 |
 |  Built-in mutable sequence.
 |
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, index, /)
 |      Return self[index].
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(self, /)
 |      Return a reverse iterator over the list.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |
 |  __sizeof__(self, /)
 |      Return the size of the list in memory, in bytes.
 |
 |  append(self, object, /)
 |      Append object to the end of the list.
 |
 |  clear(self, /)
 |      Remove all items from list.
 |
 |  copy(self, /)
 |      Return a shallow copy of the list.
 |
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
 |
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |
 |      Raises ValueError if the value is not present.
 |
 |  insert(self, index, object, /)
 |      Insert object before index.
 |
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
 |
 |      Raises IndexError if list is empty or index is out of range.
 |
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |
 |      Raises ValueError if the value is not present.
 |
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |
 |  sort(self, /, *, key=None, reverse=False)
 |      Sort the list in ascending order and return None.
 |
 |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
 |      order of two equal elements is maintained).
 |
 |      If a key function is given, apply it once to each list item and sort them,
 |      ascending or descending, according to their function values.
 |
 |      The reverse flag can be set to sort in descending order.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(object, /)
 |      See PEP 585
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None
```
```py
help(tuple)
```
Вывод:
```
Help on class tuple in module builtins:

class tuple(object)
 |  tuple(iterable=(), /)
 |
 |  Built-in immutable sequence.
 |
 |  If no argument is given, the constructor returns an empty tuple.
 |  If iterable is specified the tuple is initialized from iterable's items.
 |
 |  If the argument is a tuple, the return value is the same object.
 |
 |  Built-in subclasses:
 |      asyncgen_hooks
 |      UnraisableHookArgs
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |
 |      Raises ValueError if the value is not present.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(object, /)
 |      See PEP 585
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
```
```py
help(dict)
```
Вывод:

```
Help on class dict in module builtins:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |
 |  Methods defined here:
 |
 |  __contains__(self, key, /)
 |      True if the dictionary has the specified key, else False.
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __ior__(self, value, /)
 |      Return self|=value.
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(self, /)
 |      Return a reverse iterator over the dict keys.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |
 |  __sizeof__(self, /)
 |      Return the size of the dict in memory, in bytes.
 |
 |  clear(self, /)
 |      Remove all items from the dict.
 |
 |  copy(self, /)
 |      Return a shallow copy of the dict.
 |
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  items(self, /)
 |      Return a set-like object providing a view on the dict's items.
 |
 |  keys(self, /)
 |      Return a set-like object providing a view on the dict's keys.
 |
 |  pop(self, key, default=<unrepresentable>, /)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |
 |      If the key is not found, return the default if given; otherwise,
 |      raise a KeyError.
 |
 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E.keys(): D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |
 |  values(self, /)
 |      Return an object providing a view on the dict's values.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(object, /)
 |      See PEP 585
 |
 |  fromkeys(iterable, value=None, /)
 |      Create a new dictionary with keys from iterable and values set to value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None
```
### 8.1 Список

Список может состоять из элемнтов различных типов:

![](8.1.png)

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

![](8.1.1.png)

С элементами списка можно так же работать используя индексацию.

```py
stup=[0,0,1,1,1,1,1,1,1]
stup[-8::2]
```
Вывод:
```
[0, 1, 1, 1]
```
элемент под индексом -8 = элементу до индексом 1. Срез происходит до последнего элемента с шагом 2,
т.к не задан конечный элемент.

```py 
spis1[1]='Список'
spis1
```
Вывод:
```
[111, 'Список', (5-9j)]
```
Также можно узнать число элементов в списке с помощью функции len():

```py
len(spis1)
```
Вывод:
```
3
```
```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.
```
С помоющью .append можно добавлять элементы в список, а с помощью .pop - удалить

```py
spis1.append('New item')  # В конец списка добавлен элемент «New item»
spis1
```
Вывод:
```
[111, 'Список', (5-9j), 'New item']
```
Как мы видим в конец списка добавлен новый элемент

```py
spis1.append(ss1b)
spis1
```
Вывод:
```
[111, 'Список', (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю']
```
Изучим такие функции как:
insert, remove, extend, clear, sort, reverse, copy, count, index
```py
spis1.insert(1, 'Привет')  #вставит второй аргумент под номер индекса элемента.
spis1
[111, 'Привет', 78, (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю']
spis1.remove('Привет')  #удалит тот элемент, который полностью соответствует указанному в команде аргументу.
spis1
[111, 78, (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю']
spis1.extend('5-9')  #добавит каждый элемент аргумента в конце списка
spis1
[111, 78, (5-9j), 'New item', 'Меня зовут: \n Туровец Е.Ю', '5', '-', '9']
spis1.clear()  #удаляет все элементы из списка
spis1
[]
spis1=[5, 3, 2, 1, 7, 6, 9]
spis1.sort()  #сортировка списка как и по числам
spis1
[1, 2, 3, 5, 6, 7, 9]
spis12=['b', 'a', 'c', 'g', 't']  #так и по алфовиту
spis12.sort()
spis12
['a', 'b', 'c', 'g', 't']
spis12.reverse()  #перемешивает элементы в обратном порядке
spis12
['t', 'g', 'c', 'b', 'a']
spiscop=spis12.copy()
spiscop
['t', 'g', 'c', 'b', 'a']
spis1.count(5) #считает то, сколько раз элемент из аргумента появляется в списке
1
spis1.index(9) #возвращает индекс элемента, совпадающего по значению с аргументом
6
```
Списки также могут быть вложенными:

```py
spis2=[spis1,[4,5,6,7]]   #здесь элементами являются два списка
spis2[0][1]  #обращение к элементу списка spis1
'Список'
spis2[0][1]=78  #Убедитесь, что значение элемента заменено на 78
spis2[0][1]
78
```
```py
spis1
```
Вывод:
```
[1, 78, 3, 5, 6, 7, 9]
```
был видоизменен, ведь является элементом другого списка,
 к которому мы обратились и изменили соответственно

#### Был придуман список, содержащий в себе 4 элемента разных типов: число, строка, логическое значение и список
```py
list=[10,'Евгений',True,['a','b']]
list
```
Вывод:
```
[10, 'Евгений', True, ['a', 'b']]
```
### 8.2 Кортеж.

*Похож на список, но изменить его нельзя
```py
kort1=(222,'Kortezh',77+8j)
kort1[0]=10
```
Вывод:
```
Traceback (most recent call last):
  File "<pyshell#165>", line 1, in <module>
    kort1[0]=10
TypeError: 'tuple' object does not support item assignment
```
Получаем ошибку

Кортеж нельзя изменить, но можно переопределить

```py
kort1= kort1+(1,2)
kort1
```
Вывод:
```
(222, 'Kortezh', (77+8j), 1, 2)
```
Добавим ещё один элемент:
```py
kort1= kort1+(ss1b,)
kort1
```
Вывод:
```
(222, 'Kortezh', (77+8j), 1, 2, 'Меня зовут: \n Туровец Е.Ю')
```
Удаление элементов из кортежа можно делать путем переопределения срезом:
```py
kort2=kort1[:2]+kort1[3:]
kort2
```
Вывод:
```
(222, 'Kortezh', 1, 2, 'Меня зовут: \n Туровец Е.Ю')
```
.index и .count в кортежах работают так же как и в списках

Методов append и pop у кортежей нет, т.к. они являются неизменяемыми

Создадим собственный кортеж и элементами различных типов:
```py
korte=(10,'stroka',[10,'a'],(50,'b'))
korte
```
Вывод:
```
(10, 'stroka', [10, 'a'], (50, 'b'))
```

### 8.3 Словарь

Словарь является совокупностью пар типа 'key:value'

Создадим словарь:

```py
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
```
При обращении к ключу Orel получим:
```py
dic1['Orel']
```
Вывод:
```
56
```
Пополнение словаря:
```py
dic1['Pskov']=78
dic1
```
Вывод:
```
dic1['Pskov']=78
dic1
```
Словарь можно отсортировать по ключам или значениям:
```py
sorted(dic1.keys())
['Orel', 'Pskov', 'Saratov', 'Vologda']
sorted(dic1.values())
[45, 56, 78, 145]
```
Также можно создавать вложенные словари:
```py
dic2={1:'mean',2:'standart deviation',3:'correlation'}
dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
dic3['statistics'][2]
```
Вывод:
```
'standart deviation'
```
Более сложные словари с помощью функций dist и zip
![](8.3.png)

Создадим собственный словарь:
```py
cort=('a','b','c','d','e','f','g')
sp1s=[1,2,3,4,5]
ob=dict(zip(cort,sp1s))
ob
```
Вывод:
```
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
```
```py
len(ob)
```
Вывод:
```
5
```
Элементов 5, т.к команда zip работала столько раз, сколько элементов в наиболее маленьком объекте

```py
AVTI={'Курс I':[22,23,17,24,30,29,28,25,23,0,4,31,30,33,18,12,27],
'Курс II':[18,16,12,15,29,18,21,23,13,0,4,20,31,26,16,],
 'Курс III':[17,12,0,6,17,15,19,19,0,0,5,17,22,18,12],
 'Курс IV':[27,16,0,13,17,15,19,20,0,0,2,15,18,16,17]}
AVTI['Курс III'][5]
15
```
### 8.4 Множество

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

```py
mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
mnoz1
```
Вывод:
```
{'линия связи', 'датчик', 'двигатель', 'микропроцессор'}
```
Как мы видим дубли были удалены

Выведем число элементов в множестве:

```py
len(mnoz1)
4
```
Проверка наличия элемента во множестве:

```py
'датчик' in mnoz1
True
```
Добавление элемента:

```py
mnoz1.add('реле')
mnoz1
{'линия связи', 'датчик', 'реле', 'микропроцессор', 'двигатель'}
```
Удаление элемента:
```py
mnoz1.remove('линия связи')
mnoz1
{'датчик', 'реле', 'микропроцессор', 'двигатель'}
```
Было создано множество:
```py
mnoz1 = {'лев', '1', True, ('тигр', 1, 3)}
mnoz1
{('тигр', 1, 3), True, 'лев', '1'}
mnoz1.remove(True)
mnoz1
{('тигр', 1, 3), 'лев', '1'}
mnoz1.add('осёл')
mnoz1
{('тигр', 1, 3), 'лев', '1', 'осёл'}
```
## 9.
```py
exit()
```


