到底是Go+还是狗屁？-- 基础语法学习（附go/go+/python示例）_go 还是go+

---

注释

Go/Go+注释

// 单行注释
/*
多行注释
*/
1
2
3
4

Python注释

# 单行注释
"""
多行注释
"""
1
2
3
4

数据类型

• 布尔型：布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
• 整型：整型 int 和浮点型 float32、float64，Go +语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
• 字符串：字符串就是一串固定长度的字符连接起来的字符序列。

Go+示例

// 布尔值
println true && false
println true || false
println !true

// 数值
println("1+1 =", 1+1)
println("7.0/3.0 =", 7.0/3.0)

// 字符串
println "Go"+"Plus"
1
2
3
4
5
6
7
8
9
10
11

基础变量类型

变量可以通过变量名访问。Go+ 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

• 指定变量类型，如果没有初始化，则变量默认为空值。

  • 数值类型（包括complex64/128）为 0
  • 布尔类型为 false
  • 字符串为 “”（空字符串）

• 根据值自行判定变量类型。
  如果这个值在前面被 var 声明过的话会触发异常
  C:\Users\Lenovo\Desktop\go_test\hello.gop:1:15: expected declaration
  C:\Users\Lenovo\Desktop\go_test\hello.gop:61:12: expected ‘;’, found ‘:=’
  C:\Users\Lenovo\Desktop\go_test\hello.gop:74:2: expected ‘}’, found ‘EOF’
  */

Go+示例

// 指定变量类型，如果没有初始化，则变量默认为空值
var phone string = "11111"
println phone

// 布尔型
var bo bool
// 字符型
var by byte
// 无符号整型
var i int
// 无符号整型
var ui uint
// 浮点型
var f float64
// 字符穿
var s string
// 格式化输出
printf("%v %v %v %v %v %q\n", bo, by, i, ui, f, s)

// 根据值自行判定变量类型
phone1 := "11111"
println phone1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

有理数

我们将有理数作为原生 Go+ 类型引入。
我们使用后缀r来表示有理文字。例如， (1r << 200) 表示一个 big int, 其值等于 2 200。4/5r 表示有理常数 4/5。
<<运算符，将一个运算对象的各二进制位全部左移若干位

println 1r << 200
println 4/5r  // 4/5
println 4/5  // 0
1
2
3

容器类型

集合

Go 示例

package main

import "fmt"

func main() {
    // 集合
    z := map[string]string{"m1": "1"}
    // 集合插入元素
    z["name"] = "不太灵光的程序员"
    z["age"] = "18"
    fmt.Println(z["name"])
    // 集合删除元素
    delete(z, "name")
    fmt.Println(z)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Go+ 示例
go+ 语法，简化使用 make 方法

x := {"m1": 1}
y := {"m1": 1, "m2": "go+!"}
z := {}

// 集合插入元素
z["name"] = "不太灵光的程序员"
z["age"] = 18
println z["name"]
// 集合删除元素
delete(z, "name")
println z
println x, y, z
1
2
3
4
5
6
7
8
9
10
11
12

Python 示例

x = dict(m1=1)
y = {"m1": 1, "m2": "go+!"}
z = {}

# 插入元素
z.update({"name": "不太灵光的程序员"})
z["age"] = 18
# 删除元素
z.pop("name")
print(x, y, z)

# 遍历字典
for k in z:
    print(z[k])

# 字典推导式
print({k: v for k, v in z.items()})

# 判断key是否存在
print("name" in z)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

切片

Go 示例

package main

import "fmt"

func main() {
    x := []int{0,1,2,3,4,5}
    // 取索引3
    fmt.Println(x[3])
    // 取索引1-4不包含4
    fmt.Println(x[1:4])
    // 取索引1到最后
    fmt.Println(x[1:])
    // 同时添加多个元素
    x = append(x, 2,3,4)
    fmt.Println(x)

    // 切片遍历
    for i:=0; i < len(x); i++ {
        fmt.Println(x[i])
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Go+ 示例

x := [0, 1, 2, 3, 4] // []float64
y := [1+2i, "xsw"] // []interface{}
z := []

println x, y, z

// 取索引3
println x[3]
// 取索引1-4不包含4
println x[1:4]
// 取索引1到最后
println x[1:]
// 取索引0到倒数1个索引 不支持
// 切片反转  不支持
// 同时添加多个元素
x = append(x, 2,3,4)
println(x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Python 示例

# 初始化列表
x = [0, 1, 2, 3, 4, 5]
# 取索引3
print(x[3])
# 取索引1-4不包含4
print(x[1:4])
# 取索引1到最后
print(x[1:])
# 取索引0到倒数1个索引
print(x[:-1])
# 切片反转
print(x[::-1])
# 同时添加多个元素
x.extend([2, 3, 4])
print(x)

# 插入元素
x.append(99)

# 删除元素
x.pop()
x.remove(4)

# 遍历字典
for v in x:
    print(v)

for i in range(len(x)):
    print(x[i])

# 推导式
print({v*v for v in x})

# 判断key是否存在
print(1 in x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
显式类型定义： const b string = “abc”
隐式类型定义： const b = “abc”

Go 示例

package main
import (
    "fmt"
)
func main() {
	const WIDTH, LENGTH int = 5, 10
	area := LENGTH * WIDTH
	println area
	// 修改常量会抛出异常  VarRef *types.Const
	// WIDTH += 1
}
1
2
3
4
5
6
7
8
9
10
11

Go+ 示例

const WIDTH, LENGTH int = 5, 10
area := LENGTH * WIDTH
println area
// 修改常量会抛出异常  VarRef *types.Const
// WIDTH += 1
1
2
3
4
5

运算符

• 算术运算符：加+、减-、乘*、除/、求余%、自增++、自减-
• 关系运算符：==、!=、>、<、>=、<=、
• 逻辑运算符：%%与、||或、!非
• 位运算符：%与、|或、^异或、<<左移、>>右移
• 赋值运算符：赋值运算符比较多 运算法都可以直接赋值，例如 += 相加后赋值
• 其他运算符：& 取地址符、* 指针变量

语言条件语句

条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。

Go 示例

package main
import (
    "fmt"
)
func main() {
    // if ... else
    const WIDTH, LENGTH int = 5, 10
    if WIDTH == LENGTH {
      fmt.Println("正方形")
    }else if WIDTH < LENGTH {
      fmt.Println("长方形1")
    }else{
      fmt.Println("长方形2")
    }

    // switch
    var grade string
    var marks int = 90

    switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 60,70 : grade = "C"
      default: grade = "D"
    }
    fmt.Println(marks, grade)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Go+ 示例

// if ... else
const WIDTH, LENGTH int = 5, 10
if WIDTH == LENGTH {
  println "正方形"
}else if WIDTH < LENGTH {
  println "长方形1"
}else{
  println "长方形2"
}

// switch
var grade string
var marks int = 90

switch marks {
  case 90: grade = "A"
  case 80: grade = "B"
  case 60,70 : grade = "C"
  default: grade = "D"
}
println marks, grade
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Python 示例

# if ... else
WIDTH, LENGTH = 5, 10
if WIDTH == LENGTH:
    print("正方形")
elif WIDTH < LENGTH:
    print("长方形1")
else:
    print("长方形2") 
1
2
3
4
5
6
7
8

Lambda表达式

Go语言中的匿名函数 指的是不需要有名字的函数，通常定义在另外一个函数内部

Go 示例

package main
import (
    "fmt"
)
func main() {
    Sum := func(x, l int) (int) { return x + x }
    // 变量Sum作为匿名函数来使用，求和
    fmt.Println(Sum(50,10))
    return
}
1
2
3
4
5
6
7
8
9
10

Go+ 示例

// 并没看懂怎么用  触发异常了 undefined: Sum
Sum x, y => x + y
println(Sum(50,10))
1
2
3

Python示例

Sum = lambda x, y: x + y
print(Sum(10, 2))
1
2