Python: 'list indices must be integers' — причины и решение

kirilljsx

При работе с Python списками каждый разработчик рано или поздно встречается с ошибкой, когда пытается обратиться к элементу списка неправильным типом индекса. Эта ошибка часто озадачивает новичков, хотя решается довольно просто. Давайте разберёмся, почему это происходит и как это исправить.

Ошибка возникает потому, что Python строго следит за типами данных при индексировании списков. Если вы пытаетесь получить элемент списка с помощью числа с плавающей точкой, строки или других типов вместо целого числа, вы столкнётесь с TypeError. Понимание этого механизма поможет вам избежать ошибок в будущем.

Что такое индексация списков и почему она требует целых чисел

В Python каждый элемент в списке имеет порядковый номер, называемый индексом. Индексирование начинается с нуля: первый элемент имеет индекс 0, второй — индекс 1, третий — индекс 2 и так далее. Это позволяет быстро получить нужный элемент из списка, используя его позицию.

Почему именно целые числа? Потому что индексы — это порядковые номера позиций, а не значения. Позиция в списке может быть только целым числом: у вас не может быть элемента на позиции 2.5 или на позиции “второй”. Python рассматривает индекс как указание на конкретное место в памяти, где хранится элемент, а эти места нумеруются только целыми числами.

Как выглядит правильная индексация:

Целое число: my_list, my_list, my_list[-1] (последний элемент)
Срез (slice): my_list (элементы с индекса 1 по 3)
Неправильно: my_list[2.5], my_list["два"], my_list[[1, 2]]

Основные причины возникновения ошибки

Ошибка “list indices must be integers or slices, not float” (и её варианты с другими типами данных) возникает по нескольким причинам. Понимание каждой из них поможет вам быстро найти и исправить проблему в своём коде.

Первая и самая частая причина — использование чисел с плавающей точкой вместо целых чисел. Это может произойти, если вы делите одно число на другое (обычное деление в Python возвращает float) или преобразуете пользовательский ввод в float вместо int.

Вторая причина — результат математической операции, который возвращает float. Например, если вы вычисляете индекс через деление, результат будет числом с плавающей точкой, даже если математически это целое число.

Третья причина — неправильное преобразование пользовательского ввода. Когда вы берёте данные от пользователя (из input(), API или базы данных), они часто приходят как строки или числа с плавающей точкой.

Четвёртая причина — путаница в типах данных при работе с циклами и диапазонами. Например, если вы пытаетесь использовать элемент одного списка как индекс для другого, а этот элемент не является целым числом.

Основные сценарии возникновения:

Результат деления: index = 5 / 2 → index = 2.5 → ошибка при list[index]
Преобразование ввода: index = float(input()) → попытка использовать как индекс
Ошибка в цикле: for j in list[i] где i — это не целое число
Использование строк как индексов: list["first"] вместо list
Неправильно построенная логика: работа с результатом какой-то функции, вернувшей float

Способ 1: Явное преобразование в целое число

Самый простой и прямолинейный способ — преобразовать индекс в целое число перед использованием. Python предоставляет встроенную функцию int(), которая конвертирует практически любое числовое значение в целое число.

Это решение работает во всех случаях, когда у вас есть число (целое или с плавающей точкой) и вам нужно получить целое число. Функция int() просто отбрасывает всё после запятой, не округляя значение.

my_list = [10, 20, 30, 40, 50]
index = 2.5
print(my_list[int(index)])  # Выведет: 30

Это работает потому, что int(2.5) преобразуется в 2, и вы получите элемент с индексом 2, который и есть число 30.

Другие примеры использования int():

# Преобразование строки в число, а потом в индекс
user_input = "3"
index = int(user_input)
print(my_list[index])  # Работает, если индекс валидный

# Преобразование результата деления
total = 10
groups = 3
index = int(total / groups)  # int(3.333...) = 3
print(my_list[index])

# Преобразование результата из другого источника
computed_index = calculate_index()  # Может вернуть float
print(my_list[int(computed_index)])

Когда использовать этот способ:

У вас есть число (float), которое нужно использовать как индекс
Вы уверены, что число находится в допустимом диапазоне (от -len(list) до len(list)-1)
Нужно быстро исправить ошибку без изменения логики программы

Способ 2: Целочисленное деление вместо обычного

Если индекс вычисляется через деление, используйте целочисленное деление (//) вместо обычного деления (/). Это предотвратит появление чисел с плавающей точкой.

Целочисленное деление всегда возвращает целое число, автоматически отбрасывая дробную часть. Это гораздо более элегантно, чем потом преобразовывать результат через int().

my_list = [10, 20, 30, 40, 50]

# Неправильно (обычное деление)
index = 5 / 2  # index = 2.5
print(my_list[index])  # TypeError!

# Правильно (целочисленное деление)
index = 5 // 2  # index = 2
print(my_list[index])  # Выведет: 30

Разница между / и // критична при работе с индексами. Оператор / всегда возвращает float в Python 3, даже если деление нацело. Оператор // всегда возвращает целое число.

Примеры целочисленного деления:

# Получить средний элемент списка
middle_index = len(my_list) // 2
print(my_list[middle_index])

# Разделить список на части и получить элемент из части
part_size = len(my_list) // 3
first_part_element = my_list[part_size]

# Работа с координатами или сетками
width = 640
height = 480
pixel_index = (y // height) * width + (x // width)

Когда использовать целочисленное деление:

Индекс вычисляется через деление двух чисел
Вам нужно разбить список на части
Вы работаете с двумерными или многомерными структурами
Нужна максимальная производительность (// быстрее, чем int(/))

Способ 3: Валидация и преобразование пользовательского ввода

Если индекс поступает от пользователя (через input(), API, форму и т.д.), всегда преобразуйте его в целое число и проверьте диапазон. Пользовательские данные часто приходят как строки, и их нужно правильно обработать.

Валидация — это не просто преобразование типа, но и проверка, что значение находится в допустимом диапазоне. Это предотвратит не только TypeError, но и IndexError (попытку получить элемент вне границ списка).

my_list = [10, 20, 30, 40, 50]

# Получить ввод от пользователя
try:
    user_input = input("Введите номер элемента (0-4): ")
    index = int(user_input)  # Преобразуем в целое число
    
    # Проверяем диапазон
    if 0 <= index < len(my_list):
        print(f"Элемент: {my_list[index]}")
    else:
        print(f"Ошибка: индекс должен быть от 0 до {len(my_list)-1}")
except ValueError:
    print("Ошибка: введено не целое число")

Важно обернуть преобразование в блок try-except, потому что функция int() выбросит исключение ValueError, если пользователь введёт не-числовое значение.

Полный процесс валидации:

Получить данные (строка, float или другой тип)
Попытаться преобразовать в целое число через int()
Поймать ValueError, если преобразование не удалось
Проверить, что индекс >= 0 и индекс < len(list)
Использовать индекс безопасно

def safe_list_access(lst, index_input):
    """Безопасно получить элемент списка с валидацией"""
    try:
        index = int(index_input)
    except (ValueError, TypeError):
        return None, "Индекс должен быть числом"
    
    if not (0 <= index < len(lst)):
        return None, f"Индекс вне диапазона (0-{len(lst)-1})"
    
    return lst[index], None

# Использование
my_list = [10, 20, 30]
result, error = safe_list_access(my_list, "1")
if error:
    print(f"Ошибка: {error}")
else:
    print(f"Результат: {result}")  # 20

Способ 4: Использование enumerate для безопасного итерирования

Если вы используете индексы в циклах, функция enumerate() избавляет вас от необходимости вручную работать с индексами. Она автоматически предоставляет целые числа как индексы.

Этот подход считается более “pythonic” и безопаснее, потому что вы не можете случайно использовать неправильный тип индекса. Кроме того, код становится более читаемым.

my_list = ["apple", "banana", "cherry"]

# Старый способ (потенциально опасный)
for i in range(len(my_list)):
    print(f"{i}: {my_list[i]}")

# Новый способ с enumerate (безопасный и читаемый)
for i, element in enumerate(my_list):
    print(f"{i}: {element}")

Функция enumerate() возвращает пары (индекс, значение), где индекс гарантированно целое число. Это исключает саму возможность использования неправильного типа индекса.

Примеры использования enumerate:

# С указанием начального индекса
for i, element in enumerate(my_list, start=1):
    print(f"{i}. {element}")  # Нумерация с 1

# Распаковка при работе со списками списков
matrix = [[1, 2], [3, 4], [5, 6]]
for i, row in enumerate(matrix):
    for j, cell in enumerate(row):
        print(f"matrix[{i}][{j}] = {cell}")

# Поиск элемента с его индексом
for i, value in enumerate(my_list):
    if value == "banana":
        print(f"Найден на индексе {i}")

Когда использовать enumerate:

Нужно получить как индекс, так и элемент списка
Пишете цикл по списку и нужна позиция элемента
Хотите код, который выглядит более профессионально
Работаете с вложенными списками или сложными структурами данных

Таблица сравнения решений

Способ	Когда использовать	Преимущества	Недостатки
int(index)	Есть число (float), нужен индекс	Универсальный, простой	Требует вызова функции каждый раз
Целочисленное деление //	Индекс вычисляется через деление	Встроенное в язык, быстрое	Работает только для деления
Валидация пользовательского ввода	Данные от пользователя	Безопасно, предотвращает ошибки	Требует больше кода
enumerate()	Итерирование по списку	Самый pythonic, безопасный	Нельзя использовать произвольный индекс

Частые ошибки и как их избежать

Разработчики часто делают одни и те же ошибки при работе с индексами списков. Знание этих ошибок поможет вам их предотвратить.

Ошибка 1: Забыли, что input() возвращает строку

Это частая ошибка для новичков: пользователь вводит число, но input() возвращает строку, которую нельзя использовать как индекс напрямую.

# Неправильно
index = input("Введите индекс: ")  # "2" (строка)
print(my_list[index])  # TypeError!

# Правильно
index = int(input("Введите индекс: "))  # 2 (число)
print(my_list[index])  # OK

Ошибка 2: Обычное деление вместо целочисленного

Особенно часто встречается при попытке найти серединный элемент или разделить список.

# Неправильно
middle = len(my_list) / 2  # Может быть 2.5
print(my_list[middle])  # TypeError!

# Правильно
middle = len(my_list) // 2  # Всегда целое число
print(my_list[middle])  # OK

Ошибка 3: Использование элемента списка как индекса без проверки типа

Если вы берёте индекс из другого списка или структуры, убедитесь, что это целое число.

# Неправильно
indices = [0.5, 1.5, 2.5]  # Список float
for idx in indices:
    print(my_list[idx])  # TypeError!

# Правильно
indices = [0, 1, 2]  # Список целых чисел
for idx in indices:
    print(my_list[idx])  # OK

Ошибка 4: Путаница при вложенных списках

Когда работаете с двумерными структурами, легко перепутать типы индексов.

matrix = [[1, 2], [3, 4]]
row_index = "0"  # Строка вместо числа

# Неправильно
print(matrix[row_index])  # TypeError!

# Правильно
row_index = 0  # Целое число
print(matrix[row_index])  # 1

Как избежать этих ошибок:

Всегда используйте int() при преобразовании пользовательского ввода
Используйте // для целочисленного деления, а не /
Проверяйте типы данных при работе с неизвестными источниками
Используйте enumerate() вместо range(len())
Добавляйте type hints в Python 3.5+ для большей ясности

Заключительные мысли и практические советы

Ошибка с индексами списков в Python — это не проблема самого языка, а признак того, что разработчик забыл о требованиях Python к типам данных. Как только вы поймёте, почему индексы должны быть целыми числами, эта ошибка перестанет вас беспокоить.

Не только исправляйте ошибку, когда она возникает, но и проактивно избегайте её: правильно обрабатывайте пользовательский ввод, используйте целочисленное деление, выбирайте enumerate() вместо range(len()). По мере практики эти привычки станут вторыми по природе, и вы будете писать код без таких ошибок с первой попытки.