форкнуто от main/python-labs
Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
1009 строки
34 KiB
Markdown
1009 строки
34 KiB
Markdown
# Отчет по теме 2
|
|
|
|
Терехов Фёдор Валерьевич, А-01-23
|
|
|
|
## 1. Изучение простых объектов.
|
|
|
|
1. _"Для того, чтобы узнать, какое значение имеет переменная, достаточно перечислить их имена в строке, разделяя их знаком «,» (запятая) или «;» (точка с запятой)."_
|
|
|
|
``` python
|
|
f1=16; f2=3
|
|
print("Значения переменных через запятую:")
|
|
print(f1, f2)
|
|
|
|
print("\nЗначения переменных через точку с запятой:")
|
|
print(f1); print(f2)
|
|
```
|
|
|
|
|
|
Ответ программы:
|
|
|
|
|
|
2. _"Для того, чтобы узнать, какие объекты уже существуют в данный момент в среде Python (в пространстве имен), используйте функцию dir без аргументов."_
|
|
|
|
``` python
|
|
print("\nСуществующие объекты в пространстве имен:")
|
|
print(dir())
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
3. _"Для получения списка атрибутов любого объекта используйте ту же функцию dir(), с аргументами – именами интересующих объектов"_
|
|
|
|
``` python
|
|
print("\nАтрибуты объекта f1:")
|
|
print(dir(f1))
|
|
|
|
print("\nАтрибуты объекта f2:")
|
|
print(dir(f2))
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
4. _"Для определения классовой принадлежности любого объекта следует использовать функцию type()."_
|
|
|
|
``` python
|
|
print(f"\nТип f1: {type(f1)}") #f перед текстом обозначает строку, переменные пишутся в {}
|
|
print(f"Тип f2: {type(f2)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
5. _"Для удаления объекта или его части из оперативной памяти используйте инструкцию del."_
|
|
|
|
``` python
|
|
print("\nУдаляем объекты f1 и f2...")
|
|
del f1, f2
|
|
|
|
print("\nСуществующие объекты в пространстве имен ПОСЛЕ удаления:")
|
|
print(dir())
|
|
|
|
print("\nПопытка обратиться к удаленным объектам:")
|
|
print(f1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
## 2. Изучение правил именования объектов в Python.
|
|
|
|
*Правила именования:*
|
|
* *имена должны состоять из латинских букв, цифр и символов подчеркивания;*
|
|
* *имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);*
|
|
* *имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;*
|
|
* *большие и малые буквы в именах различаются (имена – чувствительные к регистру)!"*
|
|
|
|
``` python
|
|
gg1=1.6 #значение в виде вещественного числа
|
|
hh1='Строка' #значение в виде символьной строки
|
|
73sr=3 #неправильное имя – начинается с цифры - будет диагностика!
|
|
and=7 #недопустимое имя – совпадает с ключевым словом - будет диагностика!
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
|
|
|
|
## 3. Вывод списка ключевых слов с помощью инструкции import keyword && keyword.kwlist
|
|
|
|
``` python
|
|
import keyword
|
|
|
|
print("Список ключевых слов Python:")
|
|
print(keyword.kwlist)
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
*Сохранение списка в переменной:*
|
|
|
|
``` python
|
|
keywords_list = keyword.kwlist
|
|
print("\nСохранение в виде списка:")
|
|
print(keywords_list)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
## 4. Вывод списка встроенных идентификаторов с помощью инструкций import builtins && dir(builtins)
|
|
|
|
``` python
|
|
import builtins
|
|
|
|
print("Список встроенных идентификаторов Python:")
|
|
builtins_list = dir(builtins)
|
|
print(builtins_list)
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("Справка по функциям:")
|
|
print("\n1. Функция abs():")
|
|
help(abs)
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("\n2. Функция len():")
|
|
help(len)
|
|
```
|
|
Ответ прошграммы:
|
|
|
|
|
|
``` python
|
|
print("\n3. Функция max():")
|
|
help(max)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("\n4. Функция min():")
|
|
help(min)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("\n5. Функция pow():")
|
|
help(pow)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("\n6. Функция round():")
|
|
help(round)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("\n7. Функция sorted():")
|
|
help(sorted)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("\n8. Функция sum():")
|
|
help(sum)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
print("\n9. Функция zip():")
|
|
help(zip)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
## 5. Малые и большие буквы в именах объектов различаются.
|
|
|
|
``` python
|
|
Gg1=45
|
|
print(Gg1)
|
|
print(gg1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
## 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)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
2. Целочисленный тип.
|
|
|
|
``` python
|
|
ii1=-1234567890
|
|
print(f"\nii1 = {ii1}")
|
|
print(f"Класс объекта: {type(ii1)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
3. Экспоненциальная форма записи вещественного числа.
|
|
|
|
``` python
|
|
ff1=-8.9876e-12
|
|
print(f"\nff1 = {ff1}")
|
|
print(f"Класс объекта: {type(ff1)}")
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
4. Двоичное число.
|
|
|
|
``` python
|
|
dv1=0b1101010
|
|
print(f"\ndv1 = {dv1}")
|
|
print(f"Класс объекта: {type(dv1)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
5. Восьмеричное число.
|
|
|
|
``` python
|
|
vsm1=0o52765
|
|
print(f"\nvsm1 = {vsm1}")
|
|
print(f"Класс объекта: {type(vsm1)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
6. Шестнадцатеричное число.
|
|
|
|
``` python
|
|
shest1=0x7109af6
|
|
print(f"\nshest1 = {shest1}")
|
|
print(f"Класс объекта: {type(shest1)}")
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
7. Комплексное число.
|
|
|
|
``` python
|
|
cc1=2-3j
|
|
print(f"\ncc1 = {cc1}")
|
|
print(f"Класс объекта: {type(cc1)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
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)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
9. Альтернативный способ задания комплексного числа.
|
|
|
|
``` python
|
|
cc2=complex(a,b)
|
|
print(f"\ncc2 = {cc2}")
|
|
print(f"Класс объекта cc2: {type(cc2)}")
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
### 6.2. Строки.
|
|
|
|
1. *Строки можно заключать в апострофы или в двойные кавычки. Внутри строки символов можно использовать, так называемые, «экранированные последовательности, начинающиеся со знака «\»(обратный слеш), например, \\, \', \", \t, \n и другие.*
|
|
|
|
``` python
|
|
ss1='Это - строка символов'
|
|
print(f"{ss1}\n")
|
|
ss1a="Это - \" строка символов \", \n \t выводимая на двух строках"
|
|
print(ss1a)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
2. *Создайте строку по шаблону. Выведите получившуюся строку на экран.*
|
|
|
|
``` python
|
|
ss1b= 'Меня зовут: \n TerekhovFV'
|
|
print(ss1b)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
3. *Многострочные строки можно задавать в виде значения объекта с использованием тройных кавычек. При вводе такой строки символ приглашения в начале строки не появится, пока не будет вновь введены тройные кавычки.*
|
|
|
|
``` python
|
|
mnogo="""Нетрудно заметить , что в результате операции
|
|
над числами разных типов получается число,
|
|
имеющее более сложный тип из тех, которые участвуют в операции."""
|
|
print(mnogo)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
4. *Можно обращаться к частям строки символов с использованием индексов символов по их порядку в строке. При этом надо учитывать, что нумерация символов начинается с 0. При знаке «-»(минус) отсчёт от конца строки.*
|
|
|
|
``` python
|
|
print(ss1[0])
|
|
print(ss1[8])
|
|
print(ss1[-2])
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
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
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
*При отрицательном значении шага*
|
|
|
|
``` python
|
|
print(ss1[17:3:-2])
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
*Если "17" заменить на "-4", то получим такой же результат.*
|
|
|
|
``` python
|
|
print(ss1[-4:3:-2])
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
6. *Строка является неизменяемым объектом. Однако, можно это сделать по-другому, переопределив строку.*
|
|
|
|
``` python
|
|
ss1[4]='='
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
ss1=ss1[:4]+'='+ss1[5:]
|
|
print(ss1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
7. *С использованием ранее созданной строки ss1b попробуйте создать объекты с разными срезами исходной строки.*
|
|
|
|
``` python
|
|
print(ss1b[-10:])
|
|
|
|
print("\n")
|
|
ss1b="My name is "+ ss1b[-10:]
|
|
print(ss1b)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
8. *Самостоятельно придумайте значения и создайте объекты разных типов. После этого отобразите типы и значения созданных объектов.*
|
|
|
|
``` python
|
|
целое_число = 42
|
|
вещественное_число = 3.14159
|
|
комплексное_число = 2 + 3j
|
|
строка = "Привет, мир!"
|
|
многострочная_строка = """Это
|
|
многострочная
|
|
строка"""
|
|
логическое_значение = True
|
|
print(целое_число)
|
|
print(вещественное_число)
|
|
print(комплексное_число)
|
|
print(строка)
|
|
print(многострочная_строка)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
## 7. Изучение более сложных типов объектов: списки (list), кортежи (tuple), словари (dict), множества (set).
|
|
|
|
### 7.1. Список.
|
|
|
|
1. *Список – это последовательность: упорядоченная по местоположению коллекция объектов произвольных типов, размер которых практически не ограничен. В отличие от символьных строк, списки являются изменяемыми последовательностями, т.е. их элементы могут изменяться с помощью операций присваивания.*
|
|
|
|
``` python
|
|
spis1=[111,'Spisok',5-9j]
|
|
print(spis1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
2. *Cписок, содержащий последовательность отсчетов сигнала в виде «единичной ступеньки».*
|
|
|
|
``` python
|
|
stup=[0,0,1,1,1,1,1,1,1]
|
|
print(stup)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
3. *Список можно вводить на нескольких строках. При этом список будет считаться незавершенным, пока не будет введена закрывающая квадратная скобка.*
|
|
|
|
``` python
|
|
spis=[1,2,3,4,
|
|
5,6,7,
|
|
8,9,10]
|
|
print(spis)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
4. *При работе с элементами списка можно использовать индексы точно так же, как это делали с элементами символьной строки.*
|
|
|
|
``` python
|
|
print(stup[-8::2])
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
``` python
|
|
spis1[1]='Список'
|
|
print(spis1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
5. *Текущее число элементов в списке можно узнать с помощью функции len().*
|
|
|
|
``` python
|
|
print(len(spis1))
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
6. *Описание метода можно вывести с помощью функции help().*
|
|
|
|
``` python
|
|
help(spis1.append)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
7. *С помощью методов объектов-списков можно добавлять и удалять элементы.*
|
|
|
|
``` python
|
|
pis1.append('New item1')
|
|
spis1=spis1+["New item2"]
|
|
spis1=spis1+[ss1b]
|
|
print(spis1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
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)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
9. *Списки могут быть вложенными.*
|
|
|
|
``` python
|
|
spis2=[spis1,[4,5,6,7]]
|
|
print(spis2)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
10. *Обращение к элементам вложенного списка.*
|
|
|
|
``` python
|
|
print(spis2[0][1])
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
11. *Изменение элемента вложенного списка.*
|
|
|
|
``` python
|
|
spis2[0][1]=78
|
|
print(spis2[0][1])
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
*Теперь выведите на экран объект spis1. Объясните, почему он отличается от изначально заданного.*
|
|
|
|
```python
|
|
print(spis1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
Список spis1 вложен в список spis2.
|
|
Изменяя элемент списка spis2 spis1 мы изменяем сам spis1.
|
|
Поэтому при выводе spis1 мы получаем уже изменённый список.
|
|
|
|
12. *Объект-список, элементами которого будут объекты разных типов.*
|
|
|
|
``` python
|
|
разнообразный_список = [
|
|
42, # целое число
|
|
"Привет, мир!", # строка
|
|
True, # логическое значение
|
|
3.14159, # вещественное число
|
|
["вложенный", "список", 123], # вложенный список
|
|
{"ключ": "значение"}, # словарь
|
|
None, # специальное значение
|
|
complex(2, 3), # комплексное число
|
|
False # еще одно логическое значение
|
|
]
|
|
print(разнообразный_список)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
### 7.2. Кортеж.
|
|
|
|
1. *Объект-кортеж похож на список, но его нельзя изменить – кортежи являются последовательностями, как списки, но они являются неизменяемыми, как строки. В отличие от списка литерал кортежа заключается в круглые, а не в квадратные скобки. Кортежи также поддерживают включение в них объектов различных типов и операции, типичные для последовательностей.*
|
|
|
|
``` python
|
|
kort1=(222,'Kortezh',77+8j)
|
|
print(kort1)
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
2. *Изменить кортеж нельзя, но можно его переопределить.*
|
|
|
|
```python
|
|
kort1= kort1+(1,2)
|
|
print(kort1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
3. *Если надо добавить еще один элемент в кортеж.*
|
|
|
|
```python
|
|
ss1b= 'Меня зовут: \n TerekhovFV'
|
|
kort1= kort1+(ss1b,) #ЗДЕСЬ ЗАПЯТАЯ ОБЯЗАТЕЛЬНА, ИНАЧЕ ОШИБКА
|
|
print(kort1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
4. *Теперь переопределим кортеж с удалением комплексного элемента.*
|
|
|
|
```python
|
|
kort2=kort1[:2]+kort1[3:]
|
|
print(kort2)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
5. *Два важных метода кортежа (они есть также и у списков):*
|
|
|
|
* Определение индекса заданного элемента:
|
|
|
|
```python
|
|
print(kort1.index(2))
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
* Подсчет числа вхождений заданного элемента в кортеже:
|
|
|
|
```python
|
|
print(kort1.count(222))
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
6. *Методов append и pop у кортежей нет, т.к. они являются неизменяемыми.*
|
|
|
|
```python
|
|
kort1[2]=90
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
7. *Объект-кортеж с элементами разных типов: число, строка, список, кортеж.*
|
|
|
|
```python
|
|
разнообразный_кортеж = (
|
|
100, # целое число
|
|
"Hello, Tuple!", # строка
|
|
[1, 2, 3, "список внутри кортежа"], # список
|
|
(4, 5, 6), # вложенный кортеж
|
|
3.14, # вещественное число
|
|
True, # логическое значение
|
|
None # специальное значение
|
|
)
|
|
print(разнообразный_кортеж)
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
### 7.3. Словарь.
|
|
|
|
1. *Объект-словарь похож на ассоциативные массивы в других языках программирования. Его содержанием является совокупность пар: «ключ (key)»:«значение (value)». В качестве ключей могут использоваться неизменяемые типы объектов. Значениями могут быть объекты любого типа. Ссылка на ключ обеспечивает быстрый доступ к связанному с ним значению. В отличие от списков и кортежей совокупность элементов словаря не является упорядоченной (последовательностью). Его элементы могут изменяться с помощью операции присваивания значений.*
|
|
|
|
```python
|
|
dic1={'Saratov':145, 'Orel':56, 'Vologda':45}
|
|
print(dic1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
2. *Обращение к элементам словаря не по индексам, а по ключам:*
|
|
|
|
```python
|
|
print(dic1['Orel'])
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
3. *Пополнение словаря (добавление элемента, изменение словаря):*
|
|
|
|
```python
|
|
dic1['Pskov']=78
|
|
print(dic1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
*Обратите внимание на то, что в силу неупорядоченности словаря при его выводе элементы могут располагаться не в том порядке, в каком они задавались при его формировании.*
|
|
*Для того, чтобы получить перечень ключей или значений из словаря следует использовать методы keys или values, создающие списки, соответственно, ключей или значений из словаря.*
|
|
|
|
4. *Функция sorted позволяет увидеть список упорядоченным по ключам или по значениям:*
|
|
|
|
```python
|
|
print(sorted(dic1.keys()))
|
|
print(sorted(dic1.values()))
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
5. *Элементы словаря могут быть любого типа, в том числе и словарями.*
|
|
|
|
```python
|
|
dic2={1:'mean',2:'standart deviation',3:'correlation'}
|
|
dic3={'statistics':dic2,'POAS':['base','elementary','programming']}
|
|
print(dic3['statistics'][2])
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
6. *Более сложный словарь из списка с элементами-кортежами с использованием функции dict:*
|
|
|
|
```python
|
|
ss1b= 'Меня зовут: \n TerekhovFV'
|
|
dic4=dict([(1,['A','B','C']),(2,[4,5]),('Q','Prim'),('Stroka',ss1b)])
|
|
print(dic4)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
7. *Еще один словарь из двух списков: один для ключей и другой – для значений, с помощью функций dict и zip:*
|
|
|
|
```python
|
|
dic5=dict(zip(['A','B','C','Stroka'],[16,-3,9,ss1b]))
|
|
print(dic5)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
8. *Объект-кортеж с 7 элементами и объект-список с 5 элементами и попробуйте создать из них словарь с помощью функций dict и zip.*
|
|
|
|
```python
|
|
ключи = ('имя', 'возраст', 'город', 'профессия', 'стаж', 'зарплата', 'активен')
|
|
значения = ['Анна', 28, 'Москва', 'программист', True]
|
|
словарь = dict(zip(ключи, значения))
|
|
print(словарь)
|
|
print(f"Количество элементов в словаре: {len(словарь)}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
### 7.4. Множество.
|
|
|
|
1. *Объект-множество – это неупорядоченная совокупность неповторяющихся элементов. Эти элементы могут быть разных, но только неизменяемых типов (числа, строки, кортежи).*
|
|
|
|
```python
|
|
mnoz1={'двигатель','датчик','линия связи','датчик','микропроцессор','двигатель'}
|
|
print(mnoz1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
2. *Определение числа элементов:*
|
|
|
|
```python
|
|
print(len(mnoz1))
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
3. *Проверка наличия элемента во множестве:*
|
|
|
|
```python
|
|
print('датчик' in mnoz1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
4. *Добавление элемента:*
|
|
|
|
```python
|
|
mnoz1.add('реле')
|
|
print(mnoz1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
5. *Удаление элемента:*
|
|
|
|
```python
|
|
mnoz1.remove('линия связи')
|
|
print(mnoz1)
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
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 разнообразное_множество)
|
|
```
|
|
Ответ программы:
|
|
|
|
|
|
## Общее контрольное задание.
|
|
|
|
```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]}")
|
|
```
|
|
|
|
Ответ программы:
|
|
|
|
|
|
## Индивидульное контрольное задание №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'>
|
|
```
|