標識符與關鍵字
| 標識符 |
在編程語言中標識符就是程序員定義的具有特殊意義的詞，比如變量名、常量名、函數名等等。 Go語言中標識符由字母數字和_(下劃線）組成，並且只能以字母和_開頭，區分大小寫。 舉幾個例子：abc, _, _123, a123。
【對比python】
單下劃線與雙下劃線在類中有特殊含義
| 關鍵字 |
關鍵字是指編程語言中預先定義好的具有特殊含義的標識符。 關鍵字和保留字都不建議用作變量名。
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語言中還有37個保留字。
Constants: true false iota nil
Types: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
Functions: make len cap new append copy close delete
complex real imag
panic recover
【對比python】
import keyword
k = keyword.kwlist
print(k,len(k)) # 35個保留字
False None True and as assert
async await 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
變量
| 變量的來歷 |
程序運行過程中的數據都是保存在內存中，我們想要在代碼中操作某個數據時就需要去內存上找到這個變量，但是如果我們直接在代碼中通過內存地址去操作變量的話，代碼的可讀性會非常差而且還容易出錯，所以我們就利用變量將這個數據的內存地址保存起來，以後直接通過這個變量就能找到內存上對應的數據了。
| 變量類型 |
變量（Variable）的功能是存儲數據。不同的變量保存的數據類型可能會不一樣。經過半個多世紀的發展，編程語言已經基本形成了一套固定的類型，常見變量的數據類型有：整型、浮點型、布爾型等。
Go語言中的每一個變量都有自己的類型，並且變量必須經過聲明才能開始使用。
| 變量聲明 |
Go語言中的變量需要聲明後才能使用，同一作用域內不支持重複聲明。 並且Go語言的變量聲明後必須使用。
|標準聲明
Go語言的變量聲明格式爲：
var 變量名 變量類型
變量聲明以關鍵字var開頭，變量類型放在變量的後面，行尾無需分號。 舉個例子：
var name string
var age int
var isOk bool
|批量聲明
每聲明一個變量就需要寫var關鍵字會比較繁瑣，go語言中還支持批量變量聲明：
var (
a string
b int
c bool
d float32
)
|變量的初始化
Go語言在聲明變量的時候，會自動對變量對應的內存區域進行初始化操作。每個變量會被初始化成其類型的默認值，例如： 整型和浮點型變量的默認值爲0。 字符串變量的默認值爲空字符串。 布爾型變量默認爲false。 切片、函數、指針變量的默認爲nil。
當然我們也可在聲明變量的時候爲其指定初始值。變量初始化的標準格式如下：
var 變量名 類型 = 表達式
舉個例子：
var name string = "winstonfy"
var age int = 18
或者一次初始化多個變量
var name, age = "winstonfy", 20
類型推導
有時候我們會將變量的類型省略，這個時候編譯器會根據等號右邊的值來推導變量的類型完成初始化。
var name = "winstonfy"
var age = 18
短變量聲明
在函數內部，可以使用更簡略的 := 方式聲明並初始化變量。
package main
import (
"fmt"
)
// 全局變量m
var m = 100
func main() {
n := 10
m := 200 // 此處聲明局部變量m
fmt.Println(m, n)
}
匿名變量
在使用多重賦值時，如果想要忽略某個值，可以使用匿名變量（anonymous variable）。 匿名變量用一個下劃線_表示，例如：
func foo() (int, string) {
return 10, "winstonfy"
}
func main() {
x, _ := foo()
_, y := foo()
fmt.Println("x=", x)
fmt.Println("y=", y)
}
匿名變量不佔用命名空間，不會分配內存，所以匿名變量之間不存在重複聲明。 (在Lua等編程語言裏，匿名變量也被叫做啞元變量。)
注意事項：
- 函數外的每個語句都必須以關鍵字開始（var、const、func等）
- :=不能使用在函數外。
- _多用於佔位，表示忽略值。
【對比python】
弱類型語言，允許隱式類型轉換，不需要事先聲明，運行效率稍低
常量
相對於變量，常量是恆定不變的值，多用於定義程序運行期間不會改變的那些值。 常量的聲明和變量聲明非常類似，只是把var換成了const，常量在定義的時候必須賦值。
const pi = 3.1415
const e = 2.7182
聲明瞭pi和e這兩個常量之後，在整個程序運行期間它們的值都不能再發生變化了。
多個常量也可以一起聲明：
const (
pi = 3.1415
e = 2.7182
)
const同時聲明多個常量時，如果省略了值則表示和上面一行的值相同。 例如：
const (
n1 = 100
n2
n3
)
上面示例中，常量n1、n2、n3的值都是100。
| iota |
iota是go語言的常量計數器，只能在常量的表達式中使用。
iota在const關鍵字出現時將被重置爲0。const中每新增一行常量聲明將使iota計數一次(iota可理解爲const語句塊中的行索引)。 使用iota能簡化定義，在定義枚舉時很有用。
舉個例子：
const (
n1 = iota //0
n2 //1
n3 //2
n4 //3
)
|幾個常見的iota示例:
使用_跳過某些值
const (
n1 = iota //0
n2 //1
_
n4 //3
)
iota聲明中間插隊
const (
n1 = iota //0
n2 = 100 //100
n3 = iota //2
n4 //3
)
const n5 = iota //0
定義數量級 （這裏的<<表示左移操作，1<<10表示將1的二進制表示向左移10位，也就是由1變成了10000000000，也就是十進制的1024。同理2<<2表示將2的二進制表示向左移2位，也就是由10變成了1000，也就是十進制的8。）
const (
_ = iota
KB = 1 << (10 * iota)
MB = 1 << (10 * iota)
GB = 1 << (10 * iota)
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
)
多個iotai定義在一行
const (
a, b = iota + 1, iota + 2 //1,2
c, d //2,3
e, f //3,4
)
【對比python】
沒有使用語法強制定義常量，如果非要定義常量，變量名必須全大寫。因此在python中常量也是可以修改的，但不建議。
python中使用自定義類實現常量的方法：
# const.py
class _const:
class ConstError(TypeError):pass
def __setattr__(self,name,value):
if name in self.__dict__:
raise self.ConstError("Can't rebind const (%s)" %name)
self.__dict__[name]=value
import sys
#把const類註冊到sys.modules這個全局字典中
sys.modules[__name__]=_const()
# test.py
# 使用上面的const類
import const
const.PI=3.14
print(const.PI)
const.PI =3 #報錯 Can't rebind const PI