Целочисленные массивы в Python: создание, типы и производительность

Раздел: Списки -> Списки определенного типа

Основные способы создания списков целых чисел

Как создать список целых чисел наиболее эффективно?

Самый производительный способ в Python - использовать list comprehension или встроенную функцию list() с объектом range. Оба подхода работают на уровне C и минимизируют накладные расходы интерпретатора.

# Способ 1: списочное включение
numbers = [i for i in range(10)]
print(numbers)

Integer array python (список целых чисел в python)

# Способ 2: list() с range()
numbers = list(range(10))
print(numbers)

Результат обоих примеров: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]. Для простого диапазона list(range(...)) чуть быстрее, но list comprehension универсальнее, так как позволяет применять преобразования и фильтры.

Типичные ошибки:

  • Попытка использовать range с дробными аргументами (например, range(1.5)) вызывает TypeError. Для нецелых шагов применяйте numpy.arange.
  • Забыть преобразовать строки в целые числа: [x for x in strs] даст список строк, а не целых чисел.
  • Создание списка через for с append в сотню раз медленнее для больших объёмов.

Как создать список целых чисел с помощью цикла for и метода append?

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

numbers = []
for i in range(5):
    numbers.append(i)
print(numbers)
[0, 1, 2, 3, 4]

Метод append добавляет элемент в конец списка. Для небольших списков разница в скорости несущественна, но при миллионах элементов лучше использовать list comprehension.

Типичные ошибки:

  • Забыть инициализировать пустой список перед циклом (NameError).
  • Добавление значения другого типа (например, строки) - список останется гетерогенным, что может привести к ошибке при сортировке или арифметике.

Как преобразовать список строк в список целых чисел с помощью map и int?

Функциональный стиль подходит, когда исходные данные уже находятся в виде строк.

str_numbers = ['10', '20', '30']
int_numbers = list(map(int, str_numbers))
print(int_numbers)
[10, 20, 30]

map применяет функцию int к каждому элементу, а list() материализует результат в список. Это быстрее, чем явный цикл, но медленнее comprehension при сложных преобразованиях.

Типичные ошибки:

  • Если строка не может быть преобразована (например, 'abc'), возникнет ValueError. Желательно обернуть в try-except или предварительно фильтровать.
  • Забыть обернуть map в list() - получится объект-итератор, а не список.

Как создать типизированный массив целых чисел через array.array?

Модуль array предоставляет однородные массивы, которые занимают меньше памяти, чем обычные списки, и поддерживают только один тип данных.

import array
arr = array.array('i', [1, 2, 3, 4, 5])
print(arr)
print(type(arr))
array('i', [1, 2, 3, 4, 5])
<class 'array.array'>

Код типа 'i' означает знаковое целое (signed int). Для больших объёмов данных array значительно экономит память по сравнению со списком Python. Однако методы (например, append) всё равно существуют.

Типичные ошибки:

  • Попытка добавить значение неподдерживаемого типа (например, float) вызовет TypeError.
  • Неправильный код типа (например, 'f' для float) - массив будет другого типа.
  • В Python 3 array не поддерживает sort (доступен только sorted() с созданием списка).

Как работать с большими массивами целых чисел с помощью numpy?

Библиотека NumPy оптимизирована для численных расчётов. Массивы ndarray могут содержать только один тип данных и используют векторизованные операции.

import numpy as np
arr = np.arange(0, 10, 1, dtype=np.int32)
print(arr)
print(arr.dtype)
[0 1 2 3 4 5 6 7 8 9]
int32

np.arange создаёт массив целых чисел от 0 до 9. Можно задать шаг и тип данных. NumPy массивы поддерживают поэлементные арифметические операции без циклов.

Типичные ошибки:

  • Установка неправильного dtype (например, int64 для 32-битных целых) может привести к переполнению памяти или неожиданным результатам.
  • Смешивание целых чисел и чисел с плавающей точкой в одном массиве приводит к автоматическому преобразованию в float64.
  • Для очень больших массивов (>2^31 элементов) требуется явно указывать int64.

Как создать последовательность целых чисел без хранения в памяти с помощью генератора?

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

def int_generator():
    n = 0
    while True:
        yield n
        n += 1

gen = int_generator()
first_10 = [next(gen) for _ in range(10)]
print(first_10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Генераторы экономят память, но не поддерживают индексацию и не могут быть изменены (immutable). Для однократного прохода - идеальный выбор.

Типичные ошибки:

  • Исчерпание генератора - после полного обхода next() вызывает StopIteration. Если нужен многократный доступ, лучше использовать список.
  • Попытка получить длину генератора через len() - вызывает TypeError.

Расширенные примеры работы со списками целых чисел

Ниже приведены нестандартные или углублённые примеры, демонстрирующие различные аспекты создания и обработки целочисленных списков в Python.

Пример 1: Фильтрация чётных чисел из списка

Пример 
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = [n for n in numbers if n % 2 == 0]
print(even_numbers)
[2, 4, 6]

Условное включение позволяет одновременно отфильтровать и создать новый список.

Пример 2: Преобразование строк с возможными ошибками (с обработкой)

Пример 
raw_data = ['1', '2', 'abc', '3']
cleaned = []
for item in raw_data:
    try:
        cleaned.append(int(item))
    except ValueError:
        pass
print(cleaned)
[1, 2, 3]

Здесь игнорируются некорректные строки. Аналогичного результата можно достичь с помощью map и filter, но цикл с try-except более нагляден.

Пример 3: Использование itertools.count для генерации последовательности с шагом

Пример 
import itertools
counter = itertools.count(start=5, step=2)
first_7 = [next(counter) for _ in range(7)]
print(first_7)
[5, 7, 9, 11, 13, 15, 17]

itertools.count создаёт бесконечный генератор целых чисел с заданным шагом. Полезно для нумерации или генерирования тестовых данных.

Пример 4: Создание списка из вложенных списков (flatten)

Пример 
nested = [[1, 2], [3, 4, 5], [6]]
flat = [num for sublist in nested for num in sublist]
print(flat)
[1, 2, 3, 4, 5, 6]

Двойное включение (list comprehension) преобразует матрицу в одномерный список целых чисел.

Пример 5: Работа с array.array - методы frombytes и tobytes

Пример 
import array
# Создание массива и сериализация в байты
original = array.array('i', [100, 200, 300])
data = original.tobytes()
print('Байты:', data)

# Восстановление массива из байтов
restored = array.array('i')
restored.frombytes(data)
print('Восстановленный:', restored)
Байты: b'd\x00\x00\x00\xc8\x00\x00\x00,\x01\x00\x00'
Восстановленный: array('i', [100, 200, 300])

Эти методы полезны для передачи данных по сети или сохранения в бинарные файлы.

Пример 6: Быстрое возведение в квадрат с помощью numpy

Пример 
import numpy as np
arr = np.arange(1, 6)
squared = arr ** 2
print(squared)
[ 1  4  9 16 25]

Векторизованная операция **2 выполняется на C-уровне, что в сотни раз быстрее цикла по Python-списку.

Пример 7: Создание списка с шагом и отрицательными значениями

Пример 
descending = list(range(10, -5, -3))
print(descending)
[10, 7, 4, 1, -2]

range поддерживает отрицательный шаг, что удобно для обратных последовательностей.

Пример 8: Генератор с yield from для слияния двух диапазонов

Пример 
def merged_generator():
    yield from range(3)
    yield from range(10, 13)

result = list(merged_generator())
print(result)
[0, 1, 2, 10, 11, 12]

Конструкция yield from делегирует генерацию другому итератору, позволяя легко комбинировать последовательности.

Список целых чисел в Python - comments

En
Integer array python (python)