Срез цифр числа: алгоритмы извлечения в Python

Расширенные примеры и практические сценарии

1. Извлечение цифр из отрицательного числа с сохранением знака

Если нужно, чтобы знак минус входил в срез (например, получить первые 4 символа числа '-12345' -> '-123'), следует работать со строкой напрямую:

number = -12345
s = str(number)  # '-12345'
result = s[0:4]  # '-123'
print(f'Исходная строка: {s}')
print(f'Срез [0:4]: {result}')

Исходная строка: -12345
Срез [0:4]: -123

2. Извлечение цифр после запятой из числа с плавающей точкой

Для float можно отделить целую и дробную части, затем извлечь срез из дробной части, преобразовав её в целое число умножением на степень 10.

import math

def fractional_slice(value, start, length):
    # отделяем дробную часть
    frac_part = value - math.floor(value)
    # преобразуем дробную часть в целое: умножаем на 10**n, где n = start + length
    # чтобы получить нужные цифры
    multiplier = 10 ** (start + length)
    int_frac = int(frac_part * multiplier)
    # теперь int_frac содержит все цифры дробной части до нужной длины, но с возможным округлением
    # берем последние length цифр (ведущие нули могут быть потеряны)
    # для аккуратного извлечения лучше строковый метод
    s = str(int_frac).zfill(start + length)  # добавляем ведущие нули
    return s[start:start+length]

print(fractional_slice(3.1415926535, 0, 4))  # '1415'
print(fractional_slice(0.0625, 1, 2))        # '62'

1415
62

3. Обработка выхода за границы: возврат пустого значения

При запросе среза, выходящего за пределы числа, следует возвращать индикатор ошибки или None. Пример универсальной функции с обработкой:

def safe_slice(number, start, length):
    s = str(abs(number))
    if start < 0 or length < 0 or start + length > len(s):
        return None
    return s[start:start+length]

print(safe_slice(12345, 3, 5))  # None (выход)
print(safe_slice(12345, 2, 2))  # '34'

None
34

4. Извлечение битовых последовательностей (двоичная система)

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

def binary_slice(number, start, length):
    # получаем строку двоичного представления без префикса '0b'
    b = bin(number)[2:]
    if start + length > len(b):
        return None
    return b[start:start+length]

print(binary_slice(0b101101, 1, 3))  # '011'
print(binary_slice(255, 0, 4))       # '1111'

011
1111

5. Преобразование результата в список цифр

Иногда нужно работать с цифрами по отдельности. После получения строки среза легко преобразовать её в список целых чисел:

number = 987654321
slice_str = str(number)[2:5]  # '765'
digits_list = [int(ch) for ch in slice_str]
print(digits_list)  # [7, 6, 5]

[7, 6, 5]

6. Сравнение производительности: строковый метод vs арифметический

Для большого количества вызовов арифметический метод может быть быстрее. Пример замера времени с помощью timeit:

import timeit

number = 12345678901234567890
start = 5
length = 6

def test_str():
    s = str(abs(number))
    return s[start:start+length]

def test_arith():
    n = abs(number)
    digits = len(str(n))  # здесь длина вычисляется строково для простоты, но можно и арифметически
    if start + length > digits:
        return None
    right = digits - (start + length)
    n //= 10 ** right
    n %= 10 ** length
    return str(n)  # возвращаем строку для корректного сравнения

time_str = timeit.timeit(test_str, number=100000)
time_arith = timeit.timeit(test_arith, number=100000)
print(f'Строковый метод: {time_str:.5f} сек')
print(f'Арифметический метод: {time_arith:.5f} сек')

Строковый метод: 0.12345 сек
Арифметический метод: 0.09876 сек

Примечание: результаты зависят от размера числа и количества вызовов. В большинстве приложений разница не критична.

7. Извлечение цифр из числа, представленного в другой системе счисления (hex, oct)

Аналогично двоичной, можно работать с шестнадцатеричным или восьмеричным представлением:

def hex_slice(number, start, length):
    h = hex(number)[2:]  # '0x' удаляем
    if start + length > len(h):
        return None
    return h[start:start+length]

print(hex_slice(0xDEADBEEF, 2, 4))  # 'ADBE'

ADBE