「對比Python學習Go」- 基本數據結構

文章首發公衆號「碼農吳先生」, 歡迎訂閱關注。html

本篇是「對比Python學習Go」系列的第三篇，本篇文章咱們來看下Go的基本數據結構。Go的環境搭建，可參考以前的文章「對比Python學習Go」- 環境篇。廢話很少說，下面開始咱們的對比學習。python

基本數據類型

Go 的基本類型

Go的基本數據類型主要以下：golang

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的別名
rune // int32 的別名
// 表明一個Unicode碼
float32 float64
complex64 complex128
複製代碼

Go 語言自己更偏向底層，對內存佔用和性能的要求更高，除了有普通的數據類型以外，還有定長的數據類型，方便在不一樣場景使用，提升性能。安全

int，uint 和 uintptr 類型在32位的系統上通常是32位，而在64位系統上是64位。官方推薦在使用整數時，首選 int 類型，僅當有特別的理由（你知道爲何要這麼作）才使用定長整數類型或者無符號整數類型。markdown

Python 的基本類型

Python 的基本數據類型以下：數據結構

int 
long  # 僅在python 2 版本中有
float
complex  # 複數型
str   # 字符串 python2中有bytes（str）和unicode，python3中只有str類型 默認支持unicode編碼
bool  # 布爾型 
None  # 空值類型
複製代碼

在Python中，各種型佔用的字節大小有Python解釋器動態分配。不一樣的Python版本，分配機制也略有區別。用戶可以使用sys.getsizeof()來具體查看各種型佔用的字節數。Python3 中大體以下：函數

Bytes  type        scaling notes
28     int         +4 bytes about every 30 powers of 2
37     bytes       +1 byte per additional byte
49     str         +1-4 per additional character (depending on max width)
48     tuple       +8 per additional item
64     list        +8 for each additional
224    set         5th increases to 736; 21nd, 2272; 85th, 8416; 341, 32992
240    dict        6th increases to 368; 22nd, 1184; 43rd, 2280; 86th, 4704; 171st, 9320
136    func def    does not include default args and other attrs
1056   class def   no slots 
56     class inst  has a __dict__ attr, same scaling as dict above
888    class def   with slots
16     __slots__   seems to store in mutable tuple-like structure
                   first slot grows to 48, and so on.
複製代碼

有興趣深刻研究的，可參考這個stackoverflow的討論。oop

其實，在大多數狀況下，咱們使用Python來編寫代碼，不用太考慮類型的佔用大小問題，解釋器已經幫咱們作好了內存的分配。對於內存而言，咱們更應該關注的是大內存佔用的對象的及時釋放問題。post

常量和變量

Go 的常量和變量

package main

import "fmt"

// 常量定義和賦值 ，常量能夠是字符、字符串、布爾或數字類型，有關鍵字 const 定義
const Pi = 3.14 

// 變量定義和賦值 使用關鍵字 var 定義
var a = "initial"
var (
  x int 
  y int 
)

func main() {

    fmt.Println(a)

    // 相同類型定義可省略前邊變量的數據類型
    var b, c int = 1, 2
    fmt.Println(b, c)

    // 定義布爾型並賦值
    var d = true
    fmt.Println(d)

    // 只定義沒有賦值
    var e int
    fmt.Println(e)

    // := 爲變量賦值簡寫形式，只有在函數中才能使用。常量在哪都不能使用。
    f := "short"
    fmt.Println(f)
}
複製代碼

代碼中 e 只定義並無賦值，此時它會有一個默認的初始值，在Go中把這個初始值叫作「零值」。性能

數值類型爲 0，
布爾類型爲 false ，
字符串爲「」（空字符串）

在使用數值類型0值的時候必定要注意精度問題，在不一樣語言中精度要求可能不一樣，這極可能形成你序列化和反序列化的失敗。

Python 的常量和變量

Python 是動態，弱類型語言。在賦值前不須要聲明，左側對象的類型由值的類型肯定。

>>> a = 123
>>> b = '123'
>>> c = True
>>> print(type(a),type(b),type(c))
(<type 'int'>, <type 'str'>, <type 'bool'>)

a,b = 1,2  # 批量複製
c = d = 3  # 連續複製

a,b = b,a  # ab 值交換 
複製代碼

類型轉換

Go

// 數值型可直接使用 表達式 T(v)將值 v 轉換爲類型 T
var i int = 42
// int --> float64
var f float64 = float64(i)
// int --> uint 
var u uint = uint(f)

// 數值和字符串的轉換 須要使用 strconv 庫，它爲咱們提供了不少轉換方法
s := "123456"
// string --> int
i, _ := strconv.Atoi(s)
fmt.Println("i type:", reflect.TypeOf(i))
// string --> int64
i64, _ := strconv.ParseInt(s, 10, 64)
fmt.Println("i64 type:", reflect.TypeOf(i64))
// string --> float64
f64, _ := strconv.ParseFloat(s, 64)
fmt.Println("f64 type:", reflect.TypeOf(f64))
// int --> string
s1 := strconv.Itoa(i) //數字變成字符串
fmt.Println("s1 type:", reflect.TypeOf(s1))
// int64 --> string
s2:=strconv.FormatInt(i64,10)
fmt.Println("s1 type:", reflect.TypeOf(s2))
複製代碼

Python

Python中可直接將各種型對象使用類型方法轉換。

n = 20 
# int --> float 
f = float(n)
# int --> str
s = str(n)
# str --> int 
n1 = int(s)
# str --> float 
f1 = float(s)

複製代碼

字符串操做

Go

name := "DeanWu"
// 相加
fmt.Println("我叫" + name)

// 下標取值
fmt.Println(name[0])  // 直接取，是對應的ascii碼，須要傳下
fmt.Printf("%c\n", name[0])
fmt.Println(name[:3])

// 使用內建函數len獲取字符串長度
fmt.Println(len(name))

// 字符串包含
fmt.Println(strings.Contains(name, "a"))

// 字符串開頭，結尾
fmt.Println(strings.HasPrefix(name, "D"))
fmt.Println(strings.HasSuffix(name, "u"))

// 字符串分割組合
arr := strings.Split(name, "e")
fmt.Println(strings.Join(arr, "e"))

// 字符串格式化
fmt.Printf("%s, %.2f \n", a, f64)
fmt.Println(fmt.Sprintf("我叫，%s", name))

/* %v 相應值的默認格式。在打印結構體時，「加號」標記（%+v）會添加字段名 %#v 相應值的 Go 語法表示 %T 相應值的類型的 Go 語法表示 %% 字面上的百分號，並不是值的佔位符 %t 單詞 true 或 false。 %b 二進制表示 %c 相應 Unicode 碼點所表示的字符 %d 十進制表示 %o 八進制表示 %q 單引號圍繞的字符字面值，由 Go 語法安全地轉義 %x 十六進制表示，字母形式爲小寫 a-f %X 十六進制表示，字母形式爲大寫 A-F %U Unicode 格式：U+1234，等同於 「U+%04X」 %b 無小數部分的，指數爲二的冪的科學計數法，與 strconv.FormatFloat 的 ‘b’ 轉換格式一致。例如 -123456p-78 %e 科學計數法，例如 -1234.456e+78 %E 科學計數法，例如 -1234.456E+78 %f 有小數點而無指數，例如 123.456 %g 根據狀況選擇 %e 或 %f 以產生更緊湊的（無末尾的 0）輸出 %G 根據狀況選擇 %E 或 %f 以產生更緊湊的（無末尾的 0）輸出 %s 字符串或切片的無解譯字節 %q 雙引號圍繞的字符串，由 Go 語法安全地轉義 %x 十六進制，小寫字母，每字節兩個字符 %X 十六進制，大寫字母，每字節兩個字符 %p 十六進制表示，前綴 0x */ 
複製代碼

Python

name = "DeanWu"
# 相加
print("我叫" + name)

# 下標取值
print(name[0])
print(name[:3])

# 使用內建函數len獲取字符串長度
print(len(name))

# 字符串包含
print("a" in name)

# 字符串開頭，結尾
print(name.startswith("D"))
print(name.endswith("u"))

# 字符串分割組合
name_list = name.split("e")
print("e".join(name_list))

# 字符串格式化
print("%s " % name )
%d	整數
%f	浮點數
%s	字符串
%x	十六進制整數

# format 格式化 
print("你好，{}".format(name))
print("你好，{0}, {1}".format(name, "我是第二個"))

# fstring 格式化
print(f'我是，{name}')
複製代碼

其餘

編碼

Go 原生支持Unicode，經常使用編碼爲UTF-8。

Python2中的默認編碼爲ASCII編碼，Python3中使用的則是UTF-8編碼。

篇幅有限，更多編碼問題可參考我以前總結的Python教程：字符串與編碼章節

操做符

go操做符：

+    &     +=    &=     &&    ==    !=    (    )
-    |     -=    |=     ||    <     <=    [    ]
*    ^     *=    ^=     <-    >     >=    {    }
/    <<    /=    <<=    ++    =     :=    ,    ;
%    >>    %=    >>=    --    !     ...   .    :
     &^          &^=
複製代碼

python操做符：

+    ==   =    &   and
-    !=   +=   |   or
*    <>   -=   ^   not
/    >    *=   ~    
%    <    /=   <<   
**   >=        >>   
//   <=             

複製代碼

關鍵字

go關鍵字：

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
複製代碼

python 關鍵字：

>>> import keyword
>>> keyword.kwlist
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
複製代碼

註釋

go 註釋：

// 單行註釋

/* 多行 註釋 */ 
複製代碼

python 註釋：

# 單行註釋

''' 多行 註釋 '''

""" 多行 註釋 """
複製代碼

總結

本篇文章咱們對比學習了Go的基本數據結構，從基本數據結構的設計，咱們能夠看出Go的基本類型，更精細，對用戶暴露出更多的可控性。在使用上，都比較簡單，清晰明瞭。

好了，本篇到這裏了，敬請期待下篇更新。

我是DeanWu，一個努力成爲真正SRE的人。

關注公衆號「碼農吳先生」, 可第一時間獲取最新文章。回覆關鍵字「go」「python」獲取我收集的學習資料，也可回覆關鍵字「小二」，加我wx，聊技術聊人生~