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

Терехов Фёдор Валерьевич, А-01-23  

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

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

``` python
f1=16; f2=3
print("Значения переменных через запятую:")
print(f1, f2)

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


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

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

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

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

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

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

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

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

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

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

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

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

``` python
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;*  
* *большие и малые буквы в именах различаются (имена – чувствительные к регистру)!"*  

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

``` python
import keyword

print("Список ключевых слов Python:")
print(keyword.kwlist)
```
Ответ программы:  
![Task 3.1](images/Task3_1.png)  

*Сохранение списка в переменной:*  

``` python
keywords_list = keyword.kwlist
print("\nСохранение в виде списка:")
print(keywords_list)
```

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

## 4. Вывод списка встроенных идентификаторов с помощью инструкций import builtins && dir(builtins)  

``` python
import builtins

print("Список встроенных идентификаторов Python:")
builtins_list = dir(builtins)
print(builtins_list)
```
Ответ программы:  
![Task 4.1](images/Task4_1.png)  

``` python 
print("Справка по функциям:")
print("\n1. Функция abs():")
help(abs)
```
Ответ программы:  
![Task 4.2.1](images/Task4_2_1.png)  

``` python 
print("\n2. Функция len():")
help(len)
```
Ответ прошграммы:  
![Task 4.2.2](images/Task4_2_2.png)  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## 5. Малые и большие буквы в именах объектов различаются.  

``` python
Gg1=45
print(Gg1)
print(gg1)
```

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

## 6. Изучение простых базовых типов объектов: логический (bool), целый (int), вещественный (float), комплексный (complex), строка символов (str).  

### 6.1. Числовые типы.  

1. Логический тип.  

``` python
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. Целочисленный тип.  

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

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

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

``` python
ff1=-8.9876e-12
print(f"\nff1 = {ff1}")
print(f"Класс объекта: {type(ff1)}")
```
Ответ программы:  
![Task 6.1.3](images/Task6_1_3.png)  

4. Двоичное число.  

``` python
dv1=0b1101010
print(f"\ndv1 = {dv1}")
print(f"Класс объекта: {type(dv1)}")
```

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

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

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

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

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

``` python
shest1=0x7109af6
print(f"\nshest1 = {shest1}")
print(f"Класс объекта: {type(shest1)}")
```
Ответ программы:  
![Task 6.1.6](images/Task6_1_6.png)  

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

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

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

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

``` python
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. Альтернативный способ задания комплексного числа.  

``` python
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 и другие.*  

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

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

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

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

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

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

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

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

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

``` python
print(ss1[0])
print(ss1[8])
print(ss1[-2])
```

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

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

``` python
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)  

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

``` python
print(ss1[17:3:-2])
```
Ответ программы:  
![Task 6.2.5.1](images/Task6_2_5_1.png)  

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

``` python
print(ss1[-4:3:-2])
```

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

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

``` python
ss1[4]='='
```

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

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

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

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

``` python
print(ss1b[-10:])

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

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

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

``` python
целое_число = 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. *Список – это последовательность:  упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания.*  

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

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

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

``` python
stup=[0,0,1,1,1,1,1,1,1]
print(stup)
```

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

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

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

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

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

``` python
print(stup[-8::2])
```

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

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

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

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

``` python
print(len(spis1))
```

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

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

``` python
help(spis1.append)
```

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

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

``` python
pis1.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.*  

Создадим список для экспериментов:  

``` python
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. *Списки могут быть вложенными.*  

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

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

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

``` python
print(spis2[0][1])
```

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

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

``` python
spis2[0][1]=78
print(spis2[0][1])
```

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

*Теперь выведите на экран объект spis1. Объясните, почему он отличается от изначально заданного.*  

```python
print(spis1)
```

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

Список spis1 вложен в список spis2.  
Изменяя элемент списка spis2 spis1 мы изменяем сам spis1.  
Поэтому при выводе spis1 мы получаем уже изменённый список.  

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

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

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

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

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

``` python
kort1=(222,'Kortezh',77+8j)
print(kort1)
```
Ответ программы:  
![Task 7.2.1.](images/Task7_2_1.png)  

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

```python
kort1= kort1+(1,2)
print(kort1)
```

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

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

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

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

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

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

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

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

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

```python
print(kort1.index(2))
```

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

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

```python
print(kort1.count(222))
```

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

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

```python
kort1[2]=90
```

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

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

```python
разнообразный_кортеж = (
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)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений.*  

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

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

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

```python
print(dic1['Orel'])
```

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

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

```python
dic1['Pskov']=78
print(dic1)
```

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

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

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

```python
print(sorted(dic1.keys()))
print(sorted(dic1.values()))
```

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

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

```python
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:*  

```python
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:*  

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

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

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

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

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

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

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

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

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

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

```python
print(len(mnoz1))
```

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

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

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

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

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

```python
mnoz1.add('реле')
print(mnoz1)
```

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

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

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

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

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

```python
разнообразное_множество = {
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)  

## Общее контрольное задание.  

```python
import keyword  
  
familia = "Terekhov"  
first_letter = familia[0]  
  
sp_kw = list(keyword.kwlist)  
  
kort_nam = ("Фёдор", "Дима", "Вадим", "Екатерина")  
is_tuple = (type(kort_nam) is tuple)  
kort_nam = kort_nam + ("Павел", "Иван")  
count_dima = kort_nam.count("Дима")  
  
dict_bas = {  
"строка": familia,  
"символ (строка из 1 буквы)": first_letter,  
"список": sp_kw,  
"кортеж": kort_nam,  
"логический": is_tuple,  
}  
  
print(f"familia = {familia}")  
print(f"first_letter = {first_letter}")  
print(f"sp_kw (без 'nonlocal') содержит {len(sp_kw)} ключевых слов")  
print(f"Проверка типа kort_nam — tuple: {is_tuple}")  
print(f"kort_nam = {kort_nam}")  
print(f"Количество вхождений 'Дима' в kort_nam: {count_dima}")  
print("dict_bas (ключи → значение):")  
for k in dict_bas:  
print(f"  {k}: {dict_bas[k]}")  
```

Ответ программы:  
![Control task](images/control_task.png)  

## Индивидульное контрольное задание №9.  

*Создайте два объекта u=[1,2,3,4,5], v=[11,22,33,44,55]. К какому классу относятся эти объекты? Напишите инструкцию создания нового объекта-множества z с элементами из u и v.*  

```python
u=[1,2,3,4,5]
v=[11,22,33,44,55]

print(u)
print(type(u))
print('\n')

print(v)
print(type(v))
print('\n')
```

Ответ программы:  

```shell
[1, 2, 3, 4, 5]
<class 'list'>


[11, 22, 33, 44, 55]
<class 'list'>
```

Объекты u и v относятся к классу "Список". Класс список является изменяемым объектом, поэтому множество из них создать нельзя (элементы множества должны быть неизменяемыми объектами).  

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

```python
z=set(u+v)
```

Символ "+" соединяет два списка, команда set() преобразует их в множество.  

Код для решения индивидуального контрольного задания:  

```python
u=[1,2,3,4,5]
v=[11,22,33,44,55]

print(f"u = {u}")
print(f"Класс объекта \"u\" = {type(u)}\n")

print(f"v = {v}")
print(f"Класс объекта \"v\" = {type(v)}\n")

z=set(u+v)
print(f"z = {z}")
print(f"Класс объекта \"z\" = {type(z)}\n")
```

Ответ программы:  
```shell
u = [1, 2, 3, 4, 5]
Класс объекта "u" = <class 'list'>

v = [11, 22, 33, 44, 55]
Класс объекта "v" = <class 'list'>

z = {1, 2, 3, 4, 5, 33, 11, 44, 22, 55}
Класс объекта "z" = <class 'set'>
```