Ключевые вопросы параграфа
- Что такое коллекции в Python и какие из них — упорядоченными?
- Как обращаться к элементам строки, списка и кортежа по индексу?
- Чем отличаются строки, списки и кортежи между собой?
- Какие методы существуют для работы со строками и списками?
- Как создавать срезы и преобразовывать одни коллекции в другие?
Упорядоченные коллекции: строки, списки и кортежи
Начнём с уже знакомой строки (str) и посмотрим на неё как на коллекцию — последовательность символов, к которой можно обращаться по индексам. А затем перейдём к другим упорядоченным структурам: спискам и кортежам. Они позволяют хранить сразу несколько значений — и во многом похожи на строки, но с важными отличиями.
Что такое коллекции и индексация
Если рассмотреть строку детальнее, то она состоит из символов, каждый из которых стоит на своём месте. Другими словами, строка — это упорядоченная последовательность (коллекция) символов.
Слово «коллекция» в Python используется для обозначения типов данных, которые могут хранить сразу несколько значений. Строка — лишь один из таких типов. Помимо неё, к упорядоченным коллекциям относятся списки (list
) и кортежи (tuple
).
Во всех этих коллекциях элементы автоматически получают индексы — номера, по которым к ним можно обращаться.
В Python индексация начинается с нуля. Это значит, что:
- первый элемент имеет индекс 0,
- второй — индекс 1,
- и так далее.
В строке по индексу можно получить любой символ, включая пробелы, запятые, управляющие символы вроде \n
, \t
и другие.
Обращение к элементам по индексу
Чтобы получить символ строки по индексу, нужно указать этот индекс в квадратных скобках сразу после переменной:
1text = input()
2print(text[0])
Если пользователь введёт, например, Привет, программа выведет П — первый символ строки.
Но если строка окажется пустой, то возникнет ошибка:
IndexError: string index out of range
Это значит, что мы обратились к символу, которого не существует. Чтобы избежать этой ошибки, стоит заранее проверить, входит ли индекс в допустимые границы — например, с помощью функции len()
:
1text = input("Введите строку: ")
2i = int(input("Введите индекс символа: "))
3if i < len(text):
4 print(text[i])
5else:
6 print("Индекс выходит за пределы строки")
Отрицательная индексация
Допустим, мы хотим получить последний символ строки. Один из способов — использовать len()
:
1text = input()
2print(text[len(text) - 1])
Однако в Python есть более удобный способ: отрицательная индексация. Последний элемент строки имеет индекс -1
, предпоследний — -2
, и так далее:
1text = input()
2print(text[-1])
Такой способ часто используется, когда нужно обратиться к символам с конца строки.
Проход по коллекциям
Когда коллекция — упорядоченная, мы можем перебрать её элементы один за другим. Это позволяет выполнять повторяющиеся действия: вывести каждый символ строки, изменить элементы списка или посчитать что-то по ходу итерации. В Python для этого чаще всего используются циклы.
В этом разделе мы рассмотрим три способа прохода по элементам коллекции:
- по индексам,
- по значениям,
- по индексам и значениям одновременно (с помощью функции
enumerate()
).
Цикл по индексам
Если нам важно знать индекс каждого элемента, можно пройти по коллекции с помощью цикла for
и функции range()
. Например, выведем по символу строки на каждой строке:
1text = input()
2for i in range(len(text)):
3 print(text[i])
Такой способ полезен, когда нужно не только получить значение, но и использовать индекс — например, при обращении к другим коллекциям по тому же индексу или при вычислениях.
Цикл по значениям
Если индекс не нужен, а важно просто пройти по элементам один за другим, запись становится короче и понятнее:
1text = input()
2for letter in text:
3 print(letter)
Здесь переменная letter
на каждой итерации принимает значение следующего символа строки. Такой цикл читается проще и используется чаще всего, если нам не нужен номер элемента.
Цикл с enumerate
Если нужно и значение, и его индекс — поможет функция enumerate()
. Она возвращает пары: индекс и элемент. Это особенно удобно, когда мы работаем с элементами, но ещё и хотим показать номер строки, порядковый номер слова и т.д.:
1text = input()
2for i, letter in enumerate(text):
3 print(f"{i}. {letter}")
Этот способ — универсальный и часто используется в реальных проектах: он делает код понятным и избавляет от необходимости отдельно отслеживать индекс.
Срезы
Работая с коллекциями, особенно со строками и списками, часто нужно взять только часть элементов — например, первые 5 символов строки или каждое второе число из списка. Для этого в Python существует мощный инструмент — срезы (англ. slice).
Срез позволяет удобно извлекать фрагмент коллекции, не прибегая к циклам и дополнительным условиям.
Синтаксис срезов
Срез записывается с помощью двойного двоеточия внутри квадратных скобок:
коллекция[начало:конец:шаг]
начало
— индекс, с которого начать (включительно);конец
— индекс, до которого взять (не включается!);шаг
— через сколько элементов двигаться (по умолчанию 1).
Любой из параметров можно опустить. Например:
text[:5]
— первые 5 символов;text[::2]
— каждый второй символ;text[::-1]
— строка в обратном порядке.
Также, как и при обычной индексации, здесь работает отрицательная индексация — можно отсчитывать с конца строки.
Важно: если указанные границы выходят за пределы строки, программа не выдаст ошибку — Python просто вернёт ту часть, которая существует.
Примеры срезов
Рассмотрим разные варианты срезов:
1text = "Привет, мир!"
2print(text[8:11])
3print(text[:6])
4print(text[8:])
5print(text[:])
6print(text[::2])
Результат:
мир Привет мир! Привет, мир! Пие,мр
Срезы — это простой способ быстро получить нужную часть данных без лишнего кода. Вы часто будете их использовать — и со строками, и со списками.
Работа со строками и списками
Строки — удобный и часто используемый тип данных в Python. Мы можем обращаться к отдельным символам, перебирать их в цикле, делать срезы. Но есть важная особенность: строка — это неизменяемая коллекция. Это значит, что изменить один из символов уже созданной строки нельзя: попытка сделать это приведёт к ошибке.
Тем не менее со строками можно гибко работать: создавать на их основе новые строки, изменяя регистр, удаляя пробелы, находя подстроки и не только. Всё это делается с помощью встроенных методов, которые мы сейчас рассмотрим.
Неизменяемость строк
Попробуем изменить первый символ строки:
1word = "мир"
2word[0] = "п"
Результат:
TypeError: 'str' object does not support item assignment
Ошибка возникает потому, что строки нельзя менять «на месте». Если нужно изменить строку, необходимо создать новую — например, с помощью срезов, операций или методов.
Методы строк
Ранее мы использовали встроенные функции. Методы — это похожий инструмент, но они «принадлежат» конкретному типу данных. У строк есть собственный набор методов, которые вызываются через точку после переменной:
1print("а".islower()) #True
2print("A".islower()) #False
Метод islower()
возвращает True
, если все буквы в строке — строчные. Таких методов у строк много — и они не изменяют исходную строку, а возвращают новую. Если нужно сохранить результат, его следует присвоить переменной.
Ниже — подборка часто используемых методов строк с описаниями и примерами. Эти методы позволяют выполнять самые разные операции: изменять регистр, искать подстроки, форматировать текст и многое другое.
Обратите внимание: методы не изменяют исходную строку, а возвращают новую. Если результат нужно использовать, его стоит сохранить в переменной.
str.capitalize()
Описание
Возвращает копию строки, у которой первая буква заглавная, а остальные приведены к строчным
Пример:
1 s = "hello, World!"
2 s.capitalize()
Результат:
Hello, world!
str.count(sub)
Описание
Возвращает количество неперекрывающихся вхождений подстроки sub. К примеру, если искать в строке «ААААА» неперекрывающиеся значения «АА», то первое вхождение будет «AAAAA». Второе — «AAAAA». Больше неперекрывающихся вхождений нет. Так, поиск последующих вхождений подстроки происходит с индекса, который следует за последним найденным вхождением
Пример:
1s = "Hello, world!"
2s.count("l")
Результат:
3
str.endswith(suffix)
Описание
Возвращает True, если строка оканчивается на подстроку suffix
. Иначе возвращает False. suffix
может быть кортежем проверяемых окончаний строки
Пример:
1s = "Hello, world!"
2s.endswith("world!")
Результат:
True
str.find(sub)
Описание
Возвращает индекс первого вхождения подстроки sub
. Если подстрока не найдена, то возвращает -1
Пример:
1s = "Hello, world!"
2s.index("o")
Результат:
4
str.index(sub)
Описание
Возвращает индекс первого вхождения подстроки sub
. Вызывает исключение ValueError, если подстрока не найдена. Тема ошибок (исключений) будет разбираться на одном из следующих параграфов
Пример:
1 s = "Hello, world!"
2 s.index("o")
Результат:
4
str.isalnum()
Описание
Возвращает True, если все символы строки являются буквами и цифрами и в строке есть хотя бы один символ. Иначе возвращает False
Пример:
1s = "abc123"
2s.isalnum()
Результат:
True
str.isalpha()
Описание
Возвращает True, если все символы строки являются буквами и в строке есть хотя бы один символ. Иначе возвращает False
Пример:
1s = "Letters"
2s.isalpha()
Результат:
True
str.isdigit()
Описание
Возвращает True, если все символы строки являются цифрами и в строке есть хотя бы один символ. Иначе возвращает False
Пример:
1s = "123"
2s.isdigit()
Результат:
True
str.islower()
Описание
Возвращает True, если все буквенные символы строки написаны строчными буквами. Иначе возвращает False
Пример:
1s = "word123"
2s.islower()
Результат:
True
str.isupper()
Описание
Возвращает True, если все буквы в строке большие и в строке есть хотя бы одна буква. Иначе возвращает False
Пример:
1s = "WORD123"
2s.isupper()
Результат:
True
str.join(str_col)
Описание
Возвращает строку, полученную конкатенацией (сложением) строк — элементов коллекции str_col
(обозначение коллекции с элементами типа данных «строка»). Разделителем является строка, для которой вызван метод и цифрами и в строке есть хотя бы один символ. Иначе возвращает False
Пример:
1a = ["1", "2", "3"]
2"; ".join(a)
Результат:
"1; 2; 3"
str.ljust(width, fillchar)
Описание
Возвращает строку длиной width
с выравниванием по левому краю. Строка дополняется справа символами fillchar
до требуемой длины. По умолчанию значение fillchar
— пробел
Пример:
1s = "text"
2s.ljust(10, "=")
Результат:
"text======"
str.lower()
Описание
Возвращает копию строки, у которой все буквы приведены к нижнему регистру
Пример:
1s = "Hello, World!"
2s.lower()
Результат:
"hello, world!"
str.lstrip(chars)
Описание
Возвращает строку, у которой в начале удалены символы, встречающиеся в строке chars
. Если значение chars
не задано, то пробельные символы удаляются
Пример:
1s = "BCCAstring"
2s.lstrip("ABC")
Результат:
"string"
str.rstrip(chars)
Описание
Возвращает строку, у которой в конце удалены символы, встречающиеся в строке chars
. Если значение chars
не задано, то пробельные символы удаляются
Пример:
1s = "stringBCCA"
2s.rstrip("ABC")
Результат:
"string"
str.split(sep)
Описание
Возвращает список строк по разделителю sep
. По умолчанию sep
— любое количество пробельных символов
Пример:
1s = "one, two, three"
2s.split(", ")
Результат:
["one", "two", "three"]
str.startswith(prefix)
Описание
Возвращает True, если строка начинается на подстроку prefix
, иначе возвращает False. prefix
может быть кортежем проверяемых префиксов строки. Под кортежами подразумевается неизменяемая последовательность элементов
Пример:
1s = "Hello, world!"
2s.startswith("Hello")
Результат:
True
str.strip(chars)
Описание
Возвращает строку, у которой в начале и в конце удалены символы, встречающиеся в строке chars
. Если значение chars
не задано, то пробельные символы удаляются
Пример:
1s = "abc Hello, world! cba"
2s.strip(" abc")
Результат:
"Hello, world!"
str.title()
Описание
Возвращает строку, в которой каждое отдельное слово начинается с буквы в верхнем регистре, а остальные буквы идут в нижнем
Пример:
1s = "hello, world!"
2s.title()
Результат:
"Hello, World!"
str.upper()
Описание
Возвращает копию строки, у которой все буквы приведены к верхнему регистру
Пример:
1s = "Hello, world!"
2s.upper()
Результат:
"HELLO, WORLD!"
str.zfill(width)
Описание
Возвращает строку, дополненную слева символами «0» до длины width
Пример:
1s = "123"
2s.zfill(5)
Результат:
"00123"
Списки: изменяемые коллекции
Список (list
) — ещё один важный тип коллекции в Python. В отличие от строки, он изменяемый, и может содержать элементы любого типа данных: числа, строки, даже другие списки.
Создание и доступ к элементам
Список (list
) — это упорядоченная коллекция, в которой можно хранить значения любых типов: числа, строки, логические значения и даже другие списки.
Один из самых простых способов создать список — перечислить его элементы в квадратных скобках:
1numbers = [10, 20, 30]
Списки могут содержать элементы разных типов:
1mixed_list = [10, 20.55, "text"]
Индексация в списках работает так же, как в строках:
- первый элемент имеет индекс 0,
- можно использовать отрицательные индексы,
- поддерживаются срезы.
Примеры:
1numbers = [10, 20, 30, 40, 50]
2print(numbers[0])
3print(numbers[-1])
4print(numbers[1:3])
5print(numbers[::-1])
Изменение и удаление элементов
В отличие от строк, списки — изменяемые. Это значит, что элементы в них можно заменять, удалять или добавлять новые.
Чтобы изменить элемент, достаточно указать его индекс:
1numbers = [10, 20, 50]
2numbers[2] = 30
3print(numbers)
Вывод программы:
[10, 20, 30]
Чтобы добавить элемент в конец списка, используется метод append()
. Например, так можно собрать список из 10 чисел, введённых пользователем:
1numbers = []
2for i in range(10):
3 numbers.append(int(input()))
4print(numbers)
Вывод программы:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Удалять элементы можно с помощью оператора del
:
1numbers = [10, 20, 50]
2del numbers[-1]
3print(numbers)
Вывод программы:
[10, 20]
Также del
поддерживает удаление по срезу:
1numbers = [1, 2, 3, 4, 5]
2del numbers[::2]
3print(numbers)
Вывод программы:
[2, 4]
Методы и операции со списками
Списки поддерживают множество встроенных методов и операций. С их помощью можно:
- проверить наличие элемента,
- объединить или дублировать списки,
- добавить или удалить элемент,
- отсортировать или развернуть список.
Некоторые методы изменяют список напрямую, другие возвращают новый результат. Это особенно важно при работе с копиями и при сортировке.
В таблице ниже приведены наиболее часто используемые методы и операции со списками — с примерами и результатами выполнения.
str.isalnum()
Описание
Возвращает True, если в списке s есть элемент x. Иначе False
Пример:
11 in [1, 2, 3]
Результат:
True
x not in s
Описание
Возвращает False, если в списке s есть элемент x. Иначе True
Пример:
14 not in [1, 2, 3]
Результат:
True
s + t
Описание
Возвращает список, полученный конкатенацией списков s и t
Пример:
1[1, 2] + [3, 4, 5]
Результат:
[1, 2, 3, 4, 5]
s * n (n * s)
Описание
Возвращает список, полученный дублированием n раз списка s
Пример:
1[1, 2, 3] * 3
Результат:
[1, 2, 3, 1, 2, 3, 1, 2, 3]
len(s)
Описание
Возвращает длину списка s
Пример:
1len([1, 2, 3])
Результат:
3
min(s)
Описание
Возвращает минимальный элемент списка
Пример:
1min([1, 2, 3])
Результат:
1
max(s)
Описание
Возвращает максимальный элемент списка
Пример:
1max([1, 2, 3])
Результат:
3
s.index(x)
Описание
Возвращает индекс первого найденного элемента x. Вызывается исключение ValueError, если элемент не найден
Пример:
1[1, 2, 3, 2, 1].index(2)
Результат:
1
s.count(x)
Описание
Возвращает количество элементов x
Пример:
1[1, 1, 1, 2, 3, 1].count(1)
Результат:
4
s.append(x)
Описание
Добавляет элемент x в конец списка
Пример:
1s = [1, 2]
2s.append(3)
3print(s)
Результат:
[1, 2, 3]
s.clear()
Описание
Удаляет все элементы списка
Пример:
1s = [1, 2, 3]
2s.clear()
3print(s)
Результат:
[]
s.copy()
Описание
Возвращает копию списка
Пример:
1[1, 2, 3].copy()
Результат:
[1, 2, 3]
s.extend(t) или s += t
Описание
Расширяет список s элементами списка t
Пример:
1s = [1, 2, 3]
2s.extend([4, 5])
3print(s)
Результат:
[1, 2, 3, 4, 5]
s.insert(i, x)
Описание
Вставляет элемент x в список по индексу i
Пример:
1s = [1, 3, 4]
2s.insert(1, 2)
3print(s)
Результат:
[1, 2, 3, 4]
s.pop(i)
Описание
Возвращает и удаляет элемент с индексом i. Если i не указан, то возвращается и удаляется последний элемент
Пример:
1s = [1, 2, 3]
2x = s.pop()
3print(x)
4print(s)
Результат:
3 [1, 2]
s.remove(x)
Описание
Удаляет первый элемент со значением x
Пример:
1s = [1, 2, 3, 2, 1]
2s.remove(2)
3print(s)
Результат:
[1, 3, 2, 1]
s.reverse()
Описание
Меняет порядок элементов списка на противоположный (переворачивает список)
Пример:
1s = [1, 2, 3]
2s.reverse()
3print(s)
Результат:
[3, 2, 1]
s.sort()
Описание
Сортирует список по возрастанию, меняя исходный список. Для сортировки по убыванию используется дополнительный аргумент reverse=True
Пример:
1s = [2, 3, 1]
2s.sort()
3print(s)
Результат:
[1, 2, 3]
sorted(s)
Описание
Возвращает отсортированный по возрастанию список, не меняя исходный. Для сортировки по убыванию используется дополнительный аргумент reverse=True
Пример:
1s = [2, 3, 1]
2new_s = sorted(s, reverse=True)
3print(new_s)
Результат:
[3, 2, 1]
Кортежи: неизменяемые списки
Мы уже познакомились со строками и списками — коллекциями, в которых можно хранить и обрабатывать набор значений. Строки нельзя изменять, а списки — можно. Теперь рассмотрим ещё один тип коллекции — кортеж.
Он похож на список, но остаётся неизменным после создания. Это удобно, когда нужно зафиксировать данные и быть уверенным, что они не изменятся случайно.
Основные свойства
Кортеж (tuple
) — это упорядоченная коллекция, как и список, но неизменяемая. После создания в кортеже нельзя изменить, удалить или добавить элементы. Это делает его удобным, когда нужно защитить данные от случайных изменений.
Примеры создания:
1numbers = (1, 2, 3, 4, 5)
Если нужно создать кортеж из одного элемента, то запись будет такой:
1one_number = (1, )
Обратите внимание: при создании кортежа из одного элемента необходима запятая. Без неё Python воспримет запись как обычное выражение в скобках, а не как коллекцию.
Для кортежей доступны только те операции и методы, которые не изменяют коллекцию: доступ по индексу, срезы, проверка вхождения, функции len()
, count()
, index()
.
Примеры использования
Кортежи удобно использовать, когда нужно временно объединить значения. Например, для обмена значениями двух переменных:
1a = 1
2b = 2
3(a, b) = (b, a)
4# можно опустить круглые скобки и записать так a, b = b, a
5print(f"a = {a}, b = {b}")
Вывод программы:
a = 2, b = 1
Преобразование между коллекциями
Иногда нужно представить одну коллекцию в виде другой — например, превратить строку в список символов или в кортеж. В Python это можно сделать с помощью встроенных функций list()
, tuple()
и str()
.
Примеры преобразования
В этом примере мы преобразуем строку в список и кортеж. Каждый символ строки становится отдельным элементом новой коллекции:
1text = "Привет, мир!"
2list_symbols = list(text)
3tuple_symbols = tuple(text)
4text_from_list = str(list_symbols)
5print(list_symbols)
6print(tuple_symbols)
7print(text_from_list)
Вывод программы:
['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!'] ('П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!') ['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!']
Обратите внимание: преобразование списка или кортежа в строку с помощью
str()
не объединяет элементы в одну строку, а возвращает строковое представление коллекции. Если вы хотите собрать строку обратно из символов, используйте метод'.join(...)'
.
✅ У вас получилось разобраться с коллекциями?
Оцените, насколько этот параграф был понятным — ваша обратная связь помогает нам делать хендбук лучше.
Что дальше
Теперь, когда вы научились работать со строками, списками и кортежами, пора познакомиться с другими важными типами коллекций — множествами и словарями.
В следующем параграфе вы узнаете:
- что такое множества и как они устроены;
- как использовать операции над множествами: объединение, пересечение, разность;
- в чём особенности словаря и чем он отличается от списка;
- как обращаться к значениям по ключу, добавлять и удалять элементы;
- как использовать словари для хранения и анализа структурированных данных.
После этого вы сможете создавать программы, которые быстро ищут, группируют и обрабатывают данные — без лишнего кода и проверок.
А пока вы не ушли дальше — закрепите материал на практике:
- Отметьте, что урок прочитан при помощи кнопки ниже.
- Пройдите мини-квиз, чтобы проверить, насколько хорошо вы усвоили тему.
- Перейдите к задачам этого параграфа и потренируйтесь.
- Перед этим — загляните в короткий гайд о том, как работает система проверки.
Хотите обсудить, задать вопрос или не понимаете, почему код не работает? Мы всё предусмотрели — вступайте в сообщество Хендбука! Там студенты помогают друг другу разобраться..
Ключевые выводы параграфа
- Строки, списки и кортежи — это упорядоченные коллекции, к элементам которых можно обращаться по индексу.
- Строки и кортежи неизменяемы, списки — изменяемые.
- Все три типа поддерживают срезы и перебор в цикле.
- У строк и списков есть полезные методы, которые не изменяют исходную коллекцию, а возвращают новое значение.
- Коллекции можно преобразовывать друг в друга с помощью функций
list()
,tuple()
иstr()
.