3.1. Строки, кортежи, списки

В этом параграфе мы начнём знакомство с коллекциями — специальными типами данных, которые позволяют хранить и обрабатывать несколько значений одновременно. Мы разберёмся, как обращаться к элементам коллекций, как проходить по ним в цикле, использовать срезы и встроенные методы. А ещё научимся отличать изменяемые коллекции от неизменяемых — это важно для понимания, как работает память в Python.Рассмотрим упорядоченные коллекции, индексацию, методы и функции для их обработки.

Ключевые вопросы параграфа

  1. Что такое коллекции в Python и какие из них — упорядоченными?
  2. Как обращаться к элементам строки, списка и кортежа по индексу?
  3. Чем отличаются строки, списки и кортежи между собой?
  4. Какие методы существуют для работы со строками и списками?
  5. Как создавать срезы и преобразовывать одни коллекции в другие?

Упорядоченные коллекции: строки, списки и кортежи

Начнём с уже знакомой строки (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().

Отмечайте параграфы как прочитанные, чтобы видеть свой прогресс обучения

Вступайте в сообщество хендбука

Здесь можно найти единомышленников, экспертов и просто интересных собеседников. А ещё — получить помощь или поделиться знаниями.
Вступить
Сообщить об ошибке
Предыдущий параграф2.5. Чему вы научились

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

Следующий параграф3.2. Множества, словари

В этом параграфе мы продолжим изучать коллекции — но теперь познакомимся с неупорядоченными типами данных. Вы узнаете, как работают множества (set) и словари (dict), чем они отличаются от списков и в каких задачах используются. Научитесь проверять, содержится ли элемент в множестве, находить пересечения и разности, а также хранить и быстро получать значения по ключам. Мы разберёмся, как создавать множества и словари, выполнять над ними операции, использовать их методы и применять в реальных примера.