您可以使用fmt.Sprintf("%08b", ...)看到位的可视化表示，正如其他人已经建议的那样。
但是，如果您想在操作中使用位，例如计算汉明距离，则需要使用按位运算符。
为了计算一个字节的第n位，你需要用另一个字节bitwise AND这个字节，这个字节的第n位设置为1，其余的设置为0（也就是掩码）。换句话说，这个字节（掩码）是2n-1。
例如，要找到数字13（00001101）的第一位，我们必须用20 = 1（0000001）来掩码它。我们将对两个数字执行逐位AND的输出与掩码进行比较。如果它们相等，则意味着第n位是1，否则是0。我们继续这样做，并找到所有的位。如Go代码所示：

fmt.Print(13 & 1) // Output: 1 -> 1
fmt.Print(13 & 2) // Output: 0 -> 0
fmt.Print(13 & 4) // Output: 4 -> 1
fmt.Print(13 & 8) // Output: 8 -> 1
// Not necessary to continue, but shown for the sake of the example
fmt.Print(13 & 16) // Output: 0 -> 0
fmt.Print(13 & 32) // Output: 0 -> 0
fmt.Print(13 & 64) // Output: 0 -> 0
fmt.Print(13 & 128) // Output: 0 -> 0

字符串
因此，13在二进制中是00001101。
下面是我最近写的一个函数，用于计算两个字节数组之间的汉明距离

func hamming(a, b []byte) (int, error) {
    if len(a) != len(b) {
        return 0, errors.New("a b are not the same length")
    }

    diff := 0
    for i := 0; i < len(a); i++ {
        b1 := a[i]
        b2 := b[i]
        for j := 0; j < 8; j++ {
            mask := byte(1 << uint(j))
            if (b1 & mask) != (b2 & mask) {
                diff++
            }
        }
    }
    return diff, nil
}

型
Go Playground：https://play.golang.org/p/O1EGdzDYAn

fmt.Sprintf（“%08b”，byte（1））是个好主意。它向你展示了数字是如何在内部存储的。计算汉明距离的例子（很无聊）可以是：

package main

import (
    "fmt"
)

func HamDist(n1,n2 uint8) uint8 {
    var w uint8 = 0
    if n1&1 != n2&1 {
        w++
    }
    if n1&2 != n2&2 {
        w++
    }
    if n1&4 != n2&4 {
        w++
    }
    if n1&8 != n2&8 {
        w++
    }
    if n1&16 != n2&16 {
        w++
    }
    if n1&32 != n2&32 {
        w++
    }
    if n1&64 != n2&64 {
        w++
    }
    if n1&128 != n2&128 {
        w++
    }
    return w
}

func main() {
    fmt.Println(HamDist(255,0))
}

字符串
现在你的任务是：
1.使用循环重写代码
1.计算16位数汉明距离的扩展程序
1.如果你定义了一个计算汉明权重的函数，请想想xor运算符是做什么的，是否应该更容易计算汉明距离。

import "math/bits"

bits.OnesCount8(byte(0) ^ byte(255))

字符串

您可以简单地执行以下操作：

fmt.Printf("%08b", YourNumber)

字符串
您也可以使用%016b或%032b或任何其他。

这里有一些很好的答案，但是另一种计算两个字节之间的汉明距离的方法是对它们进行XOR，然后计算1的数量（权重）。我所知道的计算1的最简单方法是得到最后一位，用1屏蔽它，然后向右移位。
下面是我用golang写的一个函数，用来计算两个字符串之间的汉明距离。

func HammingDistance(s1, s2 string) (int, error) {
    if len(s1) != len(s2) {
        return 0, fmt.Errorf("Hamming distance of strings of different lengths %d and %d", len(s1), len(s2))
    }
    b1 := []byte(s1)
    b2 := []byte(s2)
    distance := 0
    for i := range b1 {
        xored := b1[i] ^ b2[i]
        for j := 0; j < 8; j++ {
            distance += int(xored & 1)
            xored = xored >> 1
        }
    }
    return distance, nil
}

字符串
要计算两个字节的汉明距离，你只需要内部的for循环。