Go数据类型（数字型）

Go中数字型数据类型大致分为整数（integer）、浮点数（floating point ）和复数（Complex）三种

整数重要概念

整数在Go和Python中有较大区别，主要体现在Go对整数的划分更细。Go中同时提供了有符号（signed）和无符号（unsigned）的整数类型，其中有符号整数按二进制位又可以分为int8（对应8bit大小的有符号整数），int16（对应16bit大小的有符号整数），int32（对应32bit大小的有符号整数），int64（对应64bit大小的有符号整数），以及int（与CPU相关）五种类型。无符号整数按二进制位又可以分为uint8, uint16, uint32, uint64以及uint五种类型。

根据二进制大小的不同，每种有符号整数和无符号整数类型所代表的整数范围也不尽相同，如下表所示：

• 有符号整数和无符号整数的最大的区别是前者支持负数，后者不支持。另外int这个整数类型我们在前面讲解变量时所举的例子中已经提及并使用过了，它的大小与所代表的整数范围和运行Go程序的机器的编译器和CPU相关（既可能是32bit也可能是64bit，uint同理）。实际开发中int类型的应用最为广泛，它既可用于数组和切片的索引，也可用于for循环中空值循环次数的计数器，而且一般来说int类型的处理速度也是最快的
• 除int和uint之外，还有一个大小及所代表的整数范围和编译器及CPU相关的整数数据类型叫做uintptr，它只在Go语言和C语言之间互动的底层编程中才会用到

整数使用举例

整数支持加减乘除、取模等操作，但前提是变量的整数类型必须一致，并且数字不能超出该类型的整数范围，举例如下：

func main() {
	var a, b int = 7, 2
	fmt.Println(a + b)
	fmt.Println(a - b)
	fmt.Println(a * b)
	fmt.Println(a / b)
}

注意Go中当两个整数不能整除时，只保留商数，因此7/2返回的值为3

如果变量的整数类型不一致，则系统会返回异常，举例如下：

func main() {
	var a int8 = 1
	var b uint8 = 1
	fmt.Println(a + b)
}

这里变量a的数据类型为int8，而b的数据类型为uint8，两者无法做任何运算。

如果数字超出了数据类型对应的整数范围，则系统也会返回异常，举例如下：

func main() {
	var a int8 = 256
	fmt.Println(a)
}

这里变量a的值256超出了int8对应的支持范围（-128到127）。

如果使用简短格式声明整数变量，则该整数变量的类型为int，大小视CPU的类型为32bits或者64bits。举例如下：

func main() {
	a := 10
	fmt.Printf("%T\n", a)
}

另外也可以使用整数类型相关的函数将一个类型的整数转换成另一个类型的整数，如下所示：

func main() {
	a := 10        //此时a为int类型的整数
	b := uint32(a) //将a转换为uint32类型的整数
	c := int8(a)   //将a转换为int8类型的整数
	fmt.Println(b, c)
	fmt.Printf("%T\n", a)
	fmt.Printf("%T\n", b)
	fmt.Printf("%T\n", c)
}

输出：

浮点数

浮点数用来表示带有小数点的数字，比如1.0，-45.332。在Go中浮点数分为float32和float64两种类型，两种类型代表了两种精度

float32 vs float64

float32类型的浮点数和float64类型的浮点数两者区别在于前者为单精度浮点数，可以提供约6个十进制数的精度，在内存中占用32个bits，而后者为双精度浮点数，可以提供约15个十进制数的精度，在内存中占用64个bits。

func main() {
	var f1 float32 = 16777216
	fmt.Println(f1 == f1+1)
	var f2 float64 = 16777216
	fmt.Println(f2 == f2+1)
}

输出：

这里我们用float32和float64分别创建了两个变量f1和f2，它们的值都为16777216（整数同样可以赋值给浮点数类型的变量），但是如果给它们各自加上1后再用==做判断，可以看到类型为float32的变量f1 == f1+1返回了布尔值true，类型为float64的变量f2 == f2+1返回了布尔值false。其原因是因为在IEEE 754标准中，32位的浮点数其构成为：

Value = (sign ? -1 : +1) * 2^exponent * (1.0 + mantissa)

• Value即为浮点数的值
• 1个bit用于符号位 (sign bit)，符号位用来判断判断正数或负数（+1表示正数，-1表示负数）
• 8个bit用于指数(exponent，带有-127的偏移)
• 23个bit用于尾数 (mantissa)

可以看到16777216对应的是224，如果用float32来表示的话：

• 符号位(sign bit) = +1 （表示正数）
• 指数 = 24 （保存在内存中的二进制为10010111，这个10010111是从24 + 127（指数偏移） = 151=10010111得来的）
• 尾数 = .0（即小数点后的小数为0）

因此Value = (+1) x 224 x (1.0 + .0) = 16777216

再来看16777217，也就是224+1：

• 符号位和指数不变
• 尾数必须为2-24，因为只有这样Value才会= (+1) x 224 x (1.0 + 2-24) = 16777217
• 但是因为尾数位只有23bit，因此用float32是无法表示16777217的。在float32中，16777217会以16777216表示，不会以16777218表示，这涉及到向最近的值舍入（round to nearest）的知识点，该知识点不在本书的讨论范围内。

由此可以看出float32能精确表示的正整数并不是很大，所以通常我们用float64来声明浮点数变量。不过使用float64也就意味着程序会占用更大的内存，在深度学习这种需要大使用数据集的领域，占用内存的多少会对系统运行效率有较为明显的影响。

整数和字符串互相转换

整数转换为字符串

整数转换为字符串大致有三种方法:

1. 使用string()
2. 使用strconv.ItoA()
3. 使用strconv.Format()

第一种使用string()的方法和后面两种使用strconv包的方法有本质上的区别。对整数使用string()函数的话，其返回的值不是字符串形式的整数，而是该整数对应的字符rune，举例如下：

func main() {
	num := 100
	fmt.Println(string(num))
}

输出：

可以看到对整数100使用string()并未将其转化为字符串形式的整数"100"，而是该整数对应的字符"d"。

然后编辑器里面已经明显的提示我需要使用哪个函数去实现转换了

如果你的目的是将一个整数转换为该整数的字符串形式，则需要使用strconv.ItoA()或者strconv.Format()，举例如下:

func main() {
	num := 100
	fmt.Println(strconv.Itoa(num))
	fmt.Println(strconv.FormatInt(int64(num), 10))
}

输出：

其中strconv.Itoa()函数里的Itoa是Integer to ASCII的缩写，

strconv包下的Itoa()是最简易也最常用的将整数转换为字符串的函数，推荐使用。

而与strconv.Itoa()相对应的则是strconv.Atoi()，即ASCII to Integer，表示将字符串转换为整数。

strconv.FormatInt()函数比较严格，要使用的话必须传入两个参数，

且第一个参数必须为int64的有符号整数，因为我们创建的变量的数据类型为int，不是int64，因此需要用int64(num)将其转化为int64才能作为合法的参数传入。

第二个参数为进制，这里的10表示十进制，如果想用十六进制表达的话，则将10改为16即可

字符串转换为整数：

字符串转换为整数大致两种方法，除了前面提到的strconv.Atoi()外，也可以用strconv.ParseInt()来完成。

先举例讲讲strconv.Atoi()

func main() {
	str := "100"
	fmt.Println(strconv.Atoi(str))
}

输出：

这里可以看到，对字符串变量str使用strconv.Atoi()后，返回的值为100 <nil>，为什么会有两个值？这是因为strconv.Atoi()函数本身默认会返回两个值，第一个值的数据类型为整数，第二个值的数据类型为error，我在讲字符串一章中提到了错误类型在Go中也属于一种数据类型，如果调用该函数时存在错误的话，比如被strconv.Atoi()转换的数据为非字符串，那么strconv.Atoi()会返回具体的错误类型，如果函数运行后不存在错误的话，则返回nil。在Go中类似strconv.Atoi()这种同时返回两种值（一种为函数本身因返回的值，另一种为错误类型的值）的函数还有很多

再看一下strconv.Atoi()的语法：

再来看strconv.ParseInt()的使用：

func main() {
	str := "100"
	fmt.Println(strconv.ParseInt(str, 10, 64))
}

输出：

可以看到，strconv.ParseInt()需要传入三个参数，

一个参数为要被转换为整数的字符串，

第二个参数为进制，这里的10代表十进制，

第三个参数代表的是bitSize, 其作用是用来指定我们想将字符串转换为哪类的有符号整数类型，其取值范围为0，8，16，32，64，分别表示int, int8， int16，int32和int64。

Strconv.FormatInt()和strconv.ParseInt()功能比较强大，但是使用起来稍微有些繁琐，明显strconv.Itoa()和strconv.Atoi()更易用。实际上strconv.Itoa()和strconv.Atoi()其实分别调用了strconv.Format()和strconv.ParseInt()，是后两者的简化版

另外Format和Parse其实是两组相反的方法，除了strconv.FormatInt()和strconv.ParseInt()外还有如下很多种类似的函数：

Format组：

FormatBool()

FormatFloat()

FormatInt()

FormatUint()

Parse组：

ParseBool()

ParseFloat()

ParseInt()

ParseUint()

总体来说，Format组是将其他数据类型转变成字符串，而Parse组是将字符串转为其他数据类型。

转载至：网络工程师的Golang之路 -- Go数据类型（数字型） - 知乎 (zhihu.com)