python-labs/TEMA2/report.md

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print("\nУдаляем объекты f1 и f2...")
del f1, f2

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

print("\nПопытка обратиться к удаленным объектам:")
print(f1)

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

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

Правила именования:

• имена должны состоять из латинских букв, цифр и символов подчеркивания;
• имена должны начинаться с латинской буквы (иногда могут начинаться с символа подчеркивания, но это – особый вид переменных);
• имена не должны совпадать с ключевыми словами и встроенными идентификаторами языка Python;
• большие и малые буквы в именах различаются (имена – чувствительные к регистру)!"

gg1=1.6  #значение в виде вещественного числа
hh1='Строка'  #значение в виде символьной строки
73sr=3   #неправильное имя – начинается с цифры - будет диагностика!
and=7     #недопустимое имя – совпадает с ключевым словом - будет диагностика!

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

3. Вывод списка ключевых слов с помощью инструкции import keyword && keyword.kwlist

import keyword

print("Список ключевых слов Python:")
print(keyword.kwlist)

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

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

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

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

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

import builtins

print("Список встроенных идентификаторов Python:")
builtins_list = dir(builtins)
print(builtins_list)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Gg1=45
print(Gg1)
print(gg1)

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

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)}")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)}")

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

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

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

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

6.2. Строки.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ss1[4]='='

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

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

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

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

print(ss1b[-10:])

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

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

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

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

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

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

7.1. Список.

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

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

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

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

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

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

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

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

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

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

print(stup[-8::2])

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

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

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

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

print(len(spis1))

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

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

help(spis1.append)

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

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

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

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

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)

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

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

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

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

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

print(spis2[0][1])

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

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

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

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

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

print(spis1)

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

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

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

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

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

7.2. Кортеж.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(kort1.index(2))

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

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

print(kort1.count(222))

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

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

kort1[2]=90

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

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

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

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

7.3. Словарь.

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

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

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

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

print(dic1['Orel'])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(len(mnoz1))

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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')

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

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


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

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

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

z=set(u+v)

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

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

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")

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

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