Программы с массивами на Python: от основ до продвинутых приёмов

Дополнительные примеры и приёмы работы с массивами

1. Использование array.array для экономии памяти

from array import array
arr = array('d', [1.5, 2.3, 3.7])  # массив чисел с плавающей точкой (double)
arr.append(4.1)
print(arr)
# array('d', [1.5, 2.3, 3.7, 4.1])

array('d', [1.5, 2.3, 3.7, 4.1])

Массив array хранит элементы одного типа (здесь 'd' - double). Занимает меньше памяти, чем список, но поддерживает не все методы (например, нет sort). Подходит для больших числовых данных.

2. Транспонирование матрицы (списка списков)

matrix = [[1, 2, 3],
          [4, 5, 6]]
transposed = [list(row) for row in zip(*matrix)]
print(transposed)
# [[1, 4], [2, 5], [3, 6]]

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

Используется оператор распаковки * для передачи строк матрицы в zip, который собирает элементы по столбцам. Затем каждая группа преобразуется в список.

3. Сортировка строк по длине

words = ['apple', 'pear', 'banana', 'kiwi']
sorted_words = sorted(words, key=len, reverse=True)
print(sorted_words)
# ['banana', 'apple', 'pear', 'kiwi']

['banana', 'apple', 'pear', 'kiwi']

Параметр key=len задаёт функцию вычисления ключа сортировки. Аналогично можно сортировать по последней букве: key=lambda x: x[-1].

4. Группировка элементов по условию

numbers = [1, 2, 3, 4, 5, 6]
even = [x for x in numbers if x % 2 == 0]
odd = [x for x in numbers if x % 2 != 0]
print('Чётные:', even, 'Нечётные:', odd)
# Чётные: [2, 4, 6] Нечётные: [1, 3, 5]

Чётные: [2, 4, 6] Нечётные: [1, 3, 5]

Два прохода - простое решение. Для одного прохода можно использовать filter и lambda или словарь списков.

5. Применение нескольких функций к элементам с map

def square(x):
    return x**2

def cube(x):
    return x**3

numbers = [1, 2, 3, 4]
result = list(map(lambda x: (square(x), cube(x)), numbers))
print(result)
# [(1, 1), (4, 8), (9, 27), (16, 64)]

[(1, 1), (4, 8), (9, 27), (16, 64)]

Функция map возвращает итератор. Преобразование в список даёт кортеж из результатов двух функций для каждого числа.

6. Слияние двух списков поочерёдно

a = [1, 2, 3]
b = ['a', 'b', 'c']
merged = [val for pair in zip(a, b) for val in pair]
print(merged)
# [1, 'a', 2, 'b', 3, 'c']

[1, 'a', 2, 'b', 3, 'c']

Двойное for в comprehension: сначала берётся пара из zip, затем каждый элемент пары добавляется в итоговый список.

7. Поиск дубликатов в списке

items = [1, 2, 3, 2, 4, 1]
seen = set()
duplicates = []
for item in items:
    if item in seen:
        duplicates.append(item)
    else:
        seen.add(item)
print('Дубликаты:', duplicates)
# Дубликаты: [2, 1]

Дубликаты: [2, 1]

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

8. Генерация списка случайных чисел с условием

import random
random.seed(42)  # для воспроизводимости
numbers = [random.randint(1, 100) for _ in range(10) if random.randint(1, 100) % 2 == 0]
# Внимание: такой подход может дать меньше 10 чисел, так как условие проверяется на новом random

Лучше генерировать полный список и потом фильтровать:

numbers = [x for x in (random.randint(1,100) for _ in range(10)) if x % 2 == 0]

[18, 66, 42, 6]

9. Преобразование списка строк в числа с обработкой ошибок

strings = ['10', '20', 'abc', '30']
numbers = []
for s in strings:
    try:
        numbers.append(int(s))
    except ValueError:
        numbers.append(None)  # или игнорировать
print(numbers)
# [10, 20, None, 30]

[10, 20, None, 30]

При преобразовании типов возможны исключения. Обработка внутри цикла позволяет продолжить выполнение, заменяя некорректные значения на None.

10. Использование излишнего копирования - проблема производительности

big_list = list(range(1000000))
# Плохо: каждый раз создаётся новый список
total = 0
for i in range(len(big_list)):
    total += big_list[i]
# Хорошо: sum(big_list) или цикл по элементам

Цикл с индексами медленнее и менее читаем. Лучше использовать встроенные функции или итерацию напрямую: for x in big_list:.