Квадратный корень в Python: функция sqrt() и другие способы

math.sqrt(x) — это функция модуля math в Python, которая возвращает квадратный корень числа x в виде значения типа float. Принимает только неотрицательные числа, а при передаче отрицательного аргумента возникает ошибка ValueError.

Это если говорить языком официальной документации. А если говорить по-человечески: рано или поздно в любом проекте на Python — от расчета геопозиции курьера до алгоритмов машинного обучения — вам понадобится извлечь корень. 

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

Что такое функция sqrt() в Python

Ответ кроется в самом названии. Это сокращение от английского square root — квадратный корень.

В самом базовом наборе команд Питона этой функции нет — и чтобы она появилась, нужно позвать на помощь модуль math. Это встроенная в язык папка со стандартными математическими формулами. То есть вы как бы говорите Питону: «Подключи мне математику», и дальше получаете доступ к десяткам полезных инструментов.

Определение и синтаксис math.sqrt()

Писать код с этой функцией очень просто: сначала импортируете модуль math, потом вызываете функцию sqrt и передаёте в скобках одно число.

import math
math.sqrt(x)

Но тут есть важный нюанс, который нужно запомнить:

math.sqrt(x) всегда возвращает float, даже если результат является целым числом: то есть, math.sqrt(4) возвращает 2.0, а не 2. Это принципиально отличает её от оператора **, который сохраняет тип при целочисленном входе.

Поясним: float — это просто дробное число, то есть число с точкой. Если вы попросите корень из 25, Питон отдаст вам не целую пятёрку (тип int), а 5.0. Об это часто ломаются дальнейшие проверки в коде, если вы ожидаете строго целое число без точки.

Как импортировать и использовать math.sqrt()

В самом начале вашего файла нужно написать import math — так мы вызываем нужный модуль и можем дальше производить математические операции:

import math
# Передаем целое число в скобках
result = math.sqrt(25)
print(result)

# Передаем дробное число
print(math.sqrt(9.0))

Как видите, какое число мы бы не подавали на вход, в результате мы всегда получаем вывод с точкой — float.

Ошибки: отрицательные числа и ValueError

Из обычной школьной математики мы знаем, что в рамках действительных чисел нельзя извлечь квадратный корень из отрицательного числа.

Если вы в питоновском коде случайно отдадите функции отрицательное число, например, баланс пользователя ушёл в минус, то интерпретатор уронит вашу программу с ошибкой ValueError: math domain error.

Посмотрим на примере:

import math
balance = -16
print(math.sqrt(balance)) 

Официальная документация объясняет это так: да, в высшей математике есть комплéксные числа, и корень из отрицательного числа извлечь можно. Но 99% обычных разработчиков их не знают и знать не хотят. Если функция упадёт с ошибкой, разработчик сразу увидит, что в его формулы прилетел неожиданный минус, и быстро поправит баг в логике.

Если же вы хардкорный математик и вам реально нужен корень из отрицательного числа, то создатели Питона сделали для вас отдельный модуль — cmath (Complex Math). Там та же самая функция cmath.sqrt(-16) вернёт вам комплексное число 4j без ошибок.

Таким образом запоминаем: 

Способ 2: оператор ** (возведение в степень 0.5)

Извлечь квадратный корень из числа — это математически то же самое, что и возвести это число в дробную степень 1/2 (или 0.5). Для этого в Питоне есть встроенный арифметический оператор.

Синтаксис и пример

В Python для возведения в степень используется оператор двойная звёздочка **. Запись a ** b буквально означает «число a в степени b».

Поэтому, если на собеседовании вас спросят, как извлечь корень в Питоне без подключения сторонних модулей, смело пишите дробную степень:

number = 25
# Возводим в степень 0.5 (она же 1/2)
result = number ** 0.5
print(result) 

Питон под капотом отлично поддерживает смешанную арифметику — вы можете передавать туда целые числа (int), числа с точкой (float) и даже нули. По правилам математики, если возвести ноль в любую степень — будет 0.

# Кубический корень
print(27 ** (1/3))
# Нули
print(0 ** 0.5) 
print(0 ** 5) 

Плюсы и ограничения оператора **

Главный плюс очевиден — лаконичность. Всё работает на чистом базовом синтаксисе, и импорты не нужны.

А вот теперь интересная штука, о которой не все знают. В прошлом разделе мы говорили, что math.sqrt(-16) выдаст вам ошибку ValueError. А вот оператор ** вернет вам комплéксное число, если результат невозможно представить в виде действительного числа:

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

Ограничения у этого способа два:

Способ 3: встроенная функция pow()

Если же коварный интервьюер снова попросит вас извлечь корень без импорта математических модулей и даже без использования оператора **, то есть ещё один способ — функция pow().

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

Допустим, нам нужно извлечь квадратный корень из 25:

number = 25
# Передаем число и степень 0.5
result = pow(number, 0.5)
print(result) 

pow(x, y) под капотом работает как конструкция x ** y. У этой функции есть мощнейшее применение в криптографии — туда можно передать третий аргумент для хитрого вычисления остатка от деления — pow(x, y, z), но дробных степеней это не касается.

Использовать pow(x, 0.5) в реальном продакшен-коде — это вкусовщина и редкость. Как правило, разработчики предпочитают либо читаемый math.sqrt(), либо суперкороткий ** 0.5. Но знать про эту функцию нужно, чтобы уверенно читать чужой код.

Способ 4: numpy.sqrt() для массивов и DataFrame

А теперь подключим тяжёлую артиллерию — библиотеку NumPy. Если вам нужно извлечь квадратный корень в Python сразу из миллиона чисел, колонки в базе данных или серии в Pandas DataFrame, то встроенный модуль math вам не поможет.

Для массовых вычислений используется векторизованная функция numpy.sqrt().

# Подключаем библиотеку NumPy
import numpy as np
# Создаем numpy-массив из обычного списка
numbers = np.array([4, 9, 16, 25])
# Векторизация: вычисление применяется сразу ко всем элементам
result = np.sqrt(numbers)
print(result)

Библиотека NumPy под капотом написана на языке C. Когда вы отдаете ей массив, она применяет вычисления ко всему блоку памяти в процессоре разом, а не перебирает его элементы медленным питоновским циклом. За счёт этого производительность возрастает в десятки, а то и в сотни раз по сравнению с обычным math.sqrt() внутри цикла for. 

Ровно по такому же принципу это работает и с датафреймами в библиотеке Pandas: вы просто передаёте в np.sqrt() всю колонку с данными и сразу же получаете новую колонку с извлечёнными корнями. 

Кубический корень и корень n-й степени

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

Кубический корень через ** (1/3)

Для извлечения кубического корня используют конструкцию x ** (1/3), а для корня произвольной степени n — x ** (1.0/n) или pow(x, 1.0/n). Функция math.sqrt() для этих задач не подходит: она вычисляет только квадратный корень.

В коде это выглядит так:

x = 27
# Возводим в степень 1/3 (кубический корень)
result = x ** (1/3)
print(result) 

Начиная с версии Python 3.11, в язык наконец-то завезли официальную встроенную функцию math.cbrt(x) (от cube root). У неё есть критическое преимущество перед оператором **: если вы попытаетесь извлечь кубический корень из отрицательного числа через степень (-27) ** (1/3), то Питон вернёт вам страшное комплексное число:

А вот вызов math.cbrt(-27) вернёт -3.0:

math.cbrt() специально реализован как реальный кубический корень, поэтому корректно обрабатывает отрицательные числа.

Корень n-й степени: общая формула

А что делать, если нужен корень 4-й, 5-й или 100-й степени? Применяем ту же самую логику возведения в дробную степень. Корень n-й степени — это просто число, возведённое в 1/n.

x = 16
n = 4
# Корень 4-й степени
root_n = x ** (1/n)
print(root_n) 

Здесь важно помнить про приоритет операций — поэтому никогда не забывайте скобки вокруг дроби (1/n)! 

Если вы напишете код без скобок: x ** 1 / n, интерпретатор Питона сначала возведёт x в первую степень и получит тот же самый x, а потом просто поделит его на n. И вы будете часами разбираться, почему ваши математические модели выдают бред.

Сравнение способов: когда что использовать

Давайте подытожим: если вы сомневаетесь, как сделать корень в Питоне, воспользуйтесь этой шпаргалкой:

Практические примеры

Дальше посмотрим, как sqrt в Python применяется в реальных задачах.

Пример 1 — sqrt() для вычисления расстояния между точками

Типичная задача из геймдева или геолокации. У вас есть декартовы координаты двух объектов на карте, и нужно найти расстояние между ними по прямой: по теореме Пифагора — это гипотенуза.

import math
x1, y1 = 0, 0
x2, y2 = 3, 4
# Формула: корень из суммы квадратов разностей координат
distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
print(distance) 

Лайфхак: для этой конкретной задачи в Питоне уже есть готовая функция math.hypot(), которая считает то же самое быстрее!

print(math.hypot(x2 – x1, y2 – y1))

Пример 2 — корень из элементов списка через numpy

К вам по API прилетел огромный массив данных, и нужно извлечь корень из каждого элемента. Цикл for снизит производительность, поэтому берём NumPy.

import numpy as np
# Допустим, здесь 100 000 элементов
data =[16, 25, 36, 49]
np_array = np.array(data)
# Одной строкой, без циклов, обрабатываем весь массив
result = np.sqrt(np_array)
print(result) 

Пример 3 — безопасное извлечение корня (try/except)

Вы не контролируете данные, которые вводит пользователь — и он может случайно ввести число с минусом. Чтобы скрипт не упал с ошибкой ValueError, мы оборачиваем вызов в блок try/except.

import math
def get_safe_sqrt(number):
    try:
        return math.sqrt(number)
    except ValueError:
        # Перехватываем падение и отдаем заглушку или пишем лог
        print("Ошибка: попытка извлечь корень из отрицательного числа!")
        return None
# Скрипт не упадёт, выведет текст ошибки и None
print(get_safe_sqrt(-100)) 

Пример 4 — кубический корень отрицательного числа через cbrt

Нам нужно найти корень третьей степени из -8. Если мы используем оператор **, получим бесполезное для нас комплексное число. Поэтому используем метод cbrt().

import math
# Плохой способ:
print((-8) ** (1/3)) 

# Хороший способ (начиная с Python 3.11):
print(math.cbrt(-8)) 

Пример 5 — сравнение скорости ** vs math.sqrt()

Почему мы всё-таки тащим импорт math, когда можно просто написать ** 0.5? 

Ответ кроется в производительности. Возьмём встроенный модуль timeit и замерим, как быстро Питон выполнит эти операции миллион раз подряд:

import math
import time
x = 25
# Функция math.sqrt()
start = time.time()
for _ in range(1_000_000):
    math.sqrt(x)
print("math.sqrt:", time.time() - start)
# Оператор **
start = time.time()
for _ in range(1_000_000):
    x ** 0.5
print("**:", time.time() - start)

В большинстве случаев math.sqrt() работает немного быстрее и стабильнее, потому что это специализированная функция, заточенная под одну задачу. Оператор ** более универсальный — он умеет не только корни, но и любые степени, поэтому внутри чуть более тяжёловесный.

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

Типичные ошибки при извлечении корня в Python

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

Забытый import math — самая банальная ошибка. Поскольку функция sqrt не встроена в базовый синтаксис, то при попытке написать sqrt(25) без импорта модуля и префикса math., интерпретатор выдаст ошибку NameError: name ‘sqrt’ is not defined.

ValueError на ровном месте. Вы не обернули вычисления в try/except и отдали функции отрицательное число из базы данных. Скрипт падает, пользователи видят 500-ю ошибку. Всегда валидируйте данные перед математическими вычислениями.

Комплéксные мутанты. Вы вы вдруг вместо math.sqrt() решили использовать ** 0.5 для отрицательного числа, то код не упадет, но в базу данных запишется криповое комплексное число, которое сломает всю дальнейшую типизацию на бэкенде.

Теперь вы знаете, что для обычного извлечения корня в Питоне есть целых четыре пути. Для повседневных задач берите надёжный math.sqrt(). Если не хочется делать импорты — используйте ** 0.5. А если у вас аналитика и датафреймы на миллионы строк — то расчехляйте numpy.sqrt().

Советуем дополнительно по теме: 

Бонус для читателей

Если вам интересно погрузиться в мир ИТ и при этом немного сэкономить, держите наш промокод на курсы Практикума. Он даст вам скидку при оплате, поможет с льготной ипотекой и даст безлимит на маркетплейсах. Ладно, окей, это просто скидка, без остального, но хорошая.