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

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

Ключевые вопросы статьи

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

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

Начнём с уже знакомой строки (str) и посмотрим на неё как на коллекцию — последовательность символов, к которой можно обращаться по индексам. А затем перейдём к другим упорядоченным структурам: спискам и кортежам. Они позволяют хранить сразу несколько значений — и во многом похожи на строки, но с важными отличиями.

Что такое коллекции и индексацияЧто такое коллекции и индексация

Если рассмотреть строку детальнее, то она состоит из символов, каждый из которых стоит на своём месте. Другими словами, строка — это упорядоченная последовательность (коллекция) символов.

Слово «коллекция» в Python используется для обозначения типов данных, которые могут хранить сразу несколько значений. Строка — лишь один из таких типов. Помимо неё, к упорядоченным коллекциям относятся списки (list) и кортежи (tuple).

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

В Python индексация начинается с нуля. Это значит, что:

• первый элемент имеет индекс 0,
• второй — индекс 1,
• и так далее.

В строке по индексу можно получить любой символ, включая пробелы, запятые, управляющие символы вроде \n, \t и другие.

Обращение к элементам по индексуОбращение к элементам по индексу

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

text = input()
print(text[0])

Если пользователь введёт, например, Привет, программа выведет П — первый символ строки.

Но если строка окажется пустой, то возникнет ошибка:

IndexError: string index out of range

Это значит, что мы обратились к символу, которого не существует. Чтобы избежать этой ошибки, стоит заранее проверить, входит ли индекс в допустимые границы — например, с помощью функции len():

text = input("Введите строку: ")
i = int(input("Введите индекс символа: "))
if 0 <= i < len(text):
    print(text[i])
else:
    print("Индекс выходит за пределы строки")

Отрицательная индексацияОтрицательная индексация

Допустим, мы хотим получить последний символ строки. Один из способов — использовать len():

text = input()
print(text[len(text) - 1])

Однако в Python есть более удобный способ: отрицательная индексация. Последний элемент строки имеет индекс -1, предпоследний — -2, и так далее:

text = input()
print(text[-1])

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

Проход по коллекциямПроход по коллекциям

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

В этом разделе мы рассмотрим три способа прохода по элементам коллекции:

• по индексам,
• по значениям,
• по индексам и значениям одновременно (с помощью функции enumerate()).

Цикл по индексамЦикл по индексам

Если нам важно знать индекс каждого элемента, можно пройти по коллекции с помощью цикла for и функции range(). Например, выведем по символу строки на каждой строке:

text = input()
for i in range(len(text)):
    print(text[i])

Такой способ полезен, когда нужно не только получить значение, но и использовать индекс — например, при обращении к другим коллекциям по тому же индексу или при вычислениях.

Цикл по значениямЦикл по значениям

Если индекс не нужен, а важно просто пройти по элементам один за другим, запись становится короче и понятнее:

text = input()
for letter in text:
    print(letter)

Здесь переменная letter на каждой итерации принимает значение следующего символа строки. Такой цикл читается проще и используется чаще всего, если нам не нужен номер элемента.

Цикл с enumerateЦикл с enumerate

Если нужно и значение, и его индекс — поможет функция enumerate(). Она возвращает пары: индекс и элемент. Это особенно удобно, когда мы работаем с элементами, но ещё и хотим показать номер строки, порядковый номер слова и т.д.:

text = input()
for i, letter in enumerate(text):
    print(f"{i}. {letter}")

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

СрезыСрезы

Работая с коллекциями, особенно со строками и списками, часто нужно взять только часть элементов — например, первые 5 символов строки или каждое второе число из списка. Для этого в Python существует мощный инструмент — срезы (англ. slice).

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

Синтаксис срезовСинтаксис срезов

Срез записывается с помощью двойного двоеточия внутри квадратных скобок:

коллекция[начало:конец:шаг]

• начало — индекс, с которого начать (включительно);
• конец — индекс, до которого взять (не включается!);
• шаг — через сколько элементов двигаться (по умолчанию 1).

Любой из параметров можно опустить. Например:

• text[:5] — первые 5 символов;
• text[::2] — каждый второй символ;
• text[::-1] — строка в обратном порядке.

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

Примеры срезовПримеры срезов

Рассмотрим разные варианты срезов:

text = "Привет, мир!"
print(text[8:11])
print(text[:6])
print(text[8:])
print(text[:])
print(text[::2])

Результат:

мир
Привет
мир!
Привет, мир!
Пие,мр

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

Работа со строками и спискамиРабота со строками и списками

Строки — удобный и часто используемый тип данных в Python. Мы можем обращаться к отдельным символам, перебирать их в цикле, делать срезы. Но есть важная особенность: строка — это неизменяемая коллекция. Это значит, что изменить один из символов уже созданной строки нельзя: попытка сделать это приведёт к ошибке.

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

Неизменяемость строкНеизменяемость строк

Попробуем изменить первый символ строки:

word = "мир"
word[0] = "п"

Результат:

TypeError: 'str' object does not support item assignment

Ошибка возникает потому, что строки нельзя менять «на месте». Если нужно изменить строку, необходимо создать новую — например, с помощью срезов, операций или методов.

Методы строкМетоды строк

Ранее мы использовали встроенные функции. Методы — это похожий инструмент, но они «принадлежат» конкретному типу данных. У строк есть собственный набор методов, которые вызываются через точку после переменной:

print("а".islower()) #True
print("A".islower()) #False

Метод islower() возвращает True, если все буквы в строке — строчные. Таких методов у строк много — и они не изменяют исходную строку, а возвращают новую. Если нужно сохранить результат, его следует присвоить переменной.

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

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

Hello, world!

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

3

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

True

s = "Hello, world!"
s.find("o")

4

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

4

s = "abc123"
s.isalnum()

True

s = "Letters"
s.isalpha()

True

s = "123"
s.isdigit()

True

s = "word123"
s.islower()

True

s = "WORD123"
s.isupper()

True

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

"1; 2; 3"

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

"text======"

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

"hello, world!"

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

"string"

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

"string"

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

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

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

True

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

"Hello, world!"

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

"Hello, World!"

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

"HELLO, WORLD!"

s = "123"
s.zfill(5)

"00123"

Списки: изменяемые коллекцииСписки: изменяемые коллекции

Список (list) — ещё один важный тип коллекции в Python. В отличие от строки, он изменяемый, и может содержать элементы любого типа данных: числа, строки, даже другие списки.

Создание и доступ к элементамСоздание и доступ к элементам

Список (list) — это упорядоченная коллекция, в которой можно хранить значения любых типов: числа, строки, логические значения и даже другие списки.

Один из самых простых способов создать список — перечислить его элементы в квадратных скобках:

numbers = [10, 20, 30]

Списки могут содержать элементы разных типов:

mixed_list = [10, 20.55, "text"]

Индексация в списках работает так же, как в строках:

• первый элемент имеет индекс 0,
• можно использовать отрицательные индексы,
• поддерживаются срезы.

Примеры:

numbers = [10, 20, 30, 40, 50]
print(numbers[0])
print(numbers[-1])
print(numbers[1:3])
print(numbers[::-1])

Изменение и удаление элементовИзменение и удаление элементов

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

Чтобы изменить элемент, достаточно указать его индекс:

numbers = [10, 20, 50]
numbers[2] = 30
print(numbers)

Вывод программы:

[10, 20, 30]

Чтобы добавить элемент в конец списка, используется метод append(). Например, так можно собрать список из 10 чисел, введённых пользователем:

numbers = []
for i in range(10):
    numbers.append(int(input()))
print(numbers)

Вывод программы:

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Удалять элементы можно с помощью оператора del:

numbers = [10, 20, 50]
del numbers[-1]
print(numbers)

Вывод программы:

[10, 20]

Также del поддерживает удаление по срезу:

numbers = [1, 2, 3, 4, 5]
del numbers[::2]
print(numbers)

Вывод программы:

[2, 4]

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

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

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

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

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

1 in [1, 2, 3]

True

4 not in [1, 2, 3]

True

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

[1, 2, 3, 4, 5]

[1, 2, 3] * 3

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

len([1, 2, 3])

3

min([1, 2, 3])

1

max([1, 2, 3])

3

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

1

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

4

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

[1, 2, 3]

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

[]

[1, 2, 3].copy()

[1, 2, 3]

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

[1, 2, 3, 4, 5]

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

[1, 2, 3, 4]

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

3
[1, 2]

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

[1, 3, 2, 1]

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

[3, 2, 1]

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

[1, 2, 3]

s = [2, 3, 1]
new_s = sorted(s, reverse=True)
print(new_s)

[3, 2, 1]

Кортежи: неизменяемые спискиКортежи: неизменяемые списки

Мы уже познакомились со строками и списками — коллекциями, в которых можно хранить и обрабатывать набор значений. Строки нельзя изменять, а списки — можно. Теперь рассмотрим ещё один тип коллекции — кортеж.

Он похож на список, но остаётся неизменным после создания. Это удобно, когда нужно зафиксировать данные и быть уверенным, что они не изменятся случайно.

Основные свойстваОсновные свойства

Кортеж (tuple) — это упорядоченная коллекция, как и список, но неизменяемая. После создания в кортеже нельзя изменить, удалить или добавить элементы. Это делает его удобным, когда нужно защитить данные от случайных изменений.

Примеры создания:

numbers = (1, 2, 3, 4, 5)

Если нужно создать кортеж из одного элемента, то запись будет такой:

one_number = (1, )

Для кортежей доступны только те операции и методы, которые не изменяют коллекцию: доступ по индексу, срезы, проверка вхождения, функции len(), count(), index().

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

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

a = 1
b = 2
(a, b) = (b, a)
# можно опустить круглые скобки и записать так a, b = b, a
print(f"a = {a}, b = {b}")

Вывод программы:

a = 2, b = 1

Преобразование между коллекциямиПреобразование между коллекциями

Иногда нужно представить одну коллекцию в виде другой — например, превратить строку в список символов или в кортеж. В Python это можно сделать с помощью встроенных функций list(), tuple() и str().

Примеры преобразованияПримеры преобразования

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

text = "Привет, мир!"
list_symbols = list(text)
tuple_symbols = tuple(text)
text_from_list = str(list_symbols)
print(list_symbols)
print(tuple_symbols)
print(text_from_list)

Вывод программы:

['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!']
('П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!')
['П', 'р', 'и', 'в', 'е', 'т', ',', ' ', 'м', 'и', 'р', '!']

Что дальшеЧто дальше

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

В следующей статье вы узнаете:

• что такое множества и как они устроены;
• как использовать операции над множествами: объединение, пересечение, разность;
• в чём особенности словаря и чем он отличается от списка;
• как обращаться к значениям по ключу, добавлять и удалять элементы;
• как использовать словари для хранения и анализа структурированных данных.

После этого вы сможете создавать программы, которые быстро ищут, группируют и обрабатывают данные — без лишнего кода и проверок.

Ключевые выводы статьи

• Строки, списки и кортежи — это упорядоченные коллекции, к элементам которых можно обращаться по индексу.
• Строки и кортежи неизменяемы, списки — изменяемые.
• Все три типа поддерживают срезы и перебор в цикле.
• У строк и списков есть полезные методы, которые не изменяют исходную коллекцию, а возвращают новое значение.
• Коллекции можно преобразовывать друг в друга с помощью функций list(), tuple() и str().