Лекция №3. Структуры данных

Хорошевич Павел Александрович

Строки

Строковые литералы

Строка - это последовательность пронумерованных символов. Строковые значения в Python имеют тип str.

name = 'Иван'
last_name = "Иванов"
print(name, last_name)

Тройные кавычки сохраняют форматирование строк и отступов:

code = """
for i in range(1, 10):
    if i == 5:
        continue
    print(i)
"""
print(code)

Оператор индексирования строки

Каждый символ в строке обладает порядковым номером - индексом. Нумерация символов начинается с 0 (слева направо).

Чтобы обратиться к символу по его индексу используется оператор индексирования [<индекс>]:

msg = "Язык Python"
print(msg[2])   # берём третий слева символ
print(msg[-4])  # берём четвертый справа символ

Индексация строки

Значения в строковом типе - не изменяемы. Нельзя заменить отдельные символы, обратившись к ним по индексу:

msg = "Кот"
msg[1] = "и" # ошибка!

Длина строки

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

Чтобы узнать длину строки используется функция len():

msg = "Язык Python"
print(len(msg))

Последний символ строки:

msg = "Язык Python"
last = st[len(msg) - 1]
print(last)
last = msg[-1]
print(last)

Стоит учитывать, что строка может быть пустой. В таком случае, её длина будет равна 0:

empty = "" # пустая строка
print(len(empty))

Оператор получения среза

Для того, чтобы получить подстроку в Python используется оператор среза - [<начало>:<конец>].

writers = "Ильф и Петров"
print(writers[0:4])
print(writers[7:13])

Если не указать <начало> или <конец> среза, то копирование строки начнётся с первого или до последнего символа соответственно:

writers = "Ильф и Петров"
print(writers[:4])
print(writers[7:])

Если пропустить и <начало> и <конец>, то получим копию строки:

writers = "Ильф и Петров"
print(writers)
copy = writers[:] # сохраняем копию строки
print(copy)

Общая форма записи оператора среза: [<начало>:<граница>:<шаг>]. Последнее значение определяет с каким шагом нужно брать символы из строки:

word = 'тшеикфсрт'

# берём символы начиная с первого и до конца строки через 1
first = word[0::2]
# берём символы начиная со второго и до конца строки через 1
second = word[1::2]

print(first)
print(second)

Конкатенация и повторение строк

К строковым значениям применимы два арифметических оператора - сложение и умножение.

Сложение строковых значений называется конкатенацией:

name = "Иван"
last_name = "Иванов"
print(name + " " + last_name)

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

print("Год: " + 2025) # Возникнет ошибка

Числа нужно явно преобразовать в строковый тип функцией str():

print("Год: " + str(2025))

Оператор принадлежности in

С помощью оператора in можно выяснить входит ли подстрока в строку:

st = "Привет"
print("ри" in st)
print("по" in st)

Результат работы оператора - логическое значение. Если добавить перед in логический оператор not, то мы проверим, что подстрока не входит в строку:

st = "Привет"
print("вет" not in st)

Методы класса str

Все строковые значения являются объектами класса str. В этом можно убедится с помощью функции type(), которая возвращает тип аргумента:

s = "Скрипт"
print(type(s))

Класс str обладает рядом методов, которые упрощают обработку строк.

Таблица 1: Некоторые методы класса str

Метод	Назначение
s.count(sub)	Количество вхождений подстроки sub в строку s
s.find(sub)	Находит индекс первого вхождения подстроки sub в строку s
s.replace(old, new)	Заменяет подстроку old на new; возвращает новую строку
s.upper()	Преобразование всех символов в прописные; возвращает новую строку
s.lower()	Преобразование всех символов в строчные; возвращает новую строку

Вот примеры использования этих методов:

s = "целым овладевают по частям"
print(s.count('a')) # количество букв 'а' в строке
print(s.find('по')) # индекс первого вхождения подстроки 'по'
s_new = s.replace(" ", "-*-") # меняем пробелы на '-*-'
print(s_new)
s_big = s.upper() # делаем все буквы прописными
print(s_big)

Таблица 2: Инструкции и операторы для обработки строк

Инструкции и операторы	Назначение
+	Конкатенация
*	Повторение
<строка>[]	Индексирование
<строка>[ : ]	Срез
len(<строка>)	Длина строки
in, not in	Нахождение в строке
for <символ> in <строка>	Перебор символов

Вопрос? Вопрос. Вопрос!

mess = "Знание - сила!"

• mess[3]
• mess[1:4]
• mess[:6]
• mess[:]
• '!' in mess
• mess.count('а')
• mess.upper()
• mess[-1]

Списки

Создание списка

Список - это набор упорядоченных и пронумерованных элементов. В Python списки имеют тип list.

fib = [1, 1, 2, 3, 5, 8, 13]
goods = ["хлеб", "молоко", "мука"]

В Python элементы списка не обязательно должны быть одного типа:

arr = [1, 2, True, [4, 5, 6]]

Чтобы объявить пустой список, квадратные скобки оставляют пустыми:

lst = [] # пустой список

Оператор индексирования списка

Элементы списка пронумерованы и к ним можно обращаться по их индексу. Нумерация элементов списка начинается с нуля.

Индексирование списка

Получить элемент списка по его индексу можно с помощью оператора [<индекс>].

fib = [1, 1, 2, 3, 5, 8, 13]
print(fib[2])
print(fib[9-8])
print(fib[-2])

Списки относятся к изменяемому типу данных. Мы можем заменить значение, которое находится по заданному индексу:

myList = [0, 1, 4, 6]
print(myList[2])
myList[2] = 0 # меняем элемент с индексом 2 на 0
print(myList)

Элементами списка могут быть другие списки.

magic_sq = [
    [2, 7, 6],
    [9, 5, 1],
    [4, 3, 8]
]

print(magic_sq[1][2]) # вторая строка, третий столбец

Количество элементов списка

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

fib = [1, 1, 2, 3, 5, 8, 13]
print(len(fib))

Длина элементов не учитывается в расчёте длины списка:

alist = ["Привет", 2.0, 5]
print(len(alist))
print(len(alist[0]))

Оператор получения среза

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

a_list = ['а', 'б', 'в', 'г', 'д', 'е']
print(a_list[1:3])
print(a_list[:4])
print(a_list[3:])
print(a_list[:])

Сложение и умножение

Списки можно складывать между собой.

odd_list = [1, 3, 5]
even_list = [2, 4, 6]
new_list = odd_list + even_list
print(new_list)

Умножая список на целое число получим новый список в котором элементы исходного списка повторяются заданное количество раз:

zeroes = [0] # список из одного элемента равного 0
lst = zeroes * 5
print(lst)

Оператор принадлежности in

С помощью операторов in и not in можно определить есть ли в списке указанный элемент:

lang = ["Python", "JavaScript", "C++"]
print("Python" in lang)
print("Java" not in lang)

Разбиение и слияние строк

С помощью метода split() можно разделить строку и получить список подстрок.

Работа метода split()

verse = "Кто понял жизнь тот больше не спешит"
wds = verse.split()
print(wds)

Метод split() принимает в качестве аргумента разделитель строки:

verse = "Кто понял жизнь тот больше не спешит"
wds = verse.split("т") # разделитель - буква т
print(wds)

Метод класса join() объединяет элементы списка в одну строку.

Работа метода join()

wds = ["Красота", "спасёт", "мир"]
glue = ';'
s = glue.join(wds)
print(s)
print(wds)

print("***".join(wds))
print("".join(wds))

Методы класса list

Таблица 3: Некоторые методы класса list

Метод	Назначение
<список>.append(x)	Добавление x в конец списка
<список>.sort()	Сортировка списка
<список>.insert(i, x)	Вставка в список элемента x по индексу i
<список>.count(x)	Получение количества повторений x в списке
<список>.pop() <список>.pop(i)	Удаление из списка последнего или i-го элемента и возврат его значения

Рассмотрим пример применения некоторых методов:

q = [] # создаём пустой список
print(q)

# добавляем к списку два элемента
q.append("курсовая.doc")
q.append("фото.jpg")
print(q)

last = q.pop() # удаляем последний элемент списка
print("Последний элемент:", last)
print(q)

q.insert(0, "!ДИПЛОМ.docx") # вставляем элемент в начало списка
print(q)

Таблица 4: Инструкции и операторы для обработки списков

Инструкции и операторы	Значение
+	Конкатенация
*	Повторение
<список>[]	Индексирование
<список>[:]	Срез
len(<список>)	Количество элементов
for <элемент> in <список>	Перебор символов
<выражение> in <список>	Проверка принадлежности (Boolean)

Вопрос? Вопрос. Вопрос!

lst = [2, 4, 6, 8]

• lst[3]
• lst[1:3]
• 10 in lst

Абстрактные типы данных

Абстрактный тип данных (АТД) - это тип данных, интерфейс взаимодействия с которым определён без наличия конкретной реализации на языке программирования.

АТД содержит описание типа элементов, хранящихся в АТД и набор операций над ними. Описание операций производится через входные и выходные данные.

АТД не определяет то, какой будет реальная программная реализация. Детали программной реализации скрыты от пользователя АТД.

Контейнер - это структура данных для которой строго определён порядок добавления новых элементов а также их извлечения.

Структуры данных

Стек

Стек - это абстрактный тип данных, элементы в котором можно добавлять или извлекать только из одного конца - вершины стека.

Стек работает по принципу “Первым пришёл - последним ушёл”.

Примеры использования стека

• Хранение в стеке последовательности операций для последующей возможности их отменить.
• Вызов функций в языке программирования реализуется с помощью стека.
• Стек может применяться в алгоритмах поиска с возвратом (Backtracking).

Интерфейс типа данных Stack

Таблица 5: Интерфейс контейнера Stack

Метод/Свойство	Назначение
push(el)	Метод добавляет el на вершину стека.
pop()	Метод удаляет элемент с вершины стека и возвращает его.
peek()	Метод возвращает элемент с вершины стека не удаляя его.
size()	Метод возвращает количество элементов в стеке.

Реализация стека

Работу стека можно реализовать с помощью типа list и его методов.

Очередь

Очередь - абстрактный тип данных, элементы в который добавляются с одного конца а извлекаются из другого.

Очередь работает по принципу “Первым пришёл - первым вышел”.

Примеры использования очереди

• Реализация очереди печати для принтера.
• Очередь событий

Интерфейс типа данных Queue

Таблица 6: Интерфейс контейнера Queue

Метод/Свойство	Назначение
enqueue(el)	Метод добавляющий el в конец очереди.
dequeue()	Метод удаляет элемент из начала очереди и возвращает его.
peek()	Метод возвращает элемент из начала очереди но не удаляет его.
size()	Метод возвращает количество элементов в очереди.

Реализация очереди

Работу очереди так же можно реализовать с помощью типа list и его методов.