Практикум по Python: задачи и варианты решений

Расширенные примеры

1. Поиск индексов всех максимальных значений

Если в списке несколько одинаковых максимумов, нужно найти их индексы.

def indices_of_max(lst):
    max_val = max(lst) if lst else None
    if max_val is None:
        return []
    return [i for i, v in enumerate(lst) if v == max_val]

numbers = [1, 5, 3, 5, 2]
print(indices_of_max(numbers))  # [1, 3]

[1, 3]

2. Поиск n наибольших элементов с помощью heapq

Используем heapq.nlargest для получения нескольких максимумов.

import heapq
numbers = [10, 3, 7, 15, 9, 20]
top3 = heapq.nlargest(3, numbers)
print(top3)  # [20, 15, 10]

[20, 15, 10]

Объяснение: heapq работает за O(n log k), где k – количество искомых элементов. Эффективно для больших списков.

3. Удаление дубликатов с сохранением порядка и подсчетом количества

Используем collections.Counter для подсчета повторений.

from collections import Counter
items = [1, 2, 1, 3, 2, 4]
unique_order = list(dict.fromkeys(items))
counts = Counter(items)
print("Уникальные:", unique_order)
print("Количество:", dict(counts))

Уникальные: [1, 2, 3, 4]
Количество: {1: 2, 2: 2, 3: 1, 4: 1}

4. Проверка палиндрома для произвольной последовательности (рекурсия)

def is_palindrome_recursive(s):
    if len(s) <= 1:
        return True
    if s[0] != s[-1]:
        return False
    return is_palindrome_recursive(s[1:-1])

print(is_palindrome_recursive("racecar"))  # True
print(is_palindrome_recursive("hello"))    # False

True
False

5. Чтение файла с построчной обработкой и фильтрацией по длине

with open('sample.txt', 'r', encoding='utf-8') as f:
    long_lines = [line.rstrip() for line in f if len(line) > 50]
print(f"Найдено строк длиннее 50 символов: {len(long_lines)}")
# Вывод первых трех
for line in long_lines[:3]:
    print(line)

Найдено строк длиннее 50 символов: 2
Это очень длинная строка, содержащая более пятидесяти символов для демонстрации.
Еще одна строка, которая явно превышает лимит в 50 символов, добавленная для примера.

6. Использование mmap для быстрого подсчета строк в большом файле

import mmap
with open('large_file.txt', 'r') as f:
    with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
        # разбиваем по символу новой строки
        count = mm.count(b'\n')
print(f"Строк: {count}")

Объяснение: mmap отображает файл в память, подсчет newlines происходит на уровне операционной системы, эффективно для гигабайтных файлов.

7. Группировка дубликатов с сохранением индексов

items = [1, 2, 1, 3, 2, 4]
from collections import defaultdict
groups = defaultdict(list)
for i, v in enumerate(items):
    groups[v].append(i)
print(dict(groups))
# {1: [0, 2], 2: [1, 4], 3: [3], 4: [5]}

{1: [0, 2], 2: [1, 4], 3: [3], 4: [5]}

8. Быстрая проверка палиндрома для чисел (без преобразования в строку)

def is_palindrome_number(x):
    if x < 0 or (x % 10 == 0 and x != 0):
        return False
    reversed_half = 0
    while x > reversed_half:
        reversed_half = reversed_half * 10 + x % 10
        x //= 10
    return x == reversed_half or x == reversed_half // 10

print(is_palindrome_number(121))   # True
print(is_palindrome_number(12321)) # True
print(is_palindrome_number(10))    # False

True
True
False

Объяснение: переворачиваем вторую половину числа и сравниваем с первой. Экономит память и подходит для больших чисел.

9. Чтение файла с пропуском заголовка и подсчетом статистики

with open('data.csv', 'r', encoding='utf-8') as f:
    next(f)  # пропустить заголовок
    total = 0
    count = 0
    for line in f:
        if line.strip():
            parts = line.split(',')
            try:
                value = float(parts[1])
                total += value
                count += 1
            except (IndexError, ValueError):
                continue
    avg = total / count if count else 0
print(f"Среднее значение второго столбца: {avg:.2f}")

10. Использование itertools.groupby для группировки последовательных дубликатов

from itertools import groupby
items = [1, 1, 2, 2, 2, 3, 1, 1]
grouped = [(k, list(g)) for k, g in groupby(items)]
print(grouped)
# [(1, [1, 1]), (2, [2, 2, 2]), (3, [3]), (1, [1, 1])]

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

Объяснение: groupby группирует только последовательные одинаковые элементы, в отличие от общего удаления дубликатов.