Как преобразовать целое число (int) в число с плавающей точкой (float64) в Go?

Правильное преобразование int в float64 в Go

Проблема, с которой вы столкнулись, — классическая для начинающих Go-разработчиков. В Go нет неявного приведения типов, и деление двух целых чисел всегда даёт целый результат с отбрасыванием дробной части (усечение вниз). Чтобы получить дробный результат, нужно явно преобразовать каждый операнд в тип с плавающей точкой до операции деления.

Основное решение: приведение типов перед операцией

Вам нужно преобразовать оба числа (или хотя бы одно из них) в float64 до выполнения деления:

package main

import "fmt"

func main() {
    sum := 10   // int
    count := 3  // int

    // Преобразуем оба числа в float64 перед делением
    avg := float64(sum) / float64(count)
    fmt.Printf("Среднее: %.2f\n", avg) // Вывод: Среднее: 3.33
}

Почему это работает? Когда хотя бы один из операндов имеет тип float64, Go автоматически приводит второй операнд к этому же типу (неявное приведение для совместимых типов). Но в нашем случае мы явно преобразуем оба, чтобы избежать путаницы.

Распространённая ошибка: приведение результата

Многие новички пытаются сделать так:

avg := float64(sum / count) // Ошибка! Сначала выполняется целочисленное деление

Этот код сначала делит 10 / 3 как целые числа, получая 3, а затем преобразует 3 в float64(3.0). Результат — 3.0, а не 3.333.... Запомните правило: сначала приводите типы, потом выполняйте операцию.

Альтернативный подход: использование констант

Если вы работаете с литералами (конкретными числами в коде), можно сразу указать тип через константу:

avg := 10.0 / 3.0 // Go сам определит тип как float64
fmt.Println(avg) // 3.3333333333333335

Но для переменных это не сработает — нужно явное преобразование.

Работа с разными размерами float

В Go есть два типа с плавающей точкой: float32 и float64. Рекомендуется использовать float64, так как он обеспечивает бóльшую точность и совместимость со стандартной библиотекой (например, math).

var x int = 5
var y int = 2

// Преобразование в float32
result32 := float32(x) / float32(y) // 2.5

// Преобразование в float64
result64 := float64(x) / float64(y) // 2.5

// Нельзя смешивать float32 и float64 без явного приведения
// var z float64 = float64(x) / float32(y) // Ошибка компиляции!

Практический пример: функция для вычисления среднего

Вот как можно написать универсальную функцию для расчёта среднего:

package main

import "fmt"

// Average вычисляет среднее арифметическое для int-слайса
func Average(numbers []int) float64 {
    if len(numbers) == 0 {
        return 0.0
    }

    var sum int
    for _, n := range numbers {
        sum += n
    }

    // Преобразуем sum и длину в float64 перед делением
    return float64(sum) / float64(len(numbers))
}

func main() {
    scores := []int{8, 9, 7, 10, 6}
    avg := Average(scores)
    fmt.Printf("Средний балл: %.2f\n", avg) // 8.00
}

Ключевые правила для запоминания:

• Явное преобразование — используйте float64(variable) для int → float.
• Преобразуйте до операции, а не после.
• Не смешивайте типы в одном выражении без явного приведения.
• Используйте float64 как стандартный тип для чисел с плавающей точкой.

Теперь ваш калькулятор среднего будет работать корректно! Если появятся другие вопросы по типам в Go — спрашивайте.

package main

import (
    "fmt"
    "math"
)

func main() {
    sum := 10
    count := 3

    // Преобразуем в float64 и сразу округляем до 2 знаков
    avg := float64(sum) / float64(count)
    roundedAvg := math.Round(avg*100) / 100 // Округление до сотых
    fmt.Println(roundedAvg) // 3.33
}

avg := float64(sum) / float64(count)
fmt.Printf("%.2f\n", avg) // Печатает 3.33, но avg остаётся 3.333333...