Python: как проверить, что строка содержит число
Основные подходы для проверки строки на число
При работе с пользовательским вводом или обработке данных часто возникает необходимость определить, содержит ли строка числовое значение. В Python существует несколько способов решения этой задачи, каждый из которых подходит для определенных сценариев. Ниже рассмотрен наиболее универсальный метод, а затем альтернативные варианты с пояснениями и примерами кода.
Проверка через попытку преобразования (try-except с float)
Самый надежный способ - попытаться преобразовать строку в число с помощью float() и перехватить исключение, если это невозможно. Данный метод корректно обрабатывает целые числа, числа с плавающей точкой, отрицательные значения, а также экспоненциальную запись (например, '1e5').
def is_number(s):
try:
float(s)
return True
except ValueError:
return False
print(is_number('123')) # True
print(is_number('-45.67')) # True
print(is_number('1.5e2')) # True
print(is_number('abc')) # False
print(is_number('12 34')) # False (пробел)Python проверить строку на число (проверка строки на число в python)
Объяснение: функция float() принимает строки, представляющие допустимые числа, иначе выбрасывает ValueError. Блок except перехватывает эту ошибку и возвращает False.
Возможные проблемы и ошибки:
- Строки, содержащие пробелы (например, ' 123 '), приводят к исключению. Решение: вызывать strip() перед преобразованием.
- Пустая строка вызывает ValueError, что считается False – в большинстве случаев это ожидаемое поведение.
- Числа со знаком '+' также допустимы: float('+7') вернет 7.0.
- Разделитель тысяч (например, '1,000') не распознается. Для таких случаев требуется предварительная очистка.
Как проверить, что строка содержит только цифры (целое неотрицательное число)?
Метод str.isdigit() возвращает True, если все символы строки являются цифрами (0-9) и строка не пуста. Он не подходит для отрицательных чисел, чисел с плавающей точкой или пробелами.
print('123'.isdigit()) # True
print('045'.isdigit()) # True
print('-5'.isdigit()) # False (минус не цифра)
print('12.3'.isdigit()) # False (точка не цифра)Когда использовать: быстрая проверка на неотрицательное целое без дополнительных символов (например, номера телефонов, коды).
Типичные ошибки:
- Пустая строка ''.isdigit() возвращает False, хотя может ожидаться True (если считать пустую строку числом? обычно нет).
- Юникод-цифры (например, арабские) тоже считаются цифрами, что может быть нежелательно.
Как проверить, что строка является целым числом (включая отрицательные)?
Можно сначала отбросить знак и затем применить isdigit():
def is_integer(s):
if s and s[0] in ('-', '+'):
return s[1:].isdigit()
return s.isdigit()
print(is_integer('123')) # True
print(is_integer('-5')) # True
print(is_integer('+7')) # True
print(is_integer('12.3')) # FalseЭтот подход не использует обработку исключений. Однако он не обрабатывает пробелы и пустые строки.
- Не учитывает числа с пробелами (например, ' 5'). Нужна предварительная очистка.
- Строка, состоящая только из знака ('-'), вернет True (s[1:] пустая, isdigit() для пустой строки False – проверка спасет, но в коде выше нет проверки на длину после знака). Лучше добавить проверку len(s) > 1.
Как проверить строку на число с помощью метода isnumeric()?
Метод str.isnumeric() похож на isdigit(), но поддерживает также дроби, римские цифры и другие числовые представления в Юникоде. Например:
print('½'.isnumeric()) # True (дробь)
print('123'.isnumeric()) # True
print('-5'.isnumeric()) # False
print('1.5'.isnumeric())# FalseИспользуется, когда нужно распознать расширенные числовые символы. Для обычных десятичных чисел лучше применять isdigit().
- Не учитывает знак минус или точку.
- Разные версии Python могут по-разному определять «числовые» символы.
Как проверить строку на число при помощи регулярных выражений?
Модуль re позволяет задать точный шаблон, например, для десятичного числа с необязательным знаком и дробной частью:
import re
def is_number_re(s):
pattern = r'^[+-]?\d+(\.\d+)?$'
return bool(re.match(pattern, s))
print(is_number_re('123')) # True
print(is_number_re('-45.5')) # True
print(is_number_re('+0.5')) # True
print(is_number_re('1.2.3')) # False
print(is_number_re('1e5')) # False (научная запись не подходит под этот шаблон)Регулярное выражение дает полный контроль над форматом. Однако для научной записи (1e5) потребуется более сложный шаблон.
- Шаблон не учитывает пустые строки (пустая строка не соответствует).
- Может пропускать числа с пробелами (пробел внутри шаблона не допускается).
- Излишне сложно для простых проверок.
Как обработать числа с разделителями тысяч или пробелами?
Перед проверкой строку следует очистить от незначащих символов. Например, удалить пробелы и запятые:
def is_number_cleaned(s):
cleaned = s.replace(',', '').replace(' ', '')
try:
float(cleaned)
return True
except ValueError:
return False
print(is_number_cleaned('1,000.5')) # True
print(is_number_cleaned(' 12 34 ')) # True (пробелы удалены)Такой подход удобен для импорта данных из CSV или пользовательского ввода.
- Запятая может быть десятичным разделителем (как в некоторых странах). Нужно знать локаль.
- Удаление всех пробелов может нарушить формат, если пробел является частью числа (например, '1 000' в некоторых стандартах – тысяча).
Расширенные примеры проверки строк на число
Ниже приведены дополнительные сценарии с подробными комментариями и выводом.
Пример 1: Использование decimal для высокой точности
from decimal import Decimal, InvalidOperation
def is_decimal_number(s):
try:
Decimal(s)
return True
except InvalidOperation:
return False
print(is_decimal_number('3.14159')) # True
print(is_decimal_number('-0.001')) # True
print(is_decimal_number('NaN')) # True (NaN считается Decimal)
print(is_decimal_number('Infinity')) # True
print(is_decimal_number('1.2.3')) # FalseTrue True True True False
Модуль decimal обрабатывает специальные значения, такие как 'NaN' и 'Infinity', что может быть нежелательно. Если нужно их исключить, следует добавить дополнительную проверку.
Пример 2: Проверка с учётом научной записи (e-нотации)
import re
def is_scientific_number(s):
# Шаблон для чисел с экспонентой (e или E), необязательным знаком и целой/дробной частью
pattern = r'^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$'
return bool(re.match(pattern, s.strip()))
tests = ['2e10', '-3.5E-2', '1e-5', '.5e3', '5.', '1e', 'e5', '']
for t in tests:
print(f"'{t}' -> {is_scientific_number(t)}")'2e10' -> True '-3.5E-2' -> True '1e-5' -> True '.5e3' -> True '5.' -> True '1e' -> False 'e5' -> False '' -> False
Данный шаблон покрывает большинство случаев, включая числа, начинающиеся с точки.
Пример 3: Проверка принадлежности к целым числам (int) с обработкой переполнения
def is_safe_integer(s):
try:
val = int(s)
return True
except ValueError:
return False
except OverflowError:
# Строка представляет число, не влезающее в int (например, 10**1000)
return True # или False, в зависимости от задачи
print(is_safe_integer('123')) # True
print(is_safe_integer('-999999999999999999999')) # True (в Python int неограничен)
print(is_safe_integer('12.3')) # False
print(is_safe_integer('')) # FalseTrue True False False
В Python 3 int не имеет ограничения по размеру, поэтому OverflowError не возникает; код приведен для совместимости с Python 2 или гипотетическими расширениями.
Пример 4: Использование библиотеки numpy (если доступна)
import numpy as np
def is_numeric_numpy(s):
try:
np.float64(s)
return True
except (ValueError, TypeError):
return False
print(is_numeric_numpy('3.14')) # True
print(is_numeric_numpy('inf')) # True
print(is_numeric_numpy('nan')) # True
print(is_numeric_numpy('abc')) # FalseTrue True True False
Библиотека numpy поддерживает специальные значения и может быть полезна в научных расчётах. Однако при отсутствии numpy возникнет ошибка импорта.
Пример 5: Комплексные числа
def is_complex_number(s):
try:
complex(s)
return True
except ValueError:
return False
print(is_complex_number('2+3j')) # True
print(is_complex_number('5j')) # True
print(is_complex_number('(1+2j)')) # True (скобки допускаются)
print(is_complex_number('abc')) # FalseTrue True True False
Функция complex() принимает строки в формате 'a+bj' или '(a+bj)'. Если требуется проверка именно на вещественное число, лучше не использовать комплексные.