人们都在说Go＝C＋Python，有必要先学个入门再说对不对

都在说Go＝C＋Python，有必要先学个入门再说对不对"/>

人们都在说Go＝C＋Python，有必要先学个入门再说对不对

本月10日是Go语言发布12周年的纪念日，之前也没有去关注过它；后来听人们都在说 Go = C + Python，还和区块链技术搭界，所以感觉到很有必要去了解了解。

今天是Go语言12周年生日，装一个开始Go语言之旅吧——_汉阳Hann's Home-CSDN博客Go语言的生日12年前的“今天”→ 2009.11.10，Go 语言以开源方式向全球发布！简介Go 语言又称 Golang，是谷歌（Google）开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。Go语言有时被描述为“C 类似语言”，或者是“21 世纪的C语言”。Go从C语言继承了相似的表达式语法、控制流结构、基础数据类型、调用参数传值、指针等很多思想，还有C语言一直所看中的编译后机器码的运行效率以及和现有操作系统的无缝适配。与 C++ 相比，Go 并不包括如枚举、异，这次网上搜到一款开源、跨平台的轻量级Go语言集成开发环境（LiteIDE），据说是国人开发的 Google Go 语言的一个开发工具。

目录

Go语言开发工具LiteIDE的安装

下载

安装

运行

界面

LiteIDE的使用

hello world

解读

执行

Go语法基础入门

输出 Print

注释

标识符、关键字

数据类型

布尔型

数字型

变量声明

字符型

字符串类型

派生类型

零值 nil

常量

运算符

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

其他运算符

控制语句

条件语句

开关语句(选择、分支)

fallthrough

循环语句

循环实例 

continue语句

break 语句

goto 语句

“容器”类型

数组（列表）、切片（Slice）

范围（Range）

Map（集合）

函数 func

函数定义

函数调用

多个返回值

递归函数

递归实例

字面函数（内联函数、函数嵌套）

内置函数

常用包

time包

常量

实例 

math包

常量

极值 

常用数学函数

实例

参考内容

---

Go语言开发工具LiteIDE的安装

下载

下载网址： .html 

网上多数讲的下载地址，已失链：

下载成功得到一个压缩包： liteidex37.4.qt4.8.5.zip

安装

压缩包中有两个文件夹： liteide、liteide_win64

根据你安装的Go版本是32位还64位选择对应的文件夹释放到Go安装文件夹下，我的安装在文件夹： d:\go。

运行

然后在D:\Go\liteide\bin里找到 liteide.exe，双击运行。右键点击在任务栏里的“八卦”图标，把它锁定在任务里，或者创建一个桌面快捷方式也可以。

界面

我安装的是X37.4版本：

LiteIDE的使用

文件菜单中“新建”，或者快捷键Ctrl+N新建一个代码，复制以下代码段框中的几行代码，另存为一个源文件helloworld.go。

hello world

万能的hello world，不管学什么语言总要遇到它

package mainimport "fmt"func main() {fmt.Println("hello world")
}

解读

1. package main

每个Go源代码文件的开头都是一个package声明，表示该Go代码所属的包。

包是Go语言里最基本的分发单位，也是工程管理中依赖关系的体现。

要生成Go可执行程序，必须建立一个名字为main的包。

2. import "fmt"

在包声明之后是import语句，用于导入该程序所依赖的包。

和python一样用import导入，但库名要用引号包括；类似C/C++的include语句。

3. func main()

包main中必须包含一个名为main()的函数（Go可执行程序的执行起点）。

Go语言的main()函数不能带参数，也不能定义返回值。

命令行传入的参数在os.Args变量中保存，如果需要支持命令行开关，可使用flag包。

4. fmt.Println("hello world")

Println()函数，需要导入该函数所属的fmt包。

执行

编译菜单中FileRun，或者使用快捷键 Alt+F6或Alt+Shift+R。

由fmt.Println()输出： hello world。

Go语法基础入门

输出 Print

三种基本形式：带换行、不带换行、使用格式符

fmt.Println("string")
fmt.Print("string")
fmt.Printf("Name: %s, Age: %d\n", "Hann", 48)

与python对比：内置函数不用导入包

print('string')
print('string', end='') 
print('Name: %s, Age: %d'%('Hann',48))#python 另有两种方法：
print('Name: {}, Age: {}'.format('Hann', 48))
name,age = 'Hann',48
print(f'Name: {name}, Age: {age}')

注释

与C/C++相同，使用 // 或 /*  */

// 单行注释/* 多行注释
*/

Python 则使用井号 # 或者三连引号 """ ... """ 、 ''' ... '''

标识符、关键字

标识符用来命名变量、类型等程序实体。一个标识符实际上就是一个或是多个字母(A~Z和a~z)数字(0~9)、下划线_组成的序列，但是第一个字符必须是字母或下划线而不能是数字。

这些规则，基本上所有语言都是如此。

Go 语言有 25 个关键字（或称为保留字）：

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

Go 语言有 36 个预定义标识符：

append	bool	byte	cap	close	complex
complex64	complex128	copy	false	float32	float64
imag	int	int8	int16	int32	int64
iota	len	make	new	nil	panic
print	println	real	recover	string	true
uint	uint8	uint16	uint32	uint64	uintptr

Python 只有30来个关键字，上表的标识符也有类似的但没有这么多类型标识符。

程序一般由关键字、常量、变量、运算符、类型和函数组成。

数据类型

布尔型

布尔型的值只可以是常量 true 或者 false，字母全部小写，其格式化符：%t。

Go和Python都是大小写敏感的编程语言，Python使用的布尔值首字母要大写。

数字型

#有符号整数
int8（-128 -> 127）
int16（-32768 -> 32767）
int32（-2,147,483,648 -> 2,147,483,647）
int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

#无符号整数
uint8（0 -> 255）
uint16（0 -> 65,535）
uint32（0 -> 4,294,967,295）
uint64（0 -> 18,446,744,073,709,551,615）

#浮点型
float32（IEEE-754 32位浮点型数）
float64（IEEE-754 64位浮点型数）
#无float类型

#复数，格式化符：%v
Go 拥有以下复数类型：
complex64 (32 位实数和虚数)
complex128 (64 位实数和虚数)

复数与python基本相同，只是两者的虚数单位不同，Go用的是 i ，python用的是 j 。

Go语言的数字类型比较接近C/C++，不如Python只有int, float, complex来的方便。

变量声明

Go语言引入关键字var，而类型信息放在变量名之后，示例如下：

var v1 int
var v2 string
var v3 [10]int // 数组
var v4 []int // 数组切片var c1 complex64 = 3 + 23i
fmt.Printf("The value is: %v", c1)  // 输出： 3 + 23i//函数内部可以隐式声明变量，使用 := ，不需要var 和 类型
InternalVariable := 6

这一点比Python严格，Python直接赋值即声明，没有声明关键字，且不强制要指定类型。

1）整型的零值为 0，浮点型的零值为 0.0。
2）int 和 uint 在 32 位操作系统上均使用4字节，在 64 位操作系统上均使用8字节。
3）uintptr 的长度被设定为足够存放一个指针即可。
4）整型的零值为 0，浮点型的零值为 0.0。
5）int 型是计算最快的一种类型。
6）尽可能地使用 float64，因为 math 包中所有有关数学运算的函数都会要求接收这个类型。
7）Go 是强类型语言，不会进行隐式转换.。所以Go 中不允许不同类型之间的混合使用，但允许常量之间的混合使用。

字符型

字符不是 Go 语言的一个类型，字符只是整数的特殊用例：
1）byte 类型是 uint8的别名：

var ch byte = 'A' 
var ch byte = 65
var ch byte = '\x41'  // \x 总是紧跟着长度为 2 的 16 进制数
/* 以上三行代码等价 */

2） rune 是 int32 的别名。
Unicode 至少占用 2 个字节，所以Go使用 int16 或者 int 类型来表示。如果需要使用到 4 字节，则会加上 \U 前缀；前缀 \u 则总是紧跟着长度为 4 的 16 进制数，前缀 \U紧跟着长度为 8 的 16 进制数。

var ch int = '\u0041'
var ch2 int = '\u03B2'
var ch3 int = '\U00101234'
fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer
fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character
fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes
fmt.Printf("%U - %U - %U", ch, ch2, ch3) // UTF-8 code point

对Python来说也没字符类型一说，它可以看作长度为1的字符串。 

字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

1）字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）
2）字符串在Go语言内存模型中用一个2字长的数据结构表示。它包含一个指向字符串存储数据的指针和一个长度数据。

派生类型

(a) 指针类型（Pointer）
(b) 数组类型
(c) 结构类型 （struct）
(d) Channel 类型
(e) 函数类型
(f) 切片类型
(g) 接口类型（interface）
(h) Map 类型 

这些类型大多是python所没有的，可以找到数组、结构、函数、切片、Map等相近的用法。

零值 nil

Go任何类型在未初始化时都对应一个零值：布尔类型是false，整型是0，字符串是""，而指针，函数，interface，slice，channel和map的零值都是nil。
可以把 nil 看作相当于Python的None。

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式： const identifier [type] = value
可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

Python没有常量关键字const的，就是不能被重定义的或值不变的“变量”。

运算符

运算符用于在程序运行时执行数学或逻辑运算。Go 语言内置的运算符有：

算术运算符

+、-、*、/ 、% 加减乘除、取余

++、-- 有和C/C++一样的自增减运算，但只有后增后减，没先自增先自减；
即只有 i++, j--；没有++i, --j；且不能有自增后赋值： a=i++，这是不允许的。

也没有Python的整除//，和C/C++一样用数据类型来分辨这“两种”运算。

package main
import "fmt"func main() {fmt.Printf("%d", 5/2)fmt.Println()fmt.Printf("%f", 5/2.0)
}/*
2
2.500000
*/

关系运算符

==、!=、>、<、>=、<=  这些和Python的都相同。

逻辑运算符

&&、||、!  对应Python的 and、 or、 not 运算。

位运算符

&、|、^ 、<<、>> 和Python相同：“与、或、异或”及左、右位移。

按位取反运算： Go直接用^符号，Python则用~符号。

即： Go语言中，^ 作一元运算符时即按位取反，作二元运算符时即按位异或。

Go语言还特有一个“与非”运算： &^，相当于与运算和非运算的“连写”。

赋值运算符

=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|= 差不多的，略。

其他运算符

*a    指针变量a
&a    返回变量a的存储地址

这两个运算和C/C++中的用法相同，Python是没有指针的。

控制语句

条件语句

if 语句：

package mainimport "fmt"func main() {var a int = 3if a < 23 {fmt.Printf("a 小于 23\n")}fmt.Printf("a 的值为 : %d\n", a)
}

if-else语句：

if 布尔表达式 {/* 在布尔表达式为 true 时执行 */
} else {  /* 在布尔表达式为 false 时执行 */
}

if- else if-else语句:

package mainimport "fmt"func main() {var age int = 23if age == 25 {fmt.Println("true")} else if age < 25 {fmt.Println("too small")} else {fmt.Println("too big")}
}

Go的条件语句中else 位置不能新起一行，必须紧跟在右括号后面。

与Python对比，else要另起一行，且Python有关键字elif：

a = 3
if a<23:
        ......

if a<23:
        ......
else:
        ......

if a<5:
        ......
elif a<10:
        ......
else:
        ......

注意：Go没有三目操作符a=b>c?b:c，Python中即 a=b if b>c else c。

开关语句(选择、分支)

switch-case-default语句：

switch var1 {case val1:...case val2:...default:...
}

package mainimport "fmt"func main() {var grade string = ""var marks int = 65switch marks / 10 {case 9, 10:grade = "A"case 8:grade = "B"case 6, 7:grade = "C"default:grade = "D"}fmt.Printf("你的等级是 %s\n", grade)
}

Python最新版本3.10.0才开始启用 match - case 开关语句，之前的版本只能使用 if... elif... elif... elif... else... 代替。 

相对于C/C++分支结构中，Go语言不支持如下像C/C++一样的写法：

package mainimport "fmt"func main() {var grade string = "未定义"var marks int = 65switch marks / 10 {case 9:case 10:grade = "A"case 8:grade = "B"case 6:case 7:grade = "C"default:grade = "D"}fmt.Printf("你的等级是 %s\n", grade)
}/* Out:
你的等级是 未定义
*/

fallthrough

使用fallthrough就可以解决程序要依次执行多个case代码的问题。

package mainimport "fmt"func main() {var grade string = "未定义"var marks int = 92switch marks / 10 {case 9:fallthroughcase 10:grade = "A"case 8:grade = "B"case 6:fallthroughcase 7:grade = "C"default:grade = "D"}fmt.Printf("你的等级是 %s\n", grade)
}

另外Go还有一种开关结构语句，因为要用到新类型channel，保留暂时先不讨论：

select-case-default语句

select {case clause1:statement(s1)case clsuse2:statement(s2)default:statement(s3)
}

循环语句

Go 只有for循环语句，没有while语句。但比Python有更多种形态：

和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

和 Python 的 for i in range(n)差不多：
这种格式可以对字符串、数组、切片等进行迭代输出元素。

for key, value := range oldMap {newMap[key] = value
}

循环实例 

 实例1:累加1+2+3+...+100

package mainimport "fmt"func main() {sum := 0for i := 0; i <= 100; i++ {sum += i}fmt.Println(sum)// 以下写法就和 While 形式一样，只是关键字没换而已sum = 0i := 1for i <= 100 {sum += ii++}fmt.Println(sum)}

 实例2:100以内的素数

package mainimport "fmt"func main() {// var prime,c int   //定义变量不使用也会报错var prime intvar flag boolprime = 1//while(prime<100) {  //Go语言没有whilefor prime < 100 { //这种形式就似while语句，没用这个关键字而已prime++flag = truefor tmp := 2; tmp < prime; tmp++ {if prime%tmp == 0 {flag = false}}if flag == true {fmt.Println(prime, "是素数")}}
}/*
2 是素数
3 是素数
5 是素数
7 是素数
11 是素数
13 是素数
17 是素数
19 是素数
23 是素数
29 是素数
31 是素数
37 是素数
41 是素数
43 是素数
47 是素数
53 是素数
59 是素数
61 是素数
67 是素数
71 是素数
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数
*/

continue语句

continue 忽略当前循环体内的剩下代码，提前进入下一轮循环。
用法与Python及其它语言的完全相同，略。

break 语句

break 可以提前退出当前循环，用法与Python及其它语言的基本相同；
但是Go语言中用个跳转到指定标签的功能，可以同时跳出多层循环。

注：标签一定要放在循环之前，如下示例：

package mainimport "fmt"func main() {count := 1
Label1:for {count++for {break Label1count++}}fmt.Println(count) // Out: 2
}

goto 语句

goto 可以无条件地转移到过程中指定的行（指定标签所在行之后）

注：大多数程序员都不待见这个goto语句，结构化程序设计中一般不主张使用goto语句。
比如，从主程序跳入子程序是绝对禁止的，或者从循环、结构等外部直接跳转到其内部。

Python 语言中没用goto语句，省得有了乱来瞎用。
 

“容器”类型

数组（列表）、切片（Slice）

package mainimport "fmt"func main() {// initialized arrayvar numbers [5]int // becomes [0, 0, 0, 0, 0]// change one of themnumbers[2] = 100// create a new slice from an arraysome_numbers := numbers[1:3]fmt.Println(some_numbers) // [0, 100]// length of itfmt.Println(len(numbers))// initialize a slicevar scores []float64scores = append(scores, 1.1) // recreate to appendscores[0] = 2.2              // change your mindfmt.Println(scores)          // prints [2.2]// when you don't know for sure how much you're going// to put in it, one way is tovar things [100]stringthings[0] = "Peter"things[1] = "Anders"fmt.Println(len(things)) // 100
}

对比Python： 

# initialize list
numbers = [0] * 5
# change one of them
numbers[2] = 100
some_numbers = numbers[1:3]
print(some_numbers)  # [0, 100]
# length of it
print(len(numbers))  # 5# initialize another
scores = []
scores.append(1.1)
scores[0] = 2.2
print(scores)  # [2.2]

范围（Range）

package main
import "fmt"func main() {names := []string{"Hann","Yang","Hann Yang",}for i, name := range names {fmt.Printf("%d. %s\n", i+1, name)}
}

对比Python： 

names = ["Hann", "Yang", "Hann Yang"]
for i,name in enumerate(names):
    print(f'{i+1}. {name}')

Map（集合）

package mainimport "fmt"func main() {elements := make(map[string]int)elements["H"] = 1fmt.Println(elements["H"])// remove by keyelements["O"] = 8delete(elements, "O")// only do something with a element if it's in the mapif number, ok := elements["O"]; ok {fmt.Println(number) // won't be printed}if number, ok := elements["H"]; ok {fmt.Println(number) // 1}}

对比Python： 

elements = {}
elements["H"] = 1
print(elements["H"])  # 1# remove by key
elements["O"] = 8
elements.pop("O")# do something depending on the being there
if "O" in elements:print(elements["O"])
if "H" in elements:print(elements["H"])

函数 func

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

函数定义

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {函数体
}

定义解析：

• func：函数由 func 开始声明
• function_name：函数名称，参数列表和返回值类型构成了函数签名。
• parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
• return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
• 函数体：函数定义的代码集合。

Go的函数用func起头，函数体和C/C++一样用{}包括代码，但代码语句不用“ ; ”表示结束。

与Python的比较：def funcname(): 起头的关键字不一样，python不用{}括号但要用“ : ”；以及有强制而严格的缩进。

函数调用

当创建函数时，定义的函数需要做什么，通过调用该函数来执行指定任务。

调用函数，可以向函数传递参数，并返回值：

package mainimport "fmt"func main() {/* 定义局部变量 */var a int = 100var b int = 200var ret int/* 调用函数并返回最大值 */ret = max(a, b)fmt.Printf( "最大值是 : %d\n", ret )
}/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {/* 定义局部变量 */var result intif (num1 > num2) {result = num1} else {result = num2}return result
}

对比Python： 

def Max(n1,n2):
    if n1>n2:
        return n1
    return n2

a,b = 100,200
print(Max(a,b))

多个返回值

package mainimport "fmt"func swap(x, y int) (int, int) {return y, x
}func main() {a, b := swap(3, 23)fmt.Println(a, b)
}

对比Python： 即返回值是一个元组tuple()

def Swap(n1,n2):
    return n2,n1

a,b = 100,200
a,b = Swap(a,b)
print(a, b)

递归函数

递归就是一个函数在它的函数体内调用它自身。执行递归函数将反复调用其自身，每调用一次就进入新的一层。递归函数必须有结束条件。

递归实例

实例1：阶乘

package mainimport "fmt"func Factorial(n uint64)(result uint64) {if (n > 0) {result = n * Factorial(n-1)return result}return 1
}func main() {  var i int = 15fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
}

实例2：斐波那契数列

package mainimport "fmt"func fibonacci(n int) int {if n == 1 || n == 2 {return 1}return fibonacci(n-2) + fibonacci(n-1)
}func main() {var i intfor i = 1; i <= 10; i++ {fmt.Printf("%d\t", fibonacci(i))}
}

Python这两个函数练得太多了，略。

字面函数（内联函数、函数嵌套）

暂且不知道叫什么，姑且这么称呼吧。

package mainimport "fmt"func main() {number := 0increment := func(amount int) {number += amount}increment(1)increment(2)increment(5)fmt.Println(number) // 8}

 对比Python： 

def run():
    def increment(amount):
        return number + amount

    number = 0
    number = increment(1)
    number = increment(2)
    number = increment(5)
    print(number)  # 8

run()

字面函数，形式上有点像Python，C/C++的匿名函数，或称lambda表达式。

package mainimport "fmt"func main() {Add := func(a, b int) int { return a + b }fmt.Printf("Add function literals: %d\n", Add(10, 2))
}

内置函数

内置函数是不需要引入包直接可用的函数。

append --向数组，slice里添加元素，返回新的数组，slice

delete --删除map里对应key的value值

close --关闭通道

copy --用于复制和连接slice，返回复制的数目

imag -- 返回complex的实部

real -- 返回complex的虚部

new -- 分配内存，主要用来分配值类型如int，struct，返回指向type的指针

make -- 分配内存，返回type本身（只用于slice，map，chan）

painc -- 抛出异常，与recover连用

recover -- 捕获异常

cap -- 容量，容积capacity

len -- 长度，比如string、array、slice、map、channel

常用包

fmt 标准包

math 数学运算包

errors 错误工具包

string 字符串操作包

strconv 字符串转换包

regexp 正则包（golang的正则实现的RE2标准）

encoding/json json转换工具包

os 文件读写操作

time 定时器、时间相关包

net 网络相关包

time包

常量

const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)

实例 

package mainimport ("fmt""time"
)func main() {t0 := time.Now()time.Sleep(3*time.Second + 230*time.Millisecond)elapsed := time.Since(t0)fmt.Printf("Took %s", elapsed)
}

对比Python： 

import time

t0 = time.time()
time.sleep(3.23)  # for example
t1 = time.time()
print("Took {:.2f} seconds".format(t1 - t0))

math包

常量

E = 2.71828182845904523536028747135266249775724709369995957496696763
Pi = 3.14159265358979323846264338327950288419716939937510582097494459
Phi = 1.61803398874989484820458683436563811772030917980576286213544862
Sqrt2 = 1.41421356237309504880168872420969807856967187537694807317667974
SqrtE = 1.64872127070012814684865078781416357165377610071014801157507931
SqrtPi = 1.77245385090551602729816748334114518279754945612238712821380779
SqrtPhi = 1.27201964951406896425242246173749149171560804184009624861664038
Ln2 = 0.693147180559945309417232121458176568075500134360255254120680009
Log2E = 1 / Ln2
Ln10 = 2.30258509299404568401799145468436420760110148862877297603332790
Log10E = 1 / Ln10MaxFloat32 = 3.40282346638528859811704183484516925440e+38 
// 2**127 * (2**24 - 1) / 2**23
SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-45 
// 1 / 2**(127 - 1 23)
MaxFloat64 = 1.797693134862315708145274237317043567981e+308 
// 2**1023 * (2**53 - 1) / 2**52
SmallestNonzeroFloat64 = 4.940656458412465441765687928682213723651e-324 
// 1 / 2**(1023 - 1 52)

极值 

MaxInt8 = 1<<7 - 1
MinInt8 = -1 << 7
MaxInt16 = 1<<15 - 1
MinInt16 = -1 << 15
MaxInt32 = 1<<31 - 1
MinInt32 = -1 << 31
MaxInt64 = 1<<63 - 1
MinInt64 = -1 << 63
MaxUint8 = 1<<8 - 1
MaxUint16 = 1<<16 - 1
MaxUint32 = 1<<32 - 1
MaxUint64 = 1<<64 - 1

常用数学函数

/*IsNaN函数
func IsNaN(f float64) (is bool)
报告f是否表示一个NaN（Not A Number）
*/
func testIsNaN() {fmt.Println(math.IsNaN(12321.321321))    //false
}/*Ceil函数
func Ceil(x float64) float64
返回一个不小于x的最小整数，简单来说就是向上取整
*/
func testCeil() {fmt.Println(math.Ceil(1.13456))    //2
}/*Floor函数
func Floor(x float64) float64
返回一个不大于x的最小整数，简单来说就是向下取整
*/
func testFloor() {fmt.Println(math.Floor(2.9999))    //2
}/*Trunc函数
func Trunc(x float64) float64
返回x整数部分，与Floor一样
*/
func testTrunc() {fmt.Println(math.Trunc(2.9999))    //2
}/*Abs函数
func Abs(x float64) float64
返回x的绝对值
*/
func testAbs() {fmt.Println(math.Abs(-2.999))    //2.999
}/*Max函数
func Max(x, y float64) float64
返回x和y中最大值
*/
func testMax() {fmt.Println(math.Max(1000,200))    //1000
}/*Min函数
func Min(x, y float64) float64
返回x和y中最小值
*/
func testMin() {fmt.Println(math.Min(1000,200))    //200
}/*Dim函数
func Dim(x, y float64) float64
函数返回x-y和0中的最大值
*/
func testDim() {fmt.Println(math.Dim(1000,2000))    //0fmt.Println(math.Dim(1000,200))    //800
}/*Mod函数
func Mod(x, y float64) float64
取余运算，可以理解为 x-Trunc(x/y)*y，结果的正负号和x相同
*/
func testMod() {fmt.Println(math.Mod(123,0))    //NaNfmt.Println(math.Mod(123,10))    //3
}/*Sqrt函数
func Sqrt(x float64) float64
返回x的二次方根,平方根
*/
func testSqrt() {fmt.Println(math.Sqrt(144))    //12
}/*Cbrt函数
func Cbrt(x float64) float64
返回x的二次方根,平方根
*/
func testCbrt() {fmt.Println(math.Cbrt(1728))    //12
}/*Hypot函数
func Hypot(p, q float64) float64
返回Sqrt(p*p+q*q)，相当于求直角三角形的斜边长
*/
func testHypot() {fmt.Println(math.Hypot(3,4))    //5
}/*Pow函数
func Pow(x, y float64) float64
求幂，x的y次方
*/
func testPow() {fmt.Println(math.Pow(2,3))    //8
}/*Sin函数
func Sin(x float64) float64
求正弦
*/
func testSin() {fmt.Println(math.Sin(12))    //-0.5365729180004349
}/*Cos函数
func Cos(x float64) float64
求余弦
*/
func testCos() {fmt.Println(math.Cos(12))    //0.8438539587324921
}/*Tan函数
func Tan(x float64) float64
求正切
*/
func testTan() {fmt.Println(math.Tan(12))    //-0.6358599286615807
}/*Log函数
func Log(x float64) float64
求自然对数
*/
func testLog() {fmt.Println(math.Log(2))    //0.6931471805599453
}/*Log2函数
func Log2(x float64) float64
求2为底的对数
*/
func testLog2() {fmt.Println(math.Log2(128))    //7
}/*Log10函数
func Log10(x float64) float64
求10为底的对数
*/
func testLog10() {fmt.Println(math.Log10(10000))    //4
}/*Signbit函数
func Signbit(x float64) bool
如果x是一个负数或者负零，返回真
*/
func testSignbit() {fmt.Println(math.Signbit(10000))    //falsefmt.Println(math.Signbit(-200))    //true
}

实例

package mainimport ("fmt""math"
)func main() {var x float64var n intfmt.Scanf("%f%d", &x, &n)fmt.Println(powerf(x, n))fmt.Println(powerf2(x, n))fmt.Println(powerf3(x, n))fmt.Println(math.Pow(x, float64(n)))
}//二分法
func powerf(x float64, n int) float64 {ans := 1.0for n != 0 {if n%2 == 1 {ans *= x}x *= xn /= 2}return ans
}//递归法
func powerf2(x float64, n int) float64 {if n == 0 {return 1} else {return x * powerf2(x, n-1)}
}//循环法
func powerf3(x float64, n int) float64 {ans := 1.0for n != 0 {ans *= xn--}return ans
}

本篇学到这里暂告一段落，以上内容都能领会的话，常见的小问题简单的入门基础题基本上都能解决了； Go语言还有很多高级内容，拟列入Golang进阶之路中......

参考内容

1. Runoob： .html

2. Go vs. Python： /

3. 《Go语言编程》许式伟 吕桂华 等编著，人民邮电出版社出版发行