python+golang串讲复习

其中每一个小结基本都会python和golang对比来理解。

golang的优势

hello world

我们这里就采用每个语言入门的基础，main函数中打印hello，world来理解两门语言

go

对于golang来说编译会编译成可执行文件(.exe)，像以前的java会编译成面向jvm的.class文件。

对于golang的编译通常采用(go build xxx.go)

下面是golang的代码：

package main

import "fmt"

func main() {
	fmt.Println("hello golang")
}

python

下面为python的代码：

def main():
    print('hello python')
main() // 手动调用
def main():
    print('hello python')
if __name__ == '__main__':
    main()

通过两者的对比，我们发现：

golang：

main函数入口就是先找到main函数再去执行，而不需要手动调用，所以golang的main函数必须得叫main，并且package也需要为main。

对于golang的包，比如main函数的包，我们手动声明了一个go文件的包为main，另一个go文件像引用一个包的函数，就需要通过我们手动声明的包去找到那个函数。

对于没有golang使用的包，golang会爆红，除非使用或者采用 _ 的形式。

python：

在Python中，不必每次编写程序时都定义main函数。这是因为除非定义了特定的函数，否则Python解释器将从文件顶部执行。因此，为Python程序的执行定义一个起点对于更好地理解您的程序是如何工作的很有用。

python的一个文件名就相当于一个包，不需要手动声明包。

python对于main函数的入口，需要手动调用。

python的包没有使用不会报错

变量

go

静态语言的变量定义和动态语言变量定义差距很大！

在golang中，定义一个变量得确定他的类型。

var i int

或者可以根据值推断出类型

var i = 100 // 并没有设置类型。
i := 100

golang可以多变量赋值

var a,b,c int = 1,2,3
var a,b,c int
a,b,c = 1,2,3
var(
    a int
    name string
   )

python

其实学习了golang的变量定义，发现golang中 i := 0这个语句有点像python，这就是golang想让编程尽可能简单的体现吧。

i = 1
print(i)

匿名变量

匿名变量在python和golang中都用’ _ '进行表示。

go

在golang中有时候不需要这个变量，必须得用_表示，因为不使用的变量会报错，相对于来说会对类型更加严格。

package main

import "fmt"

func test()(int,error) {
    return 0,nil
}
// err没有使用会报错，此时应该用匿名变量
func main() {
    fmt.Println("hello golang")
 // count, err := test()
	count,_ := test()
    fmt.Println(count)
}

python

在python中则不用匿名变量也不会报错。

# 不会报错
items = ['u','a','v']
for index,item in enumerate(items) :
    print(item)

常量

首先了解为什么需要常量。

在我们做一些精确的运算，例如计算圆的周长（2 Π*r）。其中Π是一个不会改变的数。

我们如果头铁一点，可以这样写。

round = 2 * 3.1415926 * 1

这样写一行其实没什么问题，但是如果使用Π的行数多了，很容易写错，我们考虑用一个变量。

PI = 3.1415926
round = 2 * PI * 1

这样有另一个问题，万一某一个地方将PI修改，所有位置的函数都有点问题。

那么我们想要一个不变的量，就是常量了。

go

直接使用关键字const，创建一个常量即可。

package main

import "fmt"

const (
	a int = 1
	b
	c string = "ab"
	d
)

func main() {
	const PI = 3.1415926
	round := 2 * PI * 1
	fmt.Println(round)
}

常量组

（如果常量组下面的元素没有声明类型和值，则和上一行一样）

package main

import "fmt"

const (
    a int = 1
    b
    c string = "ab"
    d
)

func main() {
    fmt.Println(a, b, c, d) //1 1 ab ab
}

iota（常量计数器）

• iota只能在常量组中使用
• 不同的const互不干扰
• 没有表达式的常量定义复用上一行的类型和值
• iota每行逐行+1

通过一个例子理解（a为0没啥问题，b为10没啥问题，c复用b的10没啥问题，d由于一直累加为3没啥问题。）

package main

import "fmt"

const (
	a int = iota
	b     = 10
	c
	d = iota
)

func main() {
	fmt.Println(a, b, c, d) // 0 10 10 3
}

那更骚的一个例子来看一下，更好的说明了跨了一行iota才会+1

package main

import "fmt"

const (
	a int = iota
	b     = 10
	c
	d, e = iota, iota
	f    = iota
)

func main() {
	fmt.Println(a, b, c, d, e, f) //0 10 10 3 3 4
}

python

在python中没有语法层面的常量。只能用一种约定来确定常量。即常量全部写成大写。在使用这些属性，我们就要留意不要修改他。

PI = 1415926
round = 2 * PI * 1

在python中有一个不能修改的元素，例如元组。

sex_tuple = ('male','female')

变量的作用域

go

go的全局变量和局部变量，请看下面代码：

package main

import "fmt"

var a int = 20

func main() {
	var a int = 10
	fmt.Println(a) // 10
}

python

a = 20

def my_func():
    a= 10
    print(a) // 10

my_func()
print(a) // 20

为啥一个是10，一个是20？

在函数中赋值了一个局部变量，打印的10没毛病。

但是在外部，访问不到函数内部赋值的a，只能访问到外部的全局变量20.

那我想修改全局变量怎么办？

a = 20

def my_func():
    global a
    a= 10
    print(a)

my_func()
print(a)

可以加一个global a，代表我要用的是全局变量a.

基本数据类型

go

bool类型

布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true

数值型

为啥python就没有如此繁多的整数类型？

在golang中，为int区分8，16，32，64有许多好处；

比如年龄(0_{200)，分数(0}100),这些就没必要用int64等等。

可以通过使用场景，来减少内存的占用。

在python中，int值是动态分配空间的。

1. 整数型

注意在golang中int是动态类型，取决于机器是多少位，若是64位则是8个字节，32位则是4个字节。

可以简单讲解一下二进制和位数的关系，以及int和uint的关系

• int8 有符号 8 位整型 (-128 到 127) 长度：8bit
• int16 有符号 16 位整型 (-32768 到 32767)
• int32 有符号 32 位整型 (-2147483648 到 2147483647)
• int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
• uint8 无符号 8 位整型 (0 到 255) 8位都用于表示数值：
• uint16 无符号 16 位整型 (0 到 65535)
• uint32 无符号 32 位整型 (0 到 4294967295)
• uint64 无符号 64 位整型 (0 到 18446744073709551615)

1. 浮点型

• float32 32位浮点型数
• float64 64位浮点型数

其他

• byte 等于 uint8 可以处理ASCII
• rune 等于 int32 可以处理中文
• uint 32 或 64 位

python

Python 中主要有8种数据类型：number（数字）、string（字符串）、list（列表）、tuple（元组）、dict（字典）、set（集合）、Boolean（布尔值）、None（空值）。

数据类型的转换

go

不是所有数据类型都能转换的，例如字母格式的string类型"abcd"转换为int肯定会失败 低精度转换为高精度时是安全的，高精度的值转换为低精度时会丢失精度。例如int32转换为int16，float32转换为int 这种简单的转换方式不能对int(float)和string进行互转，要跨大类型转换，可以使用strconv包提供的函数

golang中不支持变量和变量类型的隐式转换，比如看下面一段c++的代码

int main(){
    int a = 5;
    float b =6.2;
    a = b; // 发生隐式转换 6.2->6
	cout<<a<<endl;
}

对于golang，举一个例子

var b int = 5.0 // 支持，因为5.0相当于一个常量，而不是变量和变量之间的隐式转换

var c float64 = 3.4
var d int = c // 错误，无法赋值

Itoa和Atoi

**int转换为字符串：**Itoa()

println("a" + strconv.Itoa(32))  // a32

string转换为int：Atoi()

i,_ := strconv.Atoi("3")
println(3 + i)   // 6

// Atoi()转换失败
i,err := strconv.Atoi("a")
if err != nil {
    println("converted failed")
}
//由于string可能无法转换为int，所以这个函数有两个返回值：第一个返回值是转换成int的值，第二个返回值判断是否转换成功。

Parse类函数

Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)

ParseInt()和ParseUint()有3个参数：

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)

说明：

1. bitSize参数表示转换为什么位的int/uint，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8。
2. base参数表示以什么进制的方式去解析给定的字符串，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制解析

Format函数

将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。

s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16) //表示将-42转换为16进制数，转换的结果为-2a。
s := strconv.FormatUint(42, 16) 
//第二个参数base指定将第一个参数转换为多少进制，有效值为2<=base<=36。当指定的进制位大于10的时候，超出10的数值以a-z字母表示。例如16进制时，10-15的数字分别使用a-f表示，17进制时，10-16的数值分别使用a-g表示。

FormatFloat()参数众多：

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

fmt表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）。

prec控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

python

基本类型的转换

# 字符串转int
data="21"
i = int(data)
print(i)
i = int(data,16) // 将21看成16进制
print(i)

# int转字符串
i = 11
s = str(i)
print(type(s))

# float转换
data_float = float("63.4")
print(type(data_float),data_float)

float_str = str(data_float)
print(type(float_str),float_str)
# bool转换（只要字符串不为空都是true）
bool_data = bool("true")
print(type(bool_data),bool_data)

bool_str = str(bool_data)
print(type(bool_str),bool_str)

运算符

1. 算数运算符

±*/%(求余)+±-

2. 关系运算符

==!=><>=<=

3. 逻辑运算符

这个和python不一样，python中使用 and or来连接，非用not 表示。

package main

import "fmt"

func main() {
    var a bool = true
    var b bool = false
    if ( a && b ) {
       fmt.Printf("第一行 - 条件为 true\n" )
   }
    if ( a || b ) {
       fmt.Printf("第二行 - 条件为 true\n" )
   }
    /* 修改 a 和 b 的值 */
    a = false
    b = true
    if ( a && b ) {
       fmt.Printf("第三行 - 条件为 true\n" )
   } else {
       fmt.Printf("第三行 - 条件为 false\n" )
   }
    if ( !(a && b) ) {
       fmt.Printf("第四行 - 条件为 true\n" )
   }
}

4. 位运算符

位运算符对整数在内存中的二进制位进行操作。

下表列出了位运算符 &, |, 和 ^ 的计算：

假定 A = 60; B = 13; 其二进制数转换为：

A =00111100

B =00001101

A&B =00001100

A|B =00111101

A^B =00110001

Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：

赋值运算符

下表列出了所有Go语言的赋值运算符。

其他运算符

*此处讲解一下什么是地址*

运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。