1. 命名
Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名,都遵循一个简单的命名规则:一个名字必须以一个字母(Unicode字母)或下划线开头,后面可以跟任意数量的字母、数字或下划线。大写字母和小写字母是不同的:heapSort和Heapsort是两个不同的名字。这个和Python基本相同。
Go语言中类似if和switch的关键字有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
此外,还有大约30多个预定义的名字,比如int和true等,主要对应内建的常量、类型和函数。
内建常量: true false iota nil 内建类型: int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error 内建函数: make len cap new append copy close delete complex real imag panic recover
扩展(补充):
Python中的关键字
在python中若想查询python中有哪些关键字可以先导入keyword模块
import keyword print(keyword.kwlist) >>>> ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from',
'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass',
'raise', 'return', 'try', 'while', 'with', 'yield']
2.变量
变量是几乎所有编程语言中最基本的组成元素,变量是程序运行期间可以改变的量。
从根本上说,变量相当于是对一块数据存储空间的命名,程序可以通过定义一个变量来申请一块数据存储空间,之后可以通过引用变量名来使用这块存储空间。
2.1 变量声明
Go语言的变量声明方式与Python语言有明显的不同。对于纯粹的变量声明, Go语言引入了关键字var,而类型信息放在变量名之后,示例如下:
var v1 int var v2 int //一次定义多个变量 var v3, v4 int var ( v5 int v6 int )
Python中不需要提前声明变量,用的时候直接可以拿过去用。
2.2 变量初始化
对于声明变量时需要进行初始化的场景, var关键字可以保留,但不再是必要的元素,如下所示:
package main import "fmt" //导入包含,必须要使用 func main(){ // 变量,程序运行期间可以改变的两 // 1声明变量 var 变量名 类型 // 2只是声明没有初始化的变量,默认值为0 // 3同一个{}里,声明的变量名是唯一的 var a int fmt.Println(a) // 4同时可以声明多个变量 //var b,c int //fmt.Println(b,c) a = 10 //变量的赋值 fmt.Println(a) // 变量的初始化,声明变量时,同时赋值 var b int = 10 //初始化, 声明和赋值同时进行 b = 20 //赋值 先声明,后赋值 fmt.Println(b) // 自动推导类型,必须初始化,通过初始化的值确定类型 c := 30 // %T 打印变量所属的类型 fmt.Printf("c type is %T\n", c)
自动推导类型:
package main import "fmt" func main(){ // 赋值,赋值前,必须先声明变量 var a int a = 10 // 赋值可以使用n次 fmt.Println("a = ", a) // :=, 自动推导类型,先声明变量b,再给b赋值给20 // 自动推导,同一个变量名只能使用一次,用于初始化 b := 20 fmt.Println("b = ",b) // b := 30 //前面已经有变量b,不能再建一个变量b }
补充:printf和println的区别
package main import "fmt" func main(){ a := 10 // 一段一段处理,自动加换行 fmt.Println("a = ", a) // 格式化输出,把a的内容放在%d的位置 fmt.Printf("a = %d\n", a) b, c := 20, 30 fmt.Println("a = ",a, ", b = ", b, ", c =", c ) fmt.Printf("a = %d, b = %d, c = %d\n", a,b,c) }
多重赋值以及匿名变量
_(下划线)是个特殊的变量名,任何赋予它的值都会被丢弃
package main import "fmt" //go函数可以返回多个值 func test()(a,b,c int){ return 1,2,3 } func main(){ // a := 10 // b := 20 // c := 30 a, b := 10, 20 //交换两个变量的值 var tmp int tmp = a a = b b = tmp fmt.Printf("a = %d, b=%d\n", a,b) i,j := 30,40 i,j = j,i fmt.Printf("i = %d,j = %d\n", i,j) // _匿名变量,丢弃数据不处理,匿名变量配合返回值使用,才有优势 tmp,_ = i,j fmt.Println("tmp = ",tmp) var c,d,e int c,d,e = test() fmt.Printf("c = %d, d = %d, e = %d\n",c,d,e) _,d,_ = test() fmt.Println("d = ", d) }
3.常量
在Go语言中,常量是指编译期间就已知且不可改变的值。常量可以是数值类型(包括整型、浮点型和复数类型)、布尔类型、字符串类型等。
3.1 字面常量(常量值)
所谓字面常量(literal),是指程序中硬编码的常量,如:
123 3.1415 // 浮点类型的常量 3.2+12i // 复数类型的常量 true // 布尔类型的常量 "foo" // 字符串常量
3.2 常量定义
const Pi float64 = 3.14 const zero = 0.0 // 浮点常量, 自动推导类型 const ( // 常量组 size int64 = 1024 eof = -1 // 整型常量, 自动推导类型 ) const u, v float32 = 0, 3 // u = 0.0, v = 3.0,常量的多重赋值 const a, b, c = 3, 4, "foo" // a = 3, b = 4, c = "foo" //err, 常量不能修改
多个变量或常量定义实例:
package main import "fmt" func main(){ // 不同类型变量的声明(定义) //var a int //var b float64 var ( a int b float64 ) a = 10 b = 3.14 fmt.Println("a=", a) fmt.Println("b=", b) //const i int = 10 //const j float64 = 3.14 const ( i int = 10 j float64 = 3.14 ) fmt.Println("i = ", i) fmt.Println("j = ", j) }
3.3 iota枚举
常量声明可以使用iota常量生成器初始化,它用于生成一组以相似规则初始化的常量,但是不用每行都写一遍初始化表达式。
在一个const声明语句中,在第一个声明的常量所在的行,iota将会被置为0,然后在每一个有常量声明的行加一。
package main import "fmt" func main(){ // 1.iota常量生成器,每一行自动加 1 // 2.iota给常量赋值使用 const( a = iota // 1 b = iota // 2 c = iota // 3 ) fmt.Printf("a = %d, b = %d, c = %d\n", a,b,c) //3.iota遇到const重置为0 const d = iota fmt.Printf("d = %d\n", d) //4.可以只写一个iota const( e = iota f g ) fmt.Printf("e = %d, f = %d, g = %d\n ",e,f,g) //5.如果是同一行,值都一样 const ( h = iota i, j, k = iota,iota,iota m = iota ) fmt.Printf("h = %d, i = %d, j = %d, k = %d, m = %d",h,i,j,k,m) }
a = 0, b = 1, c = 2 d = 0 e = 0, f = 1, g = 2 h = 0, i = 1, j = 1, k = 1, m = 2 Process finished with exit code 0
4.基础数据类型
4.1 分类
Go语言内置以下这些基础类型:
类型 | 名称 | 长度 | 零值 | 说明 |
bool | 布尔类型 | 1 | false | 其值不为真即为家,不可以用数字代表true或false |
byte | 字节型 | 1 | 0 | uint8别名 |
rune | 字符类型 | 4 | 0 | 专用于存储unicode编码,等价于uint32 |
int, uint | 整型 | 4或8 | 0 | 32位或64位 |
int8, uint8 | 整型 | 1 | 0 | -128 ~ 127, 0 ~ 255 |
int16, uint16 | 整型 | 2 | 0 | -32768 ~ 32767, 0 ~ 65535 |
int32, uint32 | 整型 | 4 | 0 | -21亿 ~ 21 亿, 0 ~ 42 亿 |
int64, uint64 | 整型 | 8 | 0 |
|
float32 | 浮点型 | 4 | 0.0 | 小数位精确到7位 |
float64 | 浮点型 | 8 | 0.0 | 小数位精确到15位 |
complex64 | 复数类型 | 8 |
|
|
complex128 | 复数类型 | 16 |
|
|
uintptr | 整型 | 4或8 |
| ⾜以存储指针的uint32或uint64整数 |
string | 字符串 |
| "" | utf-8字符串 |
4.2 布尔类型
package main import "fmt" func main(){ //1 声明变量,没有初始化,零值(初始化值)为False var a bool fmt.Println("a = ", a) a = true fmt.Println("a = ", a ) // 自动推导类型 var b = false fmt.Println("b = ",b) c := false fmt.Println("c = ",c) }
4.3 整型
package main import "fmt" func main(){ var v1 int32 v1 = 123 v2 := 64 fmt.Println("v1 = ", v1, " ,v2 = ", v2) }
4.4 浮点型
package main import "fmt" func main(){ // 声明变量 var f1 float32 f1 = 3.14 fmt.Println("f1=", f1) //自动推导类型 f2 := 3.14 fmt.Printf("f2 type is %T\n", f2) // float 64比32存储的更准确 }
4.5 字符类型
在Go语言中支持两个字符类型,一个是byte(实际上是uint8的别名),代表utf-8字符串的单个字节的值;另一个是rune,代表单个unicode字符。
package main import "fmt" func main(){ var ch byte // 声明字符类型 ch = 97 // fmt.Println("ch = ", ch) // 格式化输出,%c以字符方式打印,%d以整型方式打印 fmt.Printf("%c %d\n", ch , ch) ch = 'a' //字符,单引号 fmt.Printf("%c, %d\n", ch, ch) //大写转小写,小写转大写 小写比大写大32 fmt.Printf("大写: %d, 小写: %d\n", 'A', 'a') fmt.Printf("大写转小写 %c\n", 'A'+32) fmt.Printf("小写转大写: %c\n", 'a'-32) }
a 97 a, 97 大写: 65, 小写: 97 大写转小写 a 小写转大写: A
4.6字符串类型
package main import "fmt" func main(){ var str1 string //声明变量 str1 = "abc" fmt.Println("str1 = ", str1) // 自动推导类型 str2 := "mike" fmt.Printf("str2类型是 %T\n", str2) // 内建函数,len()可以测试字符串的长度,有多少个字符,这个和python中的len()用法类似 fmt.Println("len(str2)=", len(str2)) }
>>>>>>
str1 = abc
str2类型是 string
len(str2)= 4
4.7字符和字符串的区别
字符一般都用单引号表示,且只有一个字符,转义字符除外(如‘\n’)
字符串一般有用双引号表示,由一个字符或多个字符所组成,字符串都隐藏一个结束符‘\0’
package main import "fmt" func main(){ var ch byte var str string //字符 //1单引号 //2字符往往都只有一个字符,转义字符除外'\n' ch = 'a' fmt.Println("ch = ", ch) //字符串 //1双引号 //2字符串由一个或多个字符组成 //3字符串都是隐藏一个结束符,'\0' str = "a" // 由'a'和 '\0'组成一个字符串 fmt.Println("str=", str) str = "hello go" //只想操作字符串的某个字符,从0开始操作,和python中的索引类似 fmt.Printf("str[0]=%c, str[1]=%c\n", str[0], str[1]) }
4.8 复数类型
复数实际上由两个实数(在计算机中用浮点数表示)构成,一个表示实部(real),一个表示虚部(imag)。
package main import "fmt" func main(){ var t complex128 //声明 t = 2.1 + 3.14i // 赋值 fmt.Println("t = ", t) //自动推导类型 t2 := 3.2 +3.2i fmt.Printf("t2 type is %T\n", t2) //通过内建函数,取实部和虚部 fmt.Println("real(t2) = ", real(t2), "imag(t2) = ", imag(t2)) }
在python中,用j或者J来表示虚部。
a = 3.13 + 2.23j a.read # 获取复数的实部 a.imag # 获取复数的虚部
5 fmt包的格式化输出输入
.5.1 格式说明
格式 | 含义 |
%% | 一个%字面量 |
%b | 一个二进制整数值(基数为2),或者是一个(高级的)用科学计数法表示的指数为2的浮点数 |
%c | 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符 |
%d | 一个十进制数值(基数为10) |
%e | 以科学记数法e表示的浮点数或者复数值 |
%E | 以科学记数法E表示的浮点数或者复数值 |
%f | 以标准记数法表示的浮点数或者复数值 |
%g | 以%e或者%f表示的浮点数或者复数,任何一个都以最为紧凑的方式输出 |
%G | 以%E或者%f表示的浮点数或者复数,任何一个都以最为紧凑的方式输出 |
%o | 一个以八进制表示的数字(基数为8) |
%p | 以十六进制(基数为16)表示的一个值的地址,前缀为0x,字母使用小写的a-f表示 |
%q | 使用Go语法以及必须时使用转义,以双引号括起来的字符串或者字节切片[]byte,或者是以单引号括起来的数字 |
%s | 字符串。输出字符串中的字符直至字符串中的空字符(字符串以'\0‘结尾,这个'\0'即空字符) |
%t | 以true或者false输出的布尔值 |
%T | 使用Go语法输出的值的类型 |
%U | 一个用Unicode表示法表示的整型码点,默认值为4个数字字符 |
%v | 使用默认格式输出的内置或者自定义类型的值,或者是使用其类型的String()方式输出的自定义值,如果该方法存在的话 |
%x | 以十六进制表示的整型值(基数为十六),数字a-f使用小写表示 |
%X | 以十六进制表示的整型值(基数为十六),数字A-F使用小写表示 |
5.2 格式化输出
package main import "fmt" func main(){ a := 10 b := "abc" c := 'a' // 字符类型是int32 d := 3.14 // %T操作变量所属类型 fmt.Printf("%T,%T,%T,%T\n", a,b,c,d) // %d整型号格式 // %s 字符串格式 // %c 字符格式 // %f 浮点型格式 fmt.Printf("a=%d, b=%s, c=%c, d=%f\n", a,b,c,d) //%v自动匹配格式输出 fmt.Printf("a=%v, b=%v, c=%v, d=%v\n", a,b,c,d) }
5.3输出
package main import "fmt" func main(){ var a int var b int fmt.Print("请输入变量a:") fmt.Scanf("%d", &a) // 别忘了& fmt.Print("请输入变量b:") fmt.Scan(&b) fmt.Println("a = ", a) fmt.Println("b = ", b) }
补充:在python中直接使用input,和python相比,go中的输入就略显的有些麻烦了
a = input("请输入变量a:") print(a)
5.4 类型转换
Go语言中不允许隐式转换,所有类型转换必须显式声明,而且转换只能发生在两种相互兼容的类型之间。
package main import "fmt" func main(){ // 不能转换类型,叫不兼容类型 var flag bool flag = true fmt.Printf("flag = %t\n", flag) // bool 类型不能转换为int // fmt.Printf("flag = %d \n", int(flag)) // 0就是假,非0就是真 // 整型也不能转bool // flag = bool(1) var ch byte ch = 'a' // 字符类型本质上是整型 var t int t = int(ch) // 类型转换,把ch的值取出来后,转成int 在赋值给t fmt.Println("t = ", t) }
5.5类型别名
package main import "fmt" func main(){ // 给int64 起一个别名叫bigint type bigint int64 var a bigint // 等价于var a int64 fmt.Printf("a type is %T\n", a) type( long int64 char byte ) var b long = 11 var ch char = 'a' fmt.Printf("b = %d, ch = %c\n", b, ch) }