Целые числа в Python: операции с int от базовых до продвинутых

Для кого эта статья:

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

• разработчики, интересующиеся практическими задачами и алгоритмами, связанными с целыми числами

  Целые числа в Python — это не просто набор цифр, а мощный фундамент для построения сложных алгоритмов и решения повседневных задач программирования. Независимо от того, рассчитываете ли вы бюджет, анализируете данные или создаете игру, тип данных int является вашим надежным инструментом. В этом руководстве мы детально разберем все аспекты работы с целыми числами — от базовых операций до продвинутых техник, которыми владеют только опытные разработчики. Приготовьтесь открыть для себя мир Python, где каждое целое число имеет безграничные возможности! 🔢

Хотите научиться применять Python для решения реальных задач, а не только теоретически изучать целые числа? Обучение Python-разработке от Skypro поможет вам пройти путь от новичка до профессионала. Наша программа построена на практических проектах, где вы будете использовать все операции с целыми числами, которые мы рассмотрим в этой статье, и намного больше! Вместо простого чтения о Python вы начнете писать работающий код уже на первом занятии.

Что такое целые числа в Python: особенности типа int

Целые числа (integers) в Python представлены типом данных int и являются одним из фундаментальных примитивных типов языка. В отличие от многих других языков программирования, Python не ограничивает размер целых чисел, что делает этот тип данных чрезвычайно гибким инструментом для разработчиков. 💪

В Python 3 существует только один тип целых чисел — int. Это отличается от Python 2, где были отдельные типы int и long. Такое объединение упростило работу с целыми числами и избавило разработчиков от необходимости следить за переполнением.

Давайте посмотрим на основные характеристики типа int в Python:

• Неограниченная точность — размер целого числа ограничен только доступной памятью компьютера
• Знаковые числа — могут быть как положительными, так и отрицательными
• Литеральные представления — поддержка различных систем счисления (десятичная, двоичная, восьмеричная, шестнадцатеричная)
• Автоматическое приведение типов — при операциях между int и float результат автоматически преобразуется в float

Создать целое число в Python можно несколькими способами:

# Прямое присваивание
x = 42

# Использование конструктора int()
y = int(3.14) # Преобразует float в int, отбрасывая дробную часть
z = int("100") # Преобразует строку в число

# Использование различных систем счисления
binary = 0b1010 # Двоичная (значение 10)
octal = 0o12 # Восьмеричная (значение 10)
hex_number = 0xA # Шестнадцатеричная (значение 10)

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

Тип int в Python реализован таким образом, что обеспечивает высокую производительность при работе с небольшими числами и беспроблемно масштабируется для работы с очень большими значениями. Это делает Python идеальным языком для математических вычислений и задач, требующих работы с большими числами, таких как криптография.

Алексей Петров, старший преподаватель программирования

Однажды на занятии по Python я столкнулся с интересным случаем. Студент пытался создать программу для расчета факториалов больших чисел и был уверен, что ему придется использовать специальные библиотеки для работы с большими числами, как он это делал в C++.

"В Python это делается намного проще," — сказал я ему. "Давайте посчитаем факториал 1000 прямо сейчас."

Мы написали простую функцию:

Python

Скопировать код

def factorial(n):
result = 1
for i in range(1, n+1):
result *= i
return result

print(factorial(1000))

Когда программа вывела огромное число из 2568 цифр без каких-либо ошибок переполнения, студент был поражен. "В других языках мне пришлось бы писать специальный код для обработки таких чисел, а здесь это работает из коробки!" — воскликнул он.

Этот момент стал для него переломным в понимании мощности Python. Студент понял, что язык спроектирован так, чтобы разработчик мог сосредоточиться на решении задачи, а не на преодолении ограничений языка.

Базовые математические операции с целыми числами Python

Python предлагает полный набор базовых математических операций для работы с целыми числами, которые интуитивно понятны и соответствуют правилам математики. Эти операции — основа для создания практически любого алгоритма в программировании. 🧮

Рассмотрим основные арифметические операции, доступные для целых чисел:

# Сложение
a = 5 + 3 # 8

# Вычитание
b = 10 – 7 # 3

# Умножение
c = 4 * 6 # 24

# Деление (возвращает float)
d = 20 / 4 # 5.0

# Целочисленное деление (возвращает int)
e = 20 // 6 # 3

# Остаток от деления (модуль)
f = 20 % 6 # 2

# Возведение в степень
g = 2 ** 3 # 8

# Отрицание
h = -10 # -10

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

Python также поддерживает составные операторы присваивания, которые объединяют математическую операцию и присваивание:

x = 5
x += 3 # Эквивалентно x = x + 3, теперь x = 8
x -= 2 # Эквивалентно x = x – 2, теперь x = 6
x *= 4 # Эквивалентно x = x * 4, теперь x = 24
x //= 3 # Эквивалентно x = x // 3, теперь x = 8
x %= 5 # Эквивалентно x = x % 5, теперь x = 3
x **= 2 # Эквивалентно x = x ** 2, теперь x = 9

При выполнении математических выражений Python следует стандартному порядку операций (PEMDAS: скобки, экспоненты, умножение/деление, сложение/вычитание):

result = 2 + 3 * 4 # 14, а не 20
result = (2 + 3) * 4 # 20

Для целых чисел также доступны битовые операции, которые работают с двоичным представлением чисел:

# Побитовое И (AND)
a = 5 & 3 # 1 (101 & 011 = 001)

# Побитовое ИЛИ (OR)
b = 5 | 3 # 7 (101 | 011 = 111)

# Побитовое исключающее ИЛИ (XOR)
c = 5 ^ 3 # 6 (101 ^ 011 = 110)

# Побитовое отрицание (NOT)
d = ~5 # -6 (инвертирует все биты и добавляет 1)

# Сдвиг влево
e = 5 << 1 # 10 (сдвигает биты на 1 позицию влево)

# Сдвиг вправо
f = 5 >> 1 # 2 (сдвигает биты на 1 позицию вправо)

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

При работе с целыми числами в Python важно помнить об одной особенности: когда вы выполняете операцию между целым числом и числом с плавающей точкой, результат всегда будет числом с плавающей точкой. Это называется "расширяющим" приведением типов.

result = 5 + 3.0 # 8.0 (float, не int)

Продвинутые операции и методы работы с int в Python

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

Начнем с встроенных функций Python, специально предназначенных для работы с числами:

# Абсолютное значение
abs_value = abs(-42) # 42

# Наибольший общий делитель
import math
gcd_value = math.gcd(48, 18) # 6

# Наименьшее общее кратное (Python 3.9+)
lcm_value = math.lcm(4, 6) # 12

# Возведение в степень с модулем (эффективно для больших чисел)
pow_mod = pow(2, 10, 1000) # 2^10 % 1000 = 24

# Округление числа
rounded = round(4.6) # 5

# Определение знака числа
import math
sign = math.copysign(1, -42) # -1.0

Для работы с большими числами Python предоставляет встроенный модуль math, который содержит множество полезных функций:

import math

# Факториал
fact = math.factorial(5) # 120

# Квадратный корень
sqrt = math.isqrt(16) # 4 (целочисленный квадратный корень)

# Проверка, является ли число степенью двойки
is_power = math.log2(16).is_integer() # True

# Потолок и пол
ceiling = math.ceil(4.2) # 5
floor = math.floor(4.8) # 4

# Число сочетаний
combinations = math.comb(5, 2) # 10 (количество способов выбрать 2 элемента из 5)

Для тех, кто работает с криптографией или требует более сложных операций с целыми числами, Python предлагает модуль sympy, который значительно расширяет возможности работы с целыми числами:

import sympy

# Проверка, является ли число простым
is_prime = sympy.isprime(17) # True

# Получение всех простых множителей
factors = sympy.factorint(100) # {2: 2, 5: 2} (2^2 * 5^2)

# Расширенный алгоритм Евклида
gcd, x, y = sympy.gcdex(42, 12) # (6, -1, 4), где 6 = gcd, -1*42 + 4*12 = 6

# Генерация простого числа заданной битности
prime = sympy.randprime(2**100, 2**101)

Для работы с различными системами счисления Python предлагает несколько полезных функций:

# Преобразование в двоичную систему
binary = bin(42) # '0b101010'

# Преобразование в восьмеричную систему
octal = oct(42) # '0o52'

# Преобразование в шестнадцатеричную систему
hexadecimal = hex(42) # '0x2a'

# Преобразование из строки заданной системы счисления в int
from_binary = int('101010', 2) # 42
from_octal = int('52', 8) # 42
from_hex = int('2a', 16) # 42
from_base36 = int('16', 36) # 42 (использует цифры 0-9 и буквы a-z)

Для операций с битами, которые часто требуются в низкоуровневом программировании и оптимизации, Python предоставляет модуль operator:

import operator

# Подсчет количества установленных битов
bit_count = bin(42).count('1') # 3

# Число бит, необходимое для представления числа в двоичном виде
bit_length = 42.bit_length() # 6

# Побитовое И
and_result = operator.and_(5, 3) # 1

# Побитовое ИЛИ
or_result = operator.or_(5, 3) # 7

# Побитовое исключающее ИЛИ
xor_result = operator.xor(5, 3) # 6

# Побитовое отрицание
not_result = operator.invert(5) # -6

Иван Сорокин, разработчик алгоритмов машинного обучения

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

Изначально я использовал стандартный подход с логарифмом:

Python

Скопировать код

def is_power_of_two(n):
if n <= 0:
return False
return math.log2(n).is_integer()

Эта функция работала корректно, но когда я запускал ее миллионы раз, она становилась узким местом. Тогда я вспомнил о битовых операциях и переписал функцию:

Python

Скопировать код

def is_power_of_two(n):
if n <= 0:
return False
return (n & (n – 1)) == 0

Результат поразил всю команду — обработка данных ускорилась почти в 20 раз! Это был момент, когда я по-настоящему оценил мощь битовых операций в Python.

Простое объяснение, почему это работает: число, являющееся степенью двойки, имеет только один установленный бит в двоичном представлении (например, 8 = 1000₂). Когда мы вычитаем 1, получаем число со всеми установленными битами до этой позиции (7 = 0111₂). Операция побитового И между ними всегда даст 0 только для степеней двойки.

Преобразование между целыми и другими типами данных

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

Рассмотрим основные сценарии преобразования между целыми числами и другими типами данных:

Преобразование из строки в целое число

# Базовое преобразование
num = int("42") # 42

# Обработка чисел в разных системах счисления
binary = int("101010", 2) # 42
octal = int("52", 8) # 42
hex_num = int("2A", 16) # 42

# Обработка чисел с пробелами
num_with_spaces = int("1 000 000".replace(" ", "")) # 1000000

# Обработка строк с префиксами
binary_with_prefix = int("0b101010", 0) # 42, префикс 0b распознается автоматически

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

try:
int("abc") # Вызовет ValueError
except ValueError as e:
print(f"Ошибка преобразования: {e}") # Ошибка преобразования: invalid literal for int() with base 10: 'abc'

Преобразование из чисел с плавающей точкой в целые числа

При преобразовании числа с плавающей точкой в целое число дробная часть отбрасывается (не округляется):

# Базовое преобразование
int(3.14) # 3
int(3.99) # 3 (обратите внимание, что число не округляется, а отсекается)

# Преобразование отрицательных чисел
int(-3.14) # -3
int(-3.99) # -3 (дробная часть также отсекается)

Если вам нужно округление, а не отсечение, используйте функцию round() перед преобразованием в int или функции math.floor() и math.ceil():

import math

# Округление до ближайшего целого
round(3.14) # 3
round(3.5) # 4

# Округление вниз (пол)
math.floor(3.99) # 3

# Округление вверх (потолок)
math.ceil(3.01) # 4

Преобразование целых чисел в другие типы данных

Целые числа часто требуется преобразовывать в другие типы данных для различных операций:

# Преобразование в float
float(42) # 42.0

# Преобразование в строку
str(42) # "42"

# Преобразование в boolean
# 0 преобразуется в False, любое другое число — в True
bool(0) # False
bool(42) # True

# Преобразование в строковое представление в разных системах счисления
bin(42) # "0b101010"
oct(42) # "0o52"
hex(42) # "0x2a"

# Преобразование в список цифр
digits = [int(digit) for digit in str(42)] # [4, 2]

Преобразование между списками/кортежами и целыми числами

Иногда требуется преобразовать список цифр в число или наоборот:

# Список цифр в число
digits = [1, 2, 3, 4]
number = int(''.join(map(str, digits))) # 1234

# Число в список цифр
number = 42
digits = [int(digit) for digit in str(number)] # [4, 2]

# Более эффективный способ для чисел с большим количеством цифр
digits = []
n = 123456789
while n > 0:
digits.insert(0, n % 10)
n //= 10
# digits = [1, 2, 3, 4, 5, 6, 7, 8, 9]

Особые случаи преобразования

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

# Преобразование очень большого числа из строки в int
big_num = int("1" * 1000) # Создает число из 1000 единиц

# Преобразование между целыми числами и байтами
num = 42
# Преобразование в bytes в порядке big-endian
bytes_representation = num.to_bytes(2, byteorder='big') # b'\x00*'

# Обратное преобразование
original_num = int.from_bytes(bytes_representation, byteorder='big') # 42

Практические задачи и решения с использованием int

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

Задача 1: Проверка числа на простоту

Проверка, является ли число простым, — классическая задача в математике и программировании.

def is_prime(n):
"""Проверяет, является ли число простым."""
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True

# Проверка нескольких чисел
for num in [2, 7, 10, 17, 20, 97]:
print(f"{num} {'является' if is_prime(num) else 'не является'} простым числом")

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

Задача 2: Вычисление НОД и НОК

Нахождение наибольшего общего делителя (НОД) и наименьшего общего кратного (НОК) — распространенная задача в математике.

def gcd(a, b):
"""Вычисляет наибольший общий делитель двух чисел."""
while b:
a, b = b, a % b
return a

def lcm(a, b):
"""Вычисляет наименьшее общее кратное двух чисел."""
return a * b // gcd(a, b)

# Пример использования
a, b = 48, 18
print(f"НОД({a}, {b}) = {gcd(a, b)}") # НОД(48, 18) = 6
print(f"НОК({a}, {b}) = {lcm(a, b)}") # НОК(48, 18) = 144

Для Python 3.5+ можно использовать встроенную функцию math.gcd(), а в Python 3.9+ также доступна функция math.lcm().

Задача 3: Преобразование числа из одной системы счисления в другую

Часто требуется конвертировать числа между различными системами счисления.

def convert_base(num, from_base, to_base):
"""Преобразует число из одной системы счисления в другую."""
# Сначала переводим в десятичную систему
if from_base != 10:
decimal = 0
power = 0
for digit in reversed(str(num)):
decimal += int(digit, from_base) * (from_base ** power)
power += 1
else:
decimal = num

# Затем из десятичной в целевую
if to_base == 10:
return decimal

result = ""
while decimal > 0:
remainder = decimal % to_base
if remainder < 10:
result = str(remainder) + result
else:
result = chr(remainder – 10 + ord('A')) + result
decimal //= to_base

return result if result else "0"

# Примеры использования
print(convert_base("101010", 2, 10)) # 42
print(convert_base("42", 10, 2)) # 101010
print(convert_base("2A", 16, 8)) # 52

Для простых случаев можно использовать встроенные функции int() для преобразования в десятичную систему и bin(), oct(), hex() для преобразования из десятичной в соответствующие системы.

Задача 4: Факторизация числа

Разложение числа на простые множители — важная задача в криптографии и теории чисел.

def prime_factors(n):
"""Возвращает список простых множителей числа n."""
factors = []
# Проверяем делимость на 2
while n % 2 == 0:
factors.append(2)
n //= 2

# Проверяем делимость на нечетные числа
i = 3
while i * i <= n:
while n % i == 0:
factors.append(i)
n //= i
i += 2

# Если n > 1, значит, n — простое число больше 2
if n > 1:
factors.append(n)

return factors

# Пример использования
num = 84
print(f"Простые множители {num}: {prime_factors(num)}") # [2, 2, 3, 7]

Задача 5: Решето Эратосфена для нахождения всех простых чисел до заданного предела

Алгоритм Решета Эратосфена — эффективный метод нахождения всех простых чисел до заданной границы.

def sieve_of_eratosthenes(limit):
"""Находит все простые числа до заданного предела."""
primes = []
sieve = [True] * (limit + 1)
sieve[0] = sieve[1] = False

for i in range(2, int(limit**0.5) + 1):
if sieve[i]:
for j in range(i*i, limit + 1, i):
sieve[j] = False

for i in range(2, limit + 1):
if sieve[i]:
primes.append(i)

return primes

# Пример использования
limit = 50
print(f"Простые числа до {limit}: {sieve_of_eratosthenes(limit)}")
# Простые числа до 50: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

Задача 6: Проверка на палиндром

Определение, является ли число палиндромом (читается одинаково слева направо и справа налево).

def is_palindrome(n):
"""Проверяет, является ли число палиндромом."""
return str(n) == str(n)[::-1]

# Пример использования
num = 12321
print(f"{num} {'является' if is_palindrome(num) else 'не является'} палиндромом")
# 12321 является палиндромом

# Альтернативный способ без преобразования в строку
def is_palindrome_math(n):
"""Проверяет, является ли число палиндромом, используя только математические операции."""
if n < 0:
return False

original = n
reversed_num = 0
while n > 0:
reversed_num = reversed_num * 10 + n % 10
n //= 10

return original == reversed_num

print(f"{num} {'является' if is_palindrome_math(num) else 'не является'} палиндромом (мат. метод)")

Задача 7: Бинарный поиск

Бинарный поиск — эффективный алгоритм поиска элемента в отсортированном массиве.

def binary_search(arr, target):
"""Выполняет бинарный поиск элемента в отсортированном массиве."""
left, right = 0, len(arr) – 1

while left <= right:
mid = (left + right) // 2 # Целочисленное деление для нахождения среднего индекса

if arr[mid] == target:
return mid # Элемент найден, возвращаем индекс
elif arr[mid] < target:
left = mid + 1 # Ищем в правой половине
else:
right = mid – 1 # Ищем в левой половине

return -1 # Элемент не найден

# Пример использования
sorted_array = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
target = 23
result = binary_search(sorted_array, target)
print(f"Индекс элемента {target}: {result}") # Индекс элемента 23: 5

Целочисленное деление здесь играет ключевую роль — оно позволяет найти середину диапазона, не используя дробные индексы.

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

Мастерство работы с целыми числами в Python — это не просто технический навык, а настоящий фундамент программирования. Изучив операции с типом int, вы получили ключ к решению множества практических задач: от простых вычислений до сложных алгоритмов. Помните: в мире Python нет ограничений на размер целых чисел, что открывает безграничные возможности для ваших проектов. Используйте эти знания как строительные блоки вашего развития как разработчика — и вы увидите, как прежде сложные задачи становятся элегантными решениями в вашем коде.

Читайте также

• Контекстные менеджеры в Python: элегантный способ управления ресурсами
• Python боты для начинающих: пошаговое создание и интеграция API
• Полный гид по справочникам Python: от новичка до мастера
• Разработка настольных приложений на Python: от идеи до готового продукта
• Python-автоматизация презентаций: 5 библиотек для создания слайдов
• Обработка текста в Python: ключевые методы работы со строками
• Python 3 для Linux: установка, настройка, решение проблем – гайд
• Функции с параметрами в Python: секретное оружие разработчика
• Примеры Python-кода: от основ до продвинутых техник с разбором
• Выбор языка программирования: где Python действительно выигрывает