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

Терехов Фёдор Валерьевич, А-01-23
  
## 1. Изучение простых объектов.

1. _"Для того, чтобы узнать, какое значение имеет переменная, достаточно перечислить их имена в строке, разделяя их знаком «,» (запятая) или «;» (точка с запятой)."_  

>f1=16; f2=3  
>print("Значения переменных через запятую:")  
>print(f1, f2)  
>  
>print("\nЗначения переменных через точку с запятой:")  
>print(f1); print(f2)  

Ответ программы:  
![Task 1.1](images/Task1_1.png)  

2. _"Для того, чтобы узнать, какие объекты уже существуют в данный момент в среде Python (в пространстве имен), используйте функцию dir без аргументов."_  

>print("\nСуществующие объекты в пространстве имен:")  
>print(dir())  

Ответ программы:  
![Task 1.2](images/Task1_2.png)  

3. _"Для получения списка атрибутов любого объекта используйте ту же функцию dir(), с аргументами – именами интересующих объектов"_  

>print("\nАтрибуты объекта f1:")  
>print(dir(f1))  
>  
>print("\nАтрибуты объекта f2:")  
>print(dir(f2))  

Ответ программы:  
![Task 1.3](images/Task1_3.png)  

4. _"Для определения классовой принадлежности любого объекта следует использовать функцию type()."_  

>print(f"\nТип f1: {type(f1)}") #f перед текстом обозначает строку, переменные пишутся в {}  
>print(f"Тип f2: {type(f2)}")  

Ответ программы:  
![Task 1.4](images/Task1_4.png)  

5. _"Для удаления объекта или его части из оперативной памяти используйте инструкцию del."_

>print("\nУдаляем объекты f1 и f2...")  
>del f1, f2  
>  
>print("\nСуществующие объекты в пространстве имен ПОСЛЕ удаления:")  
>print(dir())  
>  
>print("\nПопытка обратиться к удаленным объектам:")  
>print(f1)  

Ответ программы:  
![Task 1.5](images/Task1_5.png)  
  
## 2. Изучение правил именования объектов в Python.  
_"Правила именования: 
    •  имена должны состоять из латинских букв, цифр и символов подчеркивания;
    •  имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
    •  имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
    •  большие и малые буквы в именах различаются (имена – чувствительные к регистру)!"_  
  
>gg1=1.6  #значение в виде вещественного числа  
>hh1='Строка'  #значение в виде символьной строки  
>73sr=3   #неправильное имя – начинается с цифры - будет диагностика!  
>and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!  

Ответ программы:  
![Task 2.1](images/Task2_1.png)  
![Task 2.2](images/Task2_2.png)  
  
## 3. Вывод списка ключевых слов с помощью инструкции import keyword && keyword.kwlist  
>import keyword  
>  
>print("Список ключевых слов Python:")  
>print(keyword.kwlist)  
![Task 3.1](images/Task3_1.png)  
Сохранение списка в переменной:  
>keywords_list = keyword.kwlist  
>print("\nСохранение в виде списка:")  
>print(keywords_list)  
![Task 3.2](images/Task3_2.png)  
  
## 4. Вывод списка встроенных идентификаторов с помощью инструкций import builtins && dir(builtins)  
>import builtins  
>  
>print("Список встроенных идентификаторов Python:")  
>builtins_list = dir(builtins)  
>print(builtins_list)  

![Task 4.1](images/Task4_1.png)  

>print("Справка по функциям:")  
>print("\n1. Функция abs():")  
>help(abs)  

![Task 4.2.1](images/Task4_2_1.png)  

>print("\n2. Функция len():")  
>help(len)  

![Task 4.2.2](images/Task4_2_2.png)  

>print("\n3. Функция max():")  
>help(max)  

![Task 4.2.3](images/Task4_2_3.png)  

>print("\n4. Функция min():")  
>help(min)  

![Task 4.2.4](images/Task4_2_4.png)  

>print("\n5. Функция pow():")  
>help(pow)  

![Task 4.2.5](images/Task4_2_5.png)  

>print("\n6. Функция round():")  
>help(round)  

![Task 4.2.6](images/Task4_2_6.png)  

>print("\n7. Функция sorted():")  
>help(sorted)  

![Task 4.2.7](images/Task4_2_7.png)  

>print("\n8. Функция sum():")  
>help(sum)  

![Task 4.2.8](images/Task4_2_8.png)  

>print("\n9. Функция zip():")  
>help(zip)  

![Task 4.2.9](images/Task4_2_9.png)  
  
## 5. Малые и большие буквы в именах объектов различаются.  
>Gg1=45  
>print(Gg1)  
>print(gg1)  

Ответ программы:  
![Task 5](images/Task5.png)  
  
## 6. Изучение простых базовых типов объектов: логический (bool), целый (int), вещественный (float), комплексный (complex), строка символов (str).  

### 6.1. Числовые типы.  
1. Логический тип.  

>bb1=True  
>bb2=False  
>print(f"bb1 = {bb1}")  
>print(f"bb2 = {bb2}")  
>print(f"Класс объекта: {type(bb1)}")  

Ответ программы:  
![Task 6.1.1](images/Task6_1_1.png)  

2. Целочисленный тип.  

>ii1=-1234567890  
>print(f"\nii1 = {ii1}")  
>print(f"Класс объекта: {type(ii1)}")  

Ответ программы:  
![Task 6.1.2](images/Task6_1_2.png)  

3. Экспоненциальная форма записи вещественного числа.  

>ff1=-8.9876e-12  
>print(f"\nff1 = {ff1}")  
>print(f"Класс объекта: {type(ff1)}")  

Ответ программы:  
![Task 6.1.3](images/Task6_1_3.png)  

4. Двоичное число.  
>dv1=0b1101010  
>print(f"\ndv1 = {dv1}")  
>print(f"Класс объекта: {type(dv1)}")  

Ответ программы:  
![Task 6.1.4](images/Task6_1_4.png)  

5. Восьмеричное число.  

>vsm1=0o52765  
>print(f"\nvsm1 = {vsm1}")  
>print(f"Класс объекта: {type(vsm1)}")  

Ответ программы:  
![Task 6.1.5](images/Task6_1_5.png)  

6. Шестнадцатеричное число.  

>shest1=0x7109af6  
>print(f"\nshest1 = {shest1}")  
>print(f"Класс объекта: {type(shest1)}")  

Ответ программы:  
![Task 6.1.6](images/Task6_1_6.png)  

7. Комплексное число.  

>cc1=2-3j  
>print(f"\ncc1 = {cc1}")  
>print(f"Класс объекта: {type(cc1)}")  

Ответ программы:  
![Task 6.1.7](images/Task6_1_7.png)  

8. Вещественное число.  

>a=3.67  
>b=-0.45  
>print(f"\na = {a}")  
>print(f"b = {b}")  
>print(f"Класс объекта a: {type(a)}")  
>print(f"Класс объекта b: {type(b)}")  

Ответ программы:  
![Task 6.1.8](images/Task6_1_8.png)  

9. Альтернативный способ задания комплексного числа.  

>cc2=complex(a,b)  
>print(f"\ncc2 = {cc2}")  
>print(f"Класс объекта cc2: {type(cc2)}")  

Ответ программы:  
![Task 6.1.9](images/Task6_1_9.png)  

### 6.2. Строки.  


1. *Строки можно заключать в апострофы или в двойные кавычки. Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие.*  

>ss1='Это - строка символов'  
>print(f"{ss1}\n")  
>ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"  
>print(ss1a)  

Ответ программы:  
![Task 6.2.1](images/Task6_2_1.png)  

2. *Создайте строку по шаблону. Выведите получившуюся строку на экран.*  

>ss1b= 'Меня зовут: \n TerekhovFV'  
>print(ss1b)  

Ответ программы:  
![Task 6.2.2](images/Task6_2_2.png)  

3. *Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек. При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.*  

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

Ответ программы:  
![Task 6.2.3](images/Task6_2_3.png)  

4. *Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. При этом надо учитывать, что нумерация символов начинается с 0. При знаке «-»(минус) отсчёт от конца строки.*  

>print(ss1[0])  
>print(ss1[8])  
>print(ss1[-2])  

Ответ программы:  
![Task 6.2.4](images/Task6_2_4.png)  

5. *Операция «разрезания» или «создания среза», создающая новый объект. В срезе указываются не позиции элементов, а их индексы и что указываемая правая граница в срез не включается.*  

>print(ss1[6:9])  #Это часть строки – символы с 6-го индекса по 8-й (9-й не включается!)  
>print(ss1[13:])  #Это часть строки – с 13-го индекса и до конца  
>print(ss1[:13])  #Это часть строки – с начала и до 12-го индекса включительно  
>print(ss1[5:-8])  #Это часть строки – с 5-го индекса и до 8-го от конца  
>print(ss1[3:17:2])  #Часть строки – с 3-го по 16-й индексы с шагом 2  

Ответ программы:  
![Task 6.2.5](images/Task6_2_5.png)  

*При отрицательном значении шага*  

>print(ss1[17:3:-2])  

Ответ программы:  
![Task 6.2.5.1](images/Task6_2_5_1.png)  

*Если "17" заменить на "-4", то получим такой же результат.*  

>print(ss1[-4:3:-2])  

Ответ программы:  
![Task 6.2.5.2](images/Task6_2_5_1.png)  


6. *Строка является неизменяемым объектом. Однако, можно это сделать по-другому, переопределив строку.*  

>ss1[4]='='  

Ответ программы:  
![Task 6.2.6.1](images/Task6_2_6_1.png)  

>ss1=ss1[:4]+'='+ss1[5:]  
>print(ss1)  

Ответ программы:  
![Task 6.2.6.2](images/Task6_2_6_2.png)  

7. *С использованием ранее созданной строки ss1b попробуйте создать объекты с разными срезами исходной строки.*  

>print(ss1b[-10:])  
>  
>print("\n")  
>ss1b="My name is "+ ss1b[-10:]  
>print(ss1b)  

Ответ программы:  
![Task 6.2.7](images/Task6_2_7.png)  

8. *Самостоятельно придумайте значения и создайте объекты разных типов. После этого отобразите типы и значения созданных объектов.*  

>целое_число = 42  
>вещественное_число = 3.14159  
>комплексное_число = 2 + 3j  
>строка = "Привет, мир!"  
>многострочная_строка = """Это  
>многострочная  
>строка"""  
>логическое_значение = True  
>print(целое_число)  
>print(вещественное_число)  
>print(комплексное_число)  
>print(строка)  
>print(многострочная_строка)  

Ответ программы:  
![Task 6.2.8](images/Task6_2_8.png)  
  

## 7. Изучение более сложных типов объектов: списки (list), кортежи (tuple), словари (dict), множества (set).  

### 7.1. Список.  

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

>spis1=[111,'Spisok',5-9j]  
>print(spis1)  

Ответ программы:  
![Task 7.1.1.](images/Task7_1_1.png)  

2. *Cписок, содержащий последовательность отсчетов сигнала в виде «единичной ступеньки».*  

>stup=[0,0,1,1,1,1,1,1,1]  
>print(stup)  

Ответ программы:  
![Task 7.1.2.](images/Task7_1_2.png)  

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

>spis=[1,2,3,4,  
      5,6,7,  
      8,9,10]  
>print(spis)  

Ответ программы:  
![Task 7.1.3.](images/Task7_1_3.png)  

4. *При работе с элементами списка можно использовать индексы точно так же, как это делали с элементами символьной строки.*  

>print(stup[-8::2])  

Ответ программы:  
![Task 7.1.4.](images/Task7_1_4.png)  

>spis1[1]='Список'  
>print(spis1)  

Ответ программы:  
![Task 7.1.5.](images/Task7_1_5.png)  

5. *Текущее число элементов в списке можно узнать с помощью функции len().*  

>print(len(spis1))  

Ответ программы:  
![Task 7.1.6.](images/Task7_1_6.png)  

6. *Описание метода можно вывести с помощью функции help().*  

>help(spis1.append)  

Ответ программы:  
![Task 7.1.7.](images/Task7_1_7.png)  

7. *С помощью методов объектов-списков можно добавлять и удалять элементы.*  

>spis1.append('New item1')  
>spis1=spis1+["New item2"]  
>spis1=spis1+[ss1b]  
>print(spis1)  

Ответ программы:  
![Task 7.1.8.](images/Task7_1_8.png)  

8. *Также могут использоваться методы insert, remove, extend, clear, sort, reverse, copy, count, index.*  

>#Создадим список для экспериментов  
>fruits = ["яблоко", "банан", "апельсин", "киви", "банан", "манго"]  
>print("Исходный список:", fruits)  
>print()  
>  
>#1. append() - добавление элемента в конец  
>fruits.append("виноград")  
>print("1. После append('виноград'):", fruits)  
>  
>#2. insert() - вставка элемента по индексу  
>fruits.insert(2, "лимон")  
>print("2. После insert(2, 'лимон'):", fruits)  
>  
>#3. extend() - расширение списка другим списком  
>more_fruits = ["груша", "персик"]  
>fruits.extend(more_fruits)  
>print("3. После extend(['груша', 'персик']):", fruits)  
>  
>#4. remove() - удаление первого найденного элемента по значению  
>fruits.remove("банан")  
>print("4. После remove('банан'):", fruits)  
>  
>#5. pop() - удаление элемента по индексу (и возврат значения)  
>removed_fruit = fruits.pop(1)  
>print("5. После pop(3):", fruits)  
>print("   Удаленный элемент:", removed_fruit)  
>  
>#6. clear() - полная очистка списка (создадим копию для демонстрации)  
>fruits_copy = fruits.copy()  
>fruits_copy.clear()  
>print("6. После clear() копии:", fruits_copy)  
>  
>#7. index() - поиск индекса элемента  
>index_kiwi = fruits.index("киви")  
>print("7. Индекс элемента 'киви':", index_kiwi)  
>  
>#8. count() - подсчет количества элементов  
>count_banana = fruits.count("банан")  
>print("8. Количество 'банан' в списке:", count_banana)  
>  
>#9. sort() - сортировка списка  
>fruits.sort()  
>print("9. После sort() (по алфавиту):", fruits)  
>  
>#10. reverse() - обратный порядок элементов  
>fruits.reverse()  
>print("10. После reverse():", fruits)  
>  
>#11. copy() - создание копии списка  
>fruits_copy2 = fruits.copy()  
>fruits_copy2.append("ананас")  
>print("11. Оригинал после copy():", fruits)  
>print("    Копия после append('ананас'):", fruits_copy2)  
>  
>#12. Дополнительно: len() - длина списка  
>print("12. Длина списка:", len(fruits))  
>  
>#13. Дополнительно: проверка наличия элемента  
>print("13. 'яблоко' в списке?", "яблоко" in fruits)  
>print("    'арбуз' в списке?", "арбуз" in fruits)  

Ответ программы:  
![Task 7.1.9.](images/Task7_1_9.png)  

9. *Списки могут быть вложенными.*  

>spis2=[spis1,[4,5,6,7]]  
>print(spis2)  

Ответ программы:  
![Task 7.1.10.](images/Task7_1_10.png)  

10. *Обращение к элементам вложенного списка.*  

>print(spis2[0][1])  

Ответ программы:  
![Task 7.1.11.](images/Task7_1_11.png)  

11. *Изменение элемента вложенного списка.*  

>spis2[0][1]=78  
>print(spis2[0][1])  

Ответ программы:  
![Task 7.1.12.](images/Task7_1_12.png)  

12. *Объект-список, элементами которого будут объекты разных типов.*  

>разнообразный_список = [  
    42,                                  # целое число  
    "Привет, мир!",                      # строка  
    True,                               # логическое значение  
    3.14159,                            # вещественное число  
    ["вложенный", "список", 123],       # вложенный список  
    {"ключ": "значение"},               # словарь  
    None,                               # специальное значение  
    complex(2, 3),                      # комплексное число  
    False                               # еще одно логическое значение  
>]  
>print(разнообразный_список)  

Ответ программы:  
![Task 7.1.13.](images/Task7_1_13.png)  
  

### 7.2. Кортеж.  

1. *Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддер­живают включение в них объектов различных типов и операции, типич­ные для последовательностей.*  

>kort1=(222,'Kortezh',77+8j)  
>print(kort1)  

Ответ программы:  
![Task 7.2.1.](images/Task7_2_1.png)  

2. *Изменить кортеж нельзя, но можно его переопределить.*  

>kort1= kort1+(1,2)  
>print(kort1)  

Ответ программы:  
![Task 7.2.2](images/Task7_2_2.png)  

3. *Если надо добавить еще один элемент в кортеж.*  

>ss1b= 'Меня зовут: \n TerekhovFV'  
>kort1= kort1+(ss1b,)  #ЗДЕСЬ ЗАПЯТАЯ ОБЯЗАТЕЛЬНА, ИНАЧЕ ОШИБКА
>print(kort1)  

Ответ программы:  
![Task 7.2.3](images/Task7_2_3.png)  

4. *Теперь переопределим кортеж с удалением комплексного элемента.*  

>kort2=kort1[:2]+kort1[3:]  
>print(kort2)  

Ответ программы:  
![Task 7.2.4](images/Task7_2_4.png)  

5. *Два важных метода кортежа (они есть также и у списков):*  

* Определение индекса заданного элемента:  

>print(kort1.index(2))  

Ответ программы:  
![Task 7.2.5](images/Task7_2_5.png)  

* Подсчет числа вхождений заданного элемента в кортеже:  

>print(kort1.count(222))  

Ответ программы:  
![Task 7.2.6](images/Task7_2_6.png)  

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

>kort1[2]=90  

Ответ программы:  
![Task 7.2.7](images/Task7_2_7.png)  

7. *Объект-кортеж с элементами разных типов: число, строка, список, кортеж.*  

>разнообразный_кортеж = (  
    100,                                # целое число  
    "Hello, Tuple!",                    # строка  
    [1, 2, 3, "список внутри кортежа"], # список  
    (4, 5, 6),                         # вложенный кортеж  
    3.14,                              # вещественное число  
    True,                              # логическое значение  
    None                               # специальное значение  
>)  
>print(разнообразный_кортеж)  

Ответ программы:  
![Task 7.2.8](images/Task7_2_8.png)  
  

### 7.3. Словарь.  

1. *Объект-словарь похож на ассоциативные массивы в других языках программирования. Его содержанием является совокупность пар: «ключ (key)»:«значение (value)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений.*  

>dic1={'Saratov':145, 'Orel':56, 'Vologda':45}  
>print(dic1)  

Ответ программы:  
![Task 7.3.1](images/Task7_3_1.png)  

2. *Обращение к элементам словаря не по индексам, а по ключам:*  

>print(dic1['Orel'])  

Ответ программы:  
![Task 7.3.2](images/Task7_3_2.png)  

3. *Пополнение словаря (добавление элемента, изменение словаря):*  

>dic1['Pskov']=78  
>print(dic1)  

Ответ программы:  
![Task 7.3.3](images/Task7_3_3.png)  

*Обратите внимание на то, что в силу неупорядоченности словаря при его выводе элементы могут располагаться не в том порядке, в каком они задавались при его формировании.*  
*Для того, чтобы получить перечень ключей или значений из словаря следует использовать методы keys или values, создающие списки, соответственно, ключей или значений из словаря.*  

4. *Функция sorted позволяет увидеть список упорядоченным по ключам или по значениям:*  

>print(sorted(dic1.keys()))  
>print(sorted(dic1.values()))  

Ответ программы:  
![Task 7.3.4](images/Task7_3_4.png)  

5. *Элементы словаря могут быть любого типа, в том числе и словарями.*  

>dic2={1:'mean',2:'standart deviation',3:'correlation'}  
>dic3={'statistics':dic2,'POAS':['base','elementary','programming']}  
>print(dic3['statistics'][2])  

Ответ программы:  
![Task 7.3.5](images/Task7_3_5.png)  

6. *Более сложный словарь из списка с элементами-кортежами с использованием функции dict:*  

>ss1b= 'Меня зовут: \n TerekhovFV'  
>dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])  
>print(dic4)  

Ответ программы:  
![Task 7.3.6](images/Task7_3_6.png)  

7. *Еще один словарь из двух списков: один для ключей и другой – для значений, с помощью функций dict и zip:*  

>dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))  
>print(dic5)  

Ответ программы:  
![Task 7.3.7](images/Task7_3_7png)  

8. *Объект-кортеж с 7 элементами и объект-список с 5 элементами и попробуйте создать из них словарь с помощью функций dict и zip.*  

>ключи = ('имя', 'возраст', 'город', 'профессия', 'стаж', 'зарплата', 'активен')  
>значения = ['Анна', 28, 'Москва', 'программист', True]  
>словарь = dict(zip(ключи, значения))  
>print(словарь)  
>print(f"Количество элементов в словаре: {len(словарь)}")  

Ответ программы:  
![Task 7.3.7](images/Task7_3_7png)  

### 7.4. Множество.

1. *Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).*  

>mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}  
>print(mnoz1)  

Ответ программы:  
![Task 7.4.1.](images/Task7_4_1.png)  

2. *Определение числа элементов:*  

>print(len(mnoz1))  

Ответ программы:  
![Task 7.4.2.](images/Task7_4_2.png)  

3. *Проверка наличия элемента во множестве:*  

>print('датчик' in mnoz1)  

Ответ программы:  
![Task 7.4.3.](images/Task7_4_3.png)  

4. *Дбавление элемента:*  

>mnoz1.add('реле')  
>print(mnoz1)  

Ответ программы:  
![Task 7.4.4.](images/Task7_4_4.png)  

5. *Удаление элемента:*  

>mnoz1.remove('линия связи')  
>print(mnoz1)  

Ответ программы:  
![Task 7.4.5.](images/Task7_4_5.png)  

6. *Объект-множество с элементами разных типов.*  

>разнообразное_множество = {  
    42,                    # целое число  
    "hello",               # строка  
    3.14,                  # вещественное число  
    True,                  # логическое значение (True = 1)  
    (1, 2, 3),             # кортеж (неизменяемый)  
    "world",               # еще одна строка  
    100,                   # еще одно число  
    False                  # логическое значение (False = 0)  
>}  
>print(разнообразное_множество)  
>print('\n')  
>разнообразное_множество.add("новый элемент")  
>print(разнообразное_множество)  
>print('\n')  
>разнообразное_множество.remove("hello")  
>print(разнообразное_множество)  
>print('\n')  
>print('hello' in разнообразное_множество)  

Ответ программы:  
![Task 7.4.6.](images/Task7_4_6.png)