内容详细
1 基本数据类型
// 两大类
-基本数据类型
-数字
-很多
-字符串
-布尔
-复合数据类型
-切片
-map
-结构体
-接口
-函数
// 基本数据类型
-整形
-int
-int8
-int16
-int32
-int64
-无符号整形
-uint
-uint8
-uint16
-uint32
-uint64
-浮点型
-float32
-float64
-复数类型(知道)
-complex64,complex128
-其他
-rune
-byte
-字符串类型
-string
-""
-``
-布尔类型
-bool
-false
-true
package main
import "fmt"
// 基本数据类型
func main() {
// 1 整形
// 8个比特位，8个小格，每个小格中只能放0或1 ，1个字节，1个字节能够表示的变化是：2的8次方，
// 有正负 2的7次方，还有个0
//var age int8=127 // 超长了，int8能够表示的数字范围： 正负 2的7次方-1
//var age int16=-32768 // 正负 2的15次方-1
//var age int32=32768 // 正负 2的31次方-1
//var age int64=32769 // 正负 2的63次方-1
//fmt.Println(age)
// 更节约内存
// 写程序，如果拿着数字10，int8占1个字节 int64 占4个字节
// 补充：python中不讲求这个，直接定义即可，可以无限大，它是一个对象，对象还有方法，占空间
// 补充：java中的变量类型
/*
byte（位） : int8
short（短整数） : int16
int（整数） : int32
long（长整数） : int64
float（单精度） : float32
double（双精度） : float64
char（字符） : byte 不是完全对象，暂时先这么理解
boolean（布尔值）：bool类型
*/
// int 类型 ---》在32位机器是 int32，在64位机器是int64
// 无符号整形--->没有负数
// uint :在32位机器是 uint32，在64位机器是uint64
// uint8 2的8次方-1
//var a uint8=255
//var a uint8=-1 // 不可以
//fmt.Println(a)
// 表示人的年龄--》uint8 ---》
// 人的年龄就用int类型，完全没有问题
// 浮点型--》带小数点---》本身就是会有精度损失
// float32 小数点后6位
// float64 小数点后15位
//var a float32=2.123456789
//var a float64=2.123456789123456789
//fmt.Println(a)
// 复数---》高等数学 --->实部 虚部---》 复数由实部（real）和虚部（imag）构成
// complex64
// complex128
//var a complex64=9+2i
//var b complex64=8+3i
//fmt.Println(a+b)
// byte 是uint8的别名---》底层就是uint8--->type byte = uint8---》一个byte占1个字节--》ASCII码-->1个字节
//var a byte =255
//var a byte ='z' //【单引号】引起ASCII的一个字符
//var a byte =97
//fmt.Println(a)
//rune 是int32的别名---》底层就是int32--->type rune = int32--》占4个字节---》表示一个unicode编码的字符
// unicode 是4个字节表示一个字符
//var a rune ='中' // unicode 编码的 中 字
//fmt.Println(a)
// 这俩东西是为了表示字符串的
// 字符串类型 string
// 双引号，或者是 反引号：反引号可以换行，中间可以带双引号 ----》没有单引号或三引号
// 单引号不是表示字符串，表示的是一个 unicode 字符
//var name string = "lqz\n" +
// "is" +
// "handsome"
// var name string = `lqz
// is
//handsome ""
//`
// fmt.Println(name)
//字符串操作---》判断是否以xx开头，结尾，子字符串在不在。。。就不能像python一样通过点方式，只能通过标准库提供的方法
//res:=strings.Contains("lqz is handsome","lqw")
//fmt.Println(res)
// 布尔类型
var b bool =true
b=false
fmt.Println(b)
}
2 常量
// 恒定不变的变量，定义赋初值以后，就不能改
// python 中，常量约定俗成，全大写表示常量，go中关键字修饰，真正的不能修改
package main
import "fmt"
// 常量的定义，一般定义外部，所有函数都可以用，使用const关键字修饰，定义时必须赋初值
// 变量的作用域范围---》在函数内部，外部
// const 常量名 常量类型 = 常量值
const name string ="彭于晏"
// const 常量名 = 常量值
const age =19
func main() {
// 1 常量的基本定义和使用
//fmt.Println(name)
//fmt.Println(age)
//// 常量布尔
//const b bool = true
////b=false 不能修改
//fmt.Println(b)
//2 iota
// 同时定义多个常量
//const (
// name string="彭于晏"
// age =19
//)
// 2.1 iota使用方式一
//const (
// a=iota // iota 写在第一行，表示0
// b=iota // iota 写在第二行，表示1
// c=iota // iota 写在第三行，表示2
//)
//fmt.Println(a,b,c)
// 2.2 iota使用方式二
// 定义常量，如果没有赋初值，初值是上一行常量的值
// 一旦使用了itoa，就打破了上面的规则，按照iota的增长规则，每一行加一
//const (
// a=10 // a是10，是我定义的
// b //b没有赋值，会使用上一个常量的值
// c=iota // 第三行，就是2
//
// d=iota // 第四行，就是3
//)
//const (
// a=10 // a是10，是我定义的
// b //b没有赋值，会使用上一个常量的值
// c=iota // 第三行，就是2
// d // 第四行，就是3 中间一旦使用了iota，就打破了参照上面常量值的规范，变成了相当于每一个都写了iota
// //e=iota // 第5行，就是4
// e // 第5行，就是4
// f=iota // 第6行，就是5
//)
//fmt.Println(a,b,c,d,e,f)
// 补充位运算
var a = 60
fmt.Println(a<<2)
fmt.Println(a>>2)
type ByteSize int64
const (
_ = iota
KB ByteSize = 1 << (10*iota)
MB
GB
)
fmt.Println(KB)
}
3 函数基础
package main
import "fmt"
// 函数基础
// 1 函数定义1 ：没有参数没有返回值
func test() {
fmt.Println("我是test")
}
// 2 函数有一个参数，没有返回值--》没有按位置和关键字传参的区别，都是按位置传
func test2(name string) {
fmt.Println(name)
}
// 3 函数有多个参数，没有返回值--》没有按位置和关键字传参的区别，都是按位置传
func test3(name string, age int, hobby string) {
fmt.Println(name, age, hobby)
}
// 4 函数有多个参数，没有返回值--》参数中有同一种类型，可以简写成
//func test4(name string,hobby string,age int) {
func test4(name, hobby string, age int) {
fmt.Println(name, age, hobby)
}
// 5 函数有参数，有返回值--->声明返回值类型--》回忆python typing模块
func test5(a, b int) int {
//func test5(a, b int) (int) {
fmt.Println(a + b)
return a + b
}
// 6 函数有参数，有多个返回值--->
func test6(a,b int )(int ,int,int) {
return a+b,a*b,a-b
}
func main() {
//1 函数定义1 ：没有参数没有返回值---》使用
//test()
// 2 函数有一个参数，没有返回值--->调用
//test2("lqz")
//test2(name="lqz") // 只有python有
// 3 函数有多个参数，没有返回值--》调用
//test3("lqz",19,"篮球")
// 4 函数有多个参数，没有返回值--》参数中有同一种类型，可以简写成--》调用
//test4("lqz","篮球",19)
// 5 函数有参数，有返回值--->声明返回值类型---》调用
//var res int
//var res int =test5(30,40)
//var res =test5(30,40)
//res := test5(30, 40) // := 是一家不能 分开
//fmt.Println(res)
// 6 函数有参数，有多个返回值--->调用-->多个返回值必须用多个变量接收，不能用一个
//res1,res2,res3:=test6(40,20)
//var res1,res2,res3=test6(40,20)
//fmt.Println(res1,res2,res3)
// 有的时候只想要两个返回值 _表示忽略
res1,res2,_:=test6(40,20)
fmt.Println(res1,res2)
//fmt.Println(_) //go 不是一个变量， python 中 _ 就是个变量
/*python支持，go不支持
_=10
print(_)
*/
}
4 函数高级
package main
import "fmt"
// 函数基础
// 1 函数定义1 ：没有参数没有返回值
func test() {
fmt.Println("我是test")
}
// 2 函数有一个参数，没有返回值--》没有按位置和关键字传参的区别，都是按位置传
func test2(name string) {
fmt.Println(name)
}
// 3 函数有多个参数，没有返回值--》没有按位置和关键字传参的区别，都是按位置传
func test3(name string, age int, hobby string) {
fmt.Println(name, age, hobby)
}
// 4 函数有多个参数，没有返回值--》参数中有同一种类型，可以简写成
//func test4(name string,hobby string,age int) {
func test4(name, hobby string, age int) {
fmt.Println(name, age, hobby)
}
// 5 函数有参数，有返回值--->声明返回值类型--》回忆python typing模块
func test5(a, b int) int {
//func test5(a, b int) (int) {
fmt.Println(a + b)
return a + b
}
// 6 函数有参数，有多个返回值--->
func test6(a,b int )(int ,int,int) {
return a+b,a*b,a-b
}
func main() {
//1 函数定义1 ：没有参数没有返回值---》使用
//test()
// 2 函数有一个参数，没有返回值--->调用
//test2("lqz")
//test2(name="lqz") // 只有python有
// 3 函数有多个参数，没有返回值--》调用
//test3("lqz",19,"篮球")
// 4 函数有多个参数，没有返回值--》参数中有同一种类型，可以简写成--》调用
//test4("lqz","篮球",19)
// 5 函数有参数，有返回值--->声明返回值类型---》调用
//var res int
//var res int =test5(30,40)
//var res =test5(30,40)
//res := test5(30, 40) // := 是一家不能 分开
//fmt.Println(res)
// 6 函数有参数，有多个返回值--->调用-->多个返回值必须用多个变量接收，不能用一个
//res1,res2,res3:=test6(40,20)
//var res1,res2,res3=test6(40,20)
//fmt.Println(res1,res2,res3)
// 有的时候只想要两个返回值 _表示忽略
res1,res2,_:=test6(40,20)
fmt.Println(res1,res2)
//fmt.Println(_) //go 不是一个变量， python 中 _ 就是个变量
/*python支持，go不支持
_=10
print(_)
*/
}
补充位运算
&：按位与：两位都为1,结果为1,否则为0
a = 60 # 二进制位 0011 1100
b = 13 # 二进制位 0000 1101
'''
a&b 按位与：两位都为1,结果为1,否则为0
a 0011 1100
b 0000 1101
二进制结果 0000 1100
十进制结果 12
'''
print(a & b)
|：按位或：只要有一位为1，结果就为1
'''
a|b 按位或：有一位为1，就是1，否则是0
a 0011 1100
b 0000 1101
二进制结果 0011 1101
十进制结果 61
'''
print(a | b)
^：按位异或：两对应的二进位相异时，结果为1
'''
a^b 两对应的二进位相异时，结果为1
a 0011 1100
b 0000 1101
二进制结果 0011 0001
十进制结果 49
'''
print(a | b)
~： 按位取反,即把1变为0,把0变为1，相当于（-x-1）
'''
a 0011 1100
~a 1100 0011
十进制结果 -61
'''
print(~a)
<<：左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。
'''
<< 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0
a 0011 1100
a << 2 1111 0000
十进制结果 240
'''
print(a << 2)
a*2的移动次方
60*2的3次方
>>：右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
'''
>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
a 0011 1100
a >> 2 0000 1111
十进制结果 15
'''
print(a >> 2)
a/2的移动次方
60/4
