Списки та кортежі: типи list, tuple

Списки в Python представлені типами list та tuple і використовуються для збереження впорядкованих колекцій обʼєктів. Списки та кортежі можуть містити будь-яку кількість елементів — чисел, рядків, інших списків, об’єктів тощо. Відмінність списка від кортежа у тому, що список можна змінити після його створення, а кортеж — ні.

У цьому розділі:

Коли використовувати list?

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

• керування чергою завдань,
• збирання результатів обчислень у циклі,
• зберігання введених користувачем значень,
• створення матриць,
• побудова структури дерева тощо.

Якщо вам потрібна лише перевірка наявності елемента без дотримання порядку, краще скористатися множиною (set). Якщо ж послідовність не має змінюватися — варто використовувати кортеж (tuple). Уявіть список як коробку з пронумерованими комірками, до кожної з яких можна дістатися, щось покласти або вийняти — саме ця гнучкість робить list одним із найуживаніших типів у Python.

Створення списку та кортежу

Список задається за допомогою квадратних дужок [...], а елементи розділяються комами:

numbers = [1, 2, 3, 4, 5]           # Список чисел
words = ["один", "два", "три"]      # Список рядків
mixed = [1, "два", 3.0, True]       # Список змішаних типів
print(numbers, words, mixed)

Кортеж створюється таким самим чином, але використовуються круглі дужки (...):

numbers = (1, 2, 3, 4, 5)           # Кортеж чисел
words = ("один", "два", "три")      # Кортеж рядків
mixed = (1, "два", 3.0, True)       # Кортеж змішаних типів
print(numbers, words, mixed)

Можна створити порожній список:

empty = []
print(empty)  # []

Щоб створити порожній кортеж, достатньо вказати відкриваючу і закриваючу дужки без жодного елемента всередині:

empty = ()
print(type(empty))  # <class 'tuple'>

Такий кортеж містить нуль елементів і є незмінною порожньою послідовністю. Це може бути корисно, коли ви хочете оголосити змінну для зберігання значень у майбутньому, але при цьому гарантувати, що вона залишатиметься незмінною. У випадку, якщо вам потрібно змінювати вміст — слід використовувати порожній список [].

Щоб створити кортеж з одного елемента, потрібно додати кому після цього елемента. Просто взяти значення в дужки недостатньо — Python розпізнає це як звичайну операцію в дужках, а не як кортеж. Наприклад:

t1 = (42)      # це не кортеж, а просто число
t2 = (42,)     # це кортеж з одним елементом
t3 = 42,       # це теж кортеж з одним елементом
print(type(t1), type(t2), type(t3))

У t1 тип буде int, а у t2 та t3 — tuple. Причина в тому, що синтаксис кортежу в Python базується не лише на дужках, а насамперед на наявності ком. Дужки використовуються для зручності, але саме кома вказує, що ви створюєте кортеж.

Тепер ви розумієте, чому запис pi = 3,14 створить кортеж (3, 14), а не дійсне число 3.14. 😁

Списки та кортежі підтримують вкладені структури — можна мати список у списку:

matrix = [[1, 2], [3, 4]]
print(matrix[0])      # [1, 2]
print(matrix[0][1])   # 2

Ось той самий приклад, але з форматуванням, щоб було краще видно організацію вкладеності:

matrix = [
             [1, 2], 
             [3, 4]
         ]
print(matrix[0])      # [1, 2]
print(matrix[0][1])   # 2

Доступ до елементів списку та кортежу

Списки та кортежі є впорядкованими, тому можна звертатися до елементів за індексом:

colors = ["червоний", "зелений", "синій"]
print(colors[0])  # 'червоний'
print(colors[2])  # 'синій'

Індексація починається з нуля, як у рядках. Також доступна відʼємна індексація:

colors = ("червоний", "зелений", "синій")
print(colors[-1])  # 'синій'
print(colors[-2])  # 'зелений'

0           1          2
"червоний", "зелений", "синій"
-3          -2         -1 

Як і з рядками, при зверненні до неіснуючого індексу виникне помилка IndexError, та виконання програми буде зупинено.

Зрізи (slicing)

Списки та кортежі підтримують зрізи — можна отримати підсписок або підкортеж за допомогою індексів:

numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])   # [1, 2, 3]
print(numbers[:3])    # [0, 1, 2]
print(numbers[3:])    # [3, 4, 5]
print(numbers[::-1])  # [5, 4, 3, 2, 1, 0] — зворотній список

Це працює так само, як з рядками — Python розглядає список як лінійку з елементами.

Основні операції

Списки та кортежі підтримують такі основні операції:

print((1, 2) + (3, 4))    # (1, 2, 3, 4)
print(("a",) * 4)          # ('a', 'a', 'a', 'a')
print(len(["x", "y"]))    # 2
print("y" in ["x", "y"])  # True

У перших двох прикладах здається, що кортеж змінюється, але це не так. Операції + та * у результаті створюють новий список або кортеж.

Методи списку

Тип list має багато корисних методів:

Важливо: кортеж tuple не має цих методів, тому що кортеж змінити неможливо.

fruits = ["яблуко", "банан", "вишня"]
fruits.sort()
print(fruits)  # ['банан', 'вишня', 'яблуко']

fruits.reverse()
print(fruits)  # ['яблуко', 'вишня', 'банан']

Зміна елементів

Списки — змінюваний тип (mutable). Це означає, що ми можемо змінювати елементи списку після його створення:

nums = [10, 20, 30]
nums[1] = 99
print(nums)  # [10, 99, 30]

Також можна додавати та видаляти елементи:

lst = [1, 2, 3]
lst.append(4)        # додає 4 в кінець: [1, 2, 3, 4]
lst.insert(1, 100)   # вставляє 100 на позицію з індексом 1: [1, 100, 2, 3, 4]
lst.remove(2)        # видаляє перше входження 2: [1, 100, 3, 4]
print(lst)           # [1, 100, 3, 4]

Увага! На відміну від списків, кортежі (tuple) — незмінні (immutable). Це означає, що після створення кортежу ви не можете змінити жоден його елемент, додати новий чи видалити старий. Якщо ви спробуєте змінити значення за індексом, Python видасть помилку TypeError. Наприклад:

t = (1, 2, 3)
t[0] = 100  # TypeError: 'tuple' object does not support item assignment

Це схоже на бетонну плиту: її структура закріплена, і жоден елемент не можна пересунути. Кортежі використовуються тоді, коли ви хочете гарантувати, що дані залишаться незмінними протягом виконання програми — наприклад, координати точки, значення RGB або інші постійні налаштування. Якщо вам потрібна гнучкість — використовуйте list, якщо стабільність — обирайте tuple.

Конвертація між list і tuple

Python дозволяє легко перетворювати список (list) у кортеж (tuple) і навпаки за допомогою однойменних функцій list() та tuple(). Це зручно, коли вам потрібно тимчасово змінити тип послідовності залежно від ситуації: наприклад, зробити незмінною копію списку або, навпаки, редагувати дані, що раніше були кортежем.

tpl = (1, 2, 3)     # Створили кортеж
lst = list(tpl)     # На його основі створили список [1, 2, 3]
lst.append(4)       # Додали до списку 4: [1, 2, 3, 4]
tpl = tuple(lst)    # Створили кортеж на основі списку: (1, 2, 3, 4)
print(tpl)          # (1, 2, 3, 4)

Таке перетворення створює новий обʼєкт у памʼяті. Тобто list() не змінює сам кортеж, а створює новий список з такими ж елементами, і навпаки. Уявіть, що це як зробити копію документа у новому форматі: вміст той самий, але спосіб взаємодії змінюється.

Насправді list() та tuple() — це виклик конструкторів відповідних класів list та tuple, але тут для спрощення ми називаємо це викликом функцій.