Python · Синтаксис · Початковий рівень

Методи списків та кортежів

10 завдань

Освойте всі методи списків і зрозумійте ключові відмінності між списками і кортежами.

Короткий вступ до теми та пояснення перед вправами (вправи нижче):

Методи списків

#
Список — це впорядкована **мутабельна** послідовність: ви можете змінювати її після створення. Python надає набір методів, які модифікують список безпосередньо (in-place). ## Додавання елементів ```python fruits = ["apple", "banana"] fruits.append("cherry") # додати один елемент у кінець print(fruits) # ["apple", "banana", "cherry"] fruits.extend(["date", "elderberry"]) # додати всі елементи з ітерабельного print(fruits) # ["apple", "banana", "cherry", "date", "elderberry"] fruits.insert(1, "avocado") # вставити на індекс 1 print(fruits) # ["apple", "avocado", "banana", "cherry", "date", "elderberry"] ``` **Ключова різниця**: `append(x)` додає `x` як один елемент; `extend(iterable)` розпаковує і додає кожен елемент окремо. `list.append([1,2])` дасть `[..., [1,2]]`, а `list.extend([1,2])` — `[..., 1, 2]`. ## Видалення елементів ```python nums = [1, 2, 3, 2, 4] nums.remove(2) # видаляє ПЕРШЕ входження значення 2 print(nums) # [1, 3, 2, 4] popped = nums.pop() # видаляє і повертає ОСТАННІЙ елемент print(popped) # 4 print(nums) # [1, 3, 2] popped = nums.pop(0) # видаляє і повертає елемент за індексом 0 print(popped) # 1 print(nums) # [3, 2] nums.clear() # видаляє всі елементи print(nums) # [] ``` ## Пошук ```python items = ["a", "b", "c", "b"] print(items.index("b")) # 1 — індекс ПЕРШОГО збігу (кидає ValueError якщо немає) print(items.count("b")) # 2 — кількість усіх збігів print("c" in items) # True — `in` для перевірки наявності ``` ## Сортування та розворот ```python nums = [3, 1, 4, 1, 5, 9, 2, 6] nums.sort() # сортує на місці, зростання print(nums) # [1, 1, 2, 3, 4, 5, 6, 9] nums.sort(reverse=True) # сортує на місці, спадання print(nums) # [9, 6, 5, 4, 3, 2, 1, 1] words = ["banana", "apple", "cherry"] words.sort(key=len) # сортувати за довжиною рядка print(words) # ["apple", "banana", "cherry"] nums.reverse() # розвертає на місці (не сортує) ``` `sort()` модифікує список і повертає `None`. Використовуйте `sorted(lst)`, якщо потрібен новий відсортований список без зміни оригіналу. ## Копіювання ```python original = [1, 2, 3] copy1 = original.copy() # поверхнева копія copy2 = original[:] # теж поверхнева копія copy1.append(99) print(original) # [1, 2, 3] — не змінився print(copy1) # [1, 2, 3, 99] ``` Ніколи не робіть `copy = original` — це створює **псевдонім**, а не копію.

Кортежі та розпакування

#
Кортеж — це впорядкована **незмінна** послідовність. Після створення вміст змінити не можна. Використовуйте кортежі для даних, які не повинні змінюватись. ## Основи кортежів ```python point = (3, 7) rgb = (255, 128, 0) single = (42,) # кортеж з одного елемента — зверніть увагу на кому! empty = () print(type(point)) # <class 'tuple'> print(point[0]) # 3 print(len(rgb)) # 3 ``` Кортеж без дужок теж працює: ```python coords = 10, 20 # те саме, що (10, 20) ``` ## List vs Tuple: коли що використовувати | Список `[]` | Кортеж `()` | |---|---| | Мутабельний — можна додавати/видаляти/змінювати | Незмінний — фіксований після створення | | Для колекцій, що зростають/зменшуються | Для фіксованих записів (координати, RGB, рядки БД) | | Трохи більше пам'яті | Трохи швидший доступ, менше пам'яті | | Не можна використовувати як ключ словника | Можна використовувати як ключ словника | ```python # Список: зростаюча колекція shopping = [] shopping.append("milk") shopping.append("eggs") # Кортеж: фіксований запис person = ("Alice", 30, "engineer") name, age, role = person # розпакування ``` ## Розпакування кортежів ```python x, y = (10, 20) print(x) # 10 print(y) # 20 # Обмін змінних без тимчасової змінної a, b = 1, 2 a, b = b, a print(a, b) # 2 1 # Розширене розпакування first, *rest = [1, 2, 3, 4, 5] print(first) # 1 print(rest) # [2, 3, 4, 5] *start, last = [1, 2, 3, 4, 5] print(start) # [1, 2, 3, 4] print(last) # 5 ``` ## Кортежі у циклах ```python pairs = [(1, "one"), (2, "two"), (3, "three")] for number, word in pairs: print(f"{number} = {word}") # 1 = one # 2 = two # 3 = three ``` Саме так працюють `enumerate()` та `dict.items()` — вони повертають кортежі. ## Повернення кількох значень з функції ```python def min_max(numbers): return min(numbers), max(numbers) # повертає кортеж lo, hi = min_max([3, 1, 4, 1, 5, 9]) print(lo, hi) # 1 9 ``` Функції, що повертають кілька значень, завжди повертають кортеж. Розпакування — ідіоматичний спосіб їх отримати.

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

#
## Методи списків | Метод | Що робить | Повертає | |---|---|---| | `lst.append(x)` | Додати `x` у кінець | `None` | | `lst.extend(iterable)` | Додати всі елементи з iterable | `None` | | `lst.insert(i, x)` | Вставити `x` на індекс `i` | `None` | | `lst.pop()` | Видалити і повернути останній елемент | елемент | | `lst.pop(i)` | Видалити і повернути елемент за індексом `i` | елемент | | `lst.remove(x)` | Видалити перше входження `x` | `None` | | `lst.clear()` | Видалити всі елементи | `None` | | `lst.index(x)` | Індекс першого `x` (кидає ValueError) | int | | `lst.count(x)` | Кількість входжень `x` | int | | `lst.sort(key=None, reverse=False)` | Сортувати на місці | `None` | | `lst.reverse()` | Розвернути на місці | `None` | | `lst.copy()` | Поверхнева копія | новий список | ## Вбудовані функції для списків | Функція | Що робить | |---|---| | `sorted(lst, key=None, reverse=False)` | Повертає новий відсортований список | | `reversed(lst)` | Повертає зворотний ітератор | | `len(lst)` | Кількість елементів | | `min(lst)` / `max(lst)` | Мінімум / максимум | | `sum(lst)` | Сума числових елементів | | `list(iterable)` | Конвертувати у список | ## Операції з кортежами | Операція | Приклад | Результат | |---|---|---| | Створити | `t = (1, 2, 3)` | — | | Доступ | `t[0]` | `1` | | Зріз | `t[1:]` | `(2, 3)` | | Розпакування | `a, b, c = t` | a=1, b=2, c=3 | | Зірочкове розпакування | `first, *rest = t` | first=1, rest=[2,3] | | Конкатенація | `(1, 2) + (3, 4)` | `(1, 2, 3, 4)` | | Повторення | `(0,) * 3` | `(0, 0, 0)` | | `len(t)` | `len((1, 2, 3))` | `3` | | `x in t` | `2 in (1, 2, 3)` | `True` | | Конвертація | `list(t)` / `tuple(lst)` | — | ## append vs extend ```python lst = [1, 2] lst.append([3, 4]) # → [1, 2, [3, 4]] ← список як один елемент lst = [1, 2] lst.extend([3, 4]) # → [1, 2, 3, 4] ← елементи додаються окремо ``` ## sort vs sorted ```python nums = [3, 1, 2] nums.sort() # модифікує nums на місці, повертає None print(nums) # [1, 2, 3] nums = [3, 1, 2] new = sorted(nums) # повертає новий список, nums не змінюється print(nums, new) # [3, 1, 2] [1, 2, 3] ```

Вправи:

01

append vs extend

#
У вас є список `result = [1, 2, 3]`. Напишіть два окремих вирази: 1. Використайте `append`, щоб додати список `[4, 5]` як один елемент. 2. Починаючи знову від `[1, 2, 3]`, використайте `extend`, щоб додати `[4, 5]` як окремі елементи. Виведіть обидва результати і поясніть різницю.
result = [1, 2, 3]

# 1. Використайте append, щоб додати [4, 5] як ОДИН елемент


# 2. Почніть знову і використайте extend, щоб додати [4, 5] як ОКРЕМІ елементи
result2 = [1, 2, 3]
Рішення 
result = [1, 2, 3]
result.append([4, 5])
print(result)   # [1, 2, 3, [4, 5]]  — вкладений список

result2 = [1, 2, 3]
result2.extend([4, 5])
print(result2)  # [1, 2, 3, 4, 5]   — окремі елементи
02

Вставка на позицію

#
Напишіть функцію `insert_after(lst, target, value)`, яка вставляє `value` одразу після першого входження `target` у `lst`. Якщо `target` не знайдено, додайте `value` у кінець. Приклад: `insert_after([1, 2, 4, 5], 2, 3)` → `[1, 2, 3, 4, 5]`.
def insert_after(lst, target, value):
    pass


print(insert_after([1, 2, 4, 5], 2, 3))    # [1, 2, 3, 4, 5]
print(insert_after([1, 2, 3], 99, 0))       # [1, 2, 3, 0]
Рішення 
def insert_after(lst, target, value):
    result = lst[:]
    if target in result:
        idx = result.index(target)
        result.insert(idx + 1, value)
    else:
        result.append(value)
    return result


print(insert_after([1, 2, 4, 5], 2, 3))    # [1, 2, 3, 4, 5]
print(insert_after([1, 2, 3], 99, 0))       # [1, 2, 3, 0]
03

Видалити дублікати (зі збереженням порядку)

#
Напишіть функцію `remove_dupes(lst)`, яка видаляє дублікати зі списку, зберігаючи порядок першої появи елементів. Приклад: `remove_dupes([3, 1, 2, 1, 3, 4])` → `[3, 1, 2, 4]`. Не використовуйте множини напряму (вони не зберігають порядок).
def remove_dupes(lst):
    pass


print(remove_dupes([3, 1, 2, 1, 3, 4]))     # [3, 1, 2, 4]
print(remove_dupes([1, 1, 1]))               # [1]
Рішення 
def remove_dupes(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result


print(remove_dupes([3, 1, 2, 1, 3, 4]))     # [3, 1, 2, 4]
print(remove_dupes([1, 1, 1]))               # [1]
04

Сортування за ключем

#
Напишіть функцію `sort_by_length(words)`, яка повертає новий список слів, відсортованих за довжиною (спочатку найкоротші). Слова однакової довжини мають зберігати відносний порядок. Приклад: `sort_by_length(["banana", "fig", "apple", "kiwi"])` → `["fig", "kiwi", "apple", "banana"]`.
def sort_by_length(words):
    pass


print(sort_by_length(["banana", "fig", "apple", "kiwi"]))
# ["fig", "kiwi", "apple", "banana"]
Рішення 
def sort_by_length(words):
    return sorted(words, key=len)


print(sort_by_length(["banana", "fig", "apple", "kiwi"]))
# ["fig", "kiwi", "apple", "banana"]
05

Стек на основі списку

#
Реалізуйте простий стек на основі списку. Напишіть клас `Stack` з методами: `push(item)`, `pop()` (повертає і видаляє верхній елемент), `peek()` (повертає верхній елемент без видалення), `is_empty()`, `size()`. Використовуйте тільки методи списку — імпорт не потрібен.
class Stack:
    def __init__(self):
        self._data = []

    def push(self, item):
        pass

    def pop(self):
        pass

    def peek(self):
        pass

    def is_empty(self):
        pass

    def size(self):
        pass


s = Stack()
s.push(1)
s.push(2)
s.push(3)
print(s.peek())     # 3
print(s.pop())      # 3
print(s.size())     # 2
print(s.is_empty()) # False
Рішення 
class Stack:
    def __init__(self):
        self._data = []

    def push(self, item):
        self._data.append(item)

    def pop(self):
        return self._data.pop()

    def peek(self):
        return self._data[-1]

    def is_empty(self):
        return len(self._data) == 0

    def size(self):
        return len(self._data)


s = Stack()
s.push(1)
s.push(2)
s.push(3)
print(s.peek())     # 3
print(s.pop())      # 3
print(s.size())     # 2
print(s.is_empty()) # False
06

Безпечна копія

#
Наступний код містить помилку. Виправте його так, щоб зміна `b` не впливала на `a`: ```python a = [1, 2, 3] b = a b.append(99) print(a) # має залишитись [1, 2, 3] ``` Поясніть у коментарі, чому оригінальний код не працює.
a = [1, 2, 3]
b = a          # ПОМИЛКА: обидва вказують на один список
b.append(99)
print(a)       # має бути [1, 2, 3], але виводить [1, 2, 3, 99]

# Виправте код вище щоб зміна b не впливала на a
Рішення 
a = [1, 2, 3]
b = a.copy()   # створює новий незалежний список
b.append(99)
print(a)   # [1, 2, 3]  — без змін
print(b)   # [1, 2, 3, 99]

# Альтернативи: b = a[:]  або  b = list(a)
07

Розпакування кортежів

#
Напишіть функцію `swap(a, b)`, яка повертає два значення у зворотному порядку, використовуючи розпакування кортежу в один рядок. Потім напишіть функцію `unpack_first_last(lst)`, яка повертає кортеж `(first, last)` за допомогою зіркового розпакування. Приклад: `unpack_first_last([10, 20, 30, 40])` → `(10, 40)`.
def swap(a, b):
    pass


def unpack_first_last(lst):
    pass


print(swap(1, 2))                    # (2, 1)
print(unpack_first_last([10, 20, 30, 40]))  # (10, 40)
Рішення 
def swap(a, b):
    return b, a


def unpack_first_last(lst):
    first, *_, last = lst
    return first, last


print(swap(1, 2))                          # (2, 1)
print(unpack_first_last([10, 20, 30, 40])) # (10, 40)
08

Пошук індексу без помилок

#
Напишіть функцію `find_index(lst, value)`, яка повертає індекс `value` у `lst`, або `-1` якщо не знайдено. НЕ використовуйте `.index()` напряму (він кидає ValueError). Приклад: `find_index([10, 20, 30], 20)` → `1`, `find_index([10, 20, 30], 99)` → `-1`.
def find_index(lst, value):
    pass


print(find_index([10, 20, 30], 20))   # 1
print(find_index([10, 20, 30], 99))   # -1
Рішення 
def find_index(lst, value):
    try:
        return lst.index(value)
    except ValueError:
        return -1


print(find_index([10, 20, 30], 20))   # 1
print(find_index([10, 20, 30], 99))   # -1
09

Найчастіший елемент

#
Напишіть функцію `most_frequent(lst)`, яка повертає елемент, що зустрічається найчастіше у списку. Якщо є рівність — повертайте той, що з'явився першим. Приклад: `most_frequent([1, 2, 2, 3, 1, 2])` → `2`, `most_frequent([5, 5, 3, 3])` → `5`.
def most_frequent(lst):
    pass


print(most_frequent([1, 2, 2, 3, 1, 2]))   # 2
print(most_frequent([5, 5, 3, 3]))          # 5  (перший при рівності)
Рішення 
def most_frequent(lst):
    counts = {}
    for item in lst:
        counts[item] = counts.get(item, 0) + 1
    return max(lst, key=lambda x: counts[x])


print(most_frequent([1, 2, 2, 3, 1, 2]))   # 2
print(most_frequent([5, 5, 3, 3]))          # 5  (перший при рівності)
10

Вирівняти на один рівень

#
Напишіть функцію `flatten(lst)`, яка приймає список списків і повертає один плоский список з усіма елементами. Приклад: `flatten([[1, 2], [3, 4], [5]])` → `[1, 2, 3, 4, 5]`. Використовуйте `extend` або генератор списку.
def flatten(lst):
    pass


print(flatten([[1, 2], [3, 4], [5]]))        # [1, 2, 3, 4, 5]
print(flatten([[10, 20], [30], [40, 50]]))   # [10, 20, 30, 40, 50]
Рішення 
def flatten(lst):
    result = []
    for sub in lst:
        result.extend(sub)
    return result


# Однорядковий варіант:
def flatten_v2(lst):
    return [x for sub in lst for x in sub]


print(flatten([[1, 2], [3, 4], [5]]))        # [1, 2, 3, 4, 5]
print(flatten([[10, 20], [30], [40, 50]]))   # [10, 20, 30, 40, 50]