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

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

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, если все буквы в строке — строчные. Таких методов у строк много — и они не изменяют исходную строку, а возвращают новую. Если нужно сохранить результат, его следует присвоить переменной.

Ниже — подборка часто используемых методов строк с описаниями и примерами. Эти методы позволяют выполнять самые разные операции: изменять регистр, искать подстроки, форматировать текст и многое другое.

Обратите внимание: методы не изменяют исходную строку, а возвращают новую. Если результат нужно использовать, его стоит сохранить в переменной.

1 s = "hello, World!"
2 s.capitalize()

Hello, world!

1s = "Hello, world!"
2s.count("l")

3

1s = "Hello, world!"
2s.endswith("world!")

True

1s = "Hello, world!"
2s.index("o")

4

1 s = "Hello, world!"
2 s.index("o")

4

1s = "abc123"
2s.isalnum()

True

1s = "Letters"
2s.isalpha()

True

1s = "123"
2s.isdigit()

True

1s = "word123"
2s.islower()

True

1s = "WORD123"
2s.isupper()

True

1a = ["1", "2", "3"]
2"; ".join(a)

"1; 2; 3"

1s = "text"
2s.ljust(10, "=")

"text======"

1s = "Hello, World!"
2s.lower()

"hello, world!"

1s = "BCCAstring"
2s.lstrip("ABC")

"string"

1s = "stringBCCA"
2s.rstrip("ABC")

"string"

1s = "one, two, three"
2s.split(", ")

["one", "two", "three"]

1s = "Hello, world!"
2s.startswith("Hello")

True

1s = "abc Hello, world! cba"
2s.strip(" abc")

"Hello, world!"

1s = "hello, world!"
2s.title()

"Hello, World!"

1s = "Hello, world!"
2s.upper()

"HELLO, WORLD!"

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]

Методы и операции со списками

Списки поддерживают множество встроенных методов и операций. С их помощью можно:

• проверить наличие элемента,
• объединить или дублировать списки,
• добавить или удалить элемент,
• отсортировать или развернуть список.

Некоторые методы изменяют список напрямую, другие возвращают новый результат. Это особенно важно при работе с копиями и при сортировке.

В таблице ниже приведены наиболее часто используемые методы и операции со списками — с примерами и результатами выполнения.

11 in [1, 2, 3]

True

14 not in [1, 2, 3]

True

1[1, 2] + [3, 4, 5]

[1, 2, 3, 4, 5]

1[1, 2, 3] * 3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

1len([1, 2, 3])

3

1min([1, 2, 3])

1

1max([1, 2, 3])

3

1[1, 2, 3, 2, 1].index(2)

1

1[1, 1, 1, 2, 3, 1].count(1)

4

1s = [1, 2]
2s.append(3)
3print(s)

[1, 2, 3]

1s = [1, 2, 3]
2s.clear()
3print(s)

[]

1[1, 2, 3].copy()

[1, 2, 3]

1s = [1, 2, 3]
2s.extend([4, 5])
3print(s)

[1, 2, 3, 4, 5]

1s = [1, 3, 4]
2s.insert(1, 2)
3print(s)

[1, 2, 3, 4]

1s = [1, 2, 3]
2x = s.pop()
3print(x)
4print(s)

3
[1, 2]

1s = [1, 2, 3, 2, 1]
2s.remove(2)
3print(s)

[1, 3, 2, 1]

1s = [1, 2, 3]
2s.reverse()
3print(s)

[3, 2, 1]

1s = [2, 3, 1]
2s.sort()
3print(s)

[1, 2, 3]

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().