go：go语言变量基本类型、常量、函数基础、函数高级
一、go语言变量基本类型
Go语言的基本类型包括：
- 整型（int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、uintptr）
- 浮点型（float32、float64）
- 复数型（complex64、complex128）
- 布尔型（bool）
- 字符串型（string）
- 字符型（rune）
int ：有符号的整数类型，具体占几个字节要看操作系统的分配，不过至少分配给32位。
uint：非负整数类型，具体占几个字节要看操作系统的分配，不过至少分配给32位。
int8：有符号的整数类型，占8位bit，1个字节。范围从负的2的8次方到正的2的8次方减1。
int16：有符号的整数类型，占16位bit，2个字节。范围从负的2的16次方到正的2的16次方减1。
int32：有符号的整数类型，占32位bit，4个字节。范围从负的2的32次方到正的2的32次方减1。
int64：有符号的整数类型，占64位bit，8个字节。范围从负的2的64次方到正的2的64次方减1。
uint8:无符号的正整数类型，占8位，从0到2的9次方减1.也就是0到255.
uint16：无符号的正整数类型，占16位，从0到2的8次方减1.
uint32：无符号的正整数类型，占32位，从0到2的32次方减1.
uint64：无符号的正整数类型，占64位，从0到2的64次方减1.
uintptr：无符号的储存指针位置的类型。也就是所谓的地址类型。
rune ：等于int32，这里是经常指文字符。
byte：等于uint8，这里专门指字节符
string：字符串，通常是一个切片类型，数组内部使用rune
双引号包裹的字符串：不能换号，反引号包裹的字符串：可以换行，go中也有单引号包裹的字符串，它不是字符串，相当于是获取了对应字符的
float32：浮点型，包括正负小数，IEEE-754 32位的集合
float64：浮点型，包括正负小数，IEEE-754 64位的集合，表示小数后范围不一样
complex64，复数，实部和虚部是float32
complex128，复数，实部和虚部都是float64
error，错误类型,真实的类型是一个接口。
bool，布尔类型，是小写的：true，false
ps：
byte 是 uint8 的别名
rune 是 int32 的别名
操作代码
package main
import "fmt"
// 变量类型
func main() {
// 1 数字类型 都是表示整数，区别就是表示范围不一样
//var a int = 9
//var a1 int8 = -128
//var a2 int16 = 99
//var a3 int32 = 99
//var a4 int64 = 99
//fmt.Println(a, a1, a2, a3, a4)
////fmt.Println(a+a1)
//var a5 uint = 255
// 2 float类型
//var a float32 = 1.12345678901234567 // 7 位
//var a1 float64 = 1.12345678901234567 // 16位
//fmt.Println(a)
//fmt.Println(a1)
//3 复数类型
//var c complex64
//var c complex128
//c := 6 + 7i
//c1 := 5 + 4i
//fmt.Println(c + c1)
//var s = "lqz中国"
//fmt.Println(len(s))
// 4 字符串类型
// var name = "lqz is handsome\n" +
// "hello"
// fmt.Println(name)
//
// var s string = `lqz is handsome
// hello
//world
//好`
// fmt.Println(name)
// fmt.Println(s)
//var a = 'c' // int32 放一个字符，但是是用数字表示
//var a rune = '你'
//var a byte = 'c'
//fmt.Println(a)
//fmt.Printf("%T", a)
// 5 布尔类型
//var b bool = false
var b bool
//b = true
fmt.Println(b)
}
二、常量
ps：在我们创建一个新的go文件测试常量的时候时，有时候我们会发现出现名称冲突的情况，但是当前文件内又没有名称重复出现，这是因为package 都是main导致的，同一个package下的变量或常量可以看成是python中同一个文件中的变量
package main
import "fmt"
//1 常量：恒定不变的变量，一旦定义，值固定了，不允许修改 const关键字定义的变量
//func main() {
//
// // 定义常量 const
// //const name string="lqz"
// const name ="lqz"
// fmt.Println(name)
//
//}
//3 变量，常量的作用域范围 (变量只要不再同一个范围内，是可以再定义的)
// name:="lqz"
//func main() {
// //var name = "pyy"
// name = "pyy"
// fmt.Println(name)
//
//}
//4 常量可以一次性定义多个
//const name,age = "lqz","19"
//const (
// name string="lqz"
// age int =19
//)
// 5 iota的使用 必须用const关键字
// 同时定义多个常量，第二个如果没有赋初值，初值就是上一个的值
// iota的用法一：后续定义的常量会自增，后续的就可以不用等于iota，会自增
// 只要用了iota，后续的都会自增1，
// iota 放在第几行，值就是多少，后续的都会自增
// 如果某一行被一个下划线替代了，表示跳过这一个不想要的值
const (
a = 10
b
c
d = iota
_
e
)
func main() {
fmt.Println(c)
}
三、函数基础
在介绍函数的时候，解释型语言跟编译型语言有所不同。python中，函数被调用的位置，如果在定义函数的带代码上方，会因为找不到那个函数而报错，go 这样的编译型语言中没有这个问题，放在被调用代码的后面一样可以运行工
package main
import "fmt"
// 函数
func main() {
//1 调用普通函数
//test()
// 2 调用有参数的函数 (类型必须严格一致，有几个值就传几个值，按位置，没有关键字传参)
//test1(11, "lqz")
// 3 调用简写的有参函数
//test2(11, 12, "lqz")
// 4 调用有返回值的函数
//res := test3(1, 2)
//var res = test3(1, 2)
//var res int= test3(1, 2)
//fmt.Println(res)
//test3(3, 4)
// 5 调用多个参数，多个返回值的函数 必须用多个接收,有几个就要用几个变量接收，不能多不能少
//res1, res2, res3 := test4(5, 6)
//fmt.Println(res1)
//fmt.Println(res2)
////fmt.Println(res3)
// 5.1 就不想要第三个参数，后面不会用第三个参数
//_, _, res1 := test4(5, 6) // 忽略掉第三
//fmt.Println(res1)
////fmt.Println(res2)
////fmt.Println(res3)
//fmt.Println(_) //不能当变量用，就是个空白
}
// 1 定义普通函数，没有参数，没有返回值
func test() {
fmt.Println("我是普通函数")
}
// 2 有参数的函数,必须指定参数类型
func test1(a int, b string) {
fmt.Println(a)
fmt.Println(b)
}
// 3 有参数的函数，多个参数，类型一致可以简写 （go语言想发设法让你少写代码）
//func test2(a, b int, c string) {
// fmt.Println(a)
// fmt.Println(b)
// fmt.Println(c)
//}
// 4 既有参数，又有返回值的 ,只有一个返回值的，需要指明返回值类型
func test3(a, b int) int {
return a + b
}
// 5 多个参数，多个返回值
func test4(a, b int) (int, int, string) {
return a + b, a * b, "成功"
}
四、函数高级
同一个包下，变量，函数只能定义一次
匿名函数：函数没有名字，一般定义在其他函数内部
f := func() {
}
package main
import "fmt"
// 函数高级
func main() {
// 1 匿名函数
//test5()
// 2 匿名函数赋值给变量
//test6()
// 3 调用函数，返回闭包函数
res := test7()
fmt.Println(res) //0x68de00 内存地址
res()
}
// 1 匿名函数加括号直接调用
func test5() {
func() {
fmt.Println("我是内层函数")
}()
}
// 2 匿名函数赋值给一个变量--->函数是一种类型---》在go中，函数又称一等公民（可以赋值给变量的都叫一等公民），又叫头等函数，一等函数
//func test6() {
// //f:=func() {
// // fmt.Println("我是内层函数")
// //}
// // f 类型是什么呀？完整定义，写类型
// var f func() = func() {
// fmt.Println("我是内层函数")
// }
// fmt.Printf("%T", f) // func()
//
//}
// 3 函数是一等公民，是一种类型---》函数的参数和返回值都是类型的一部分
//func test6() {
// var f func() = func() {
// fmt.Println("我是内层函数")
// }
// var f1 func(int) int = func(a int) int {
// 函数的类型由参数的类型和返回值的类型一同组成
// fmt.Println(a)
// return 10
// }
// var f2 func(int) string = func(c int) string {
// fmt.Println(a)
// return "10"
// }
// fmt.Printf("%T\n", f)
// fmt.Printf("%T", f1)
// f2(1)
//}
// 闭包函数
func test7() func() {
//return func() {
// fmt.Println("我是内存函数")
//}
t := 10
f := func() {
fmt.Println(t)
fmt.Println("我是内存函数")
}
return f // 闭包函数
}
ps：如果研究不明白，或者想偷懒，直接用冒号加等于号绑定匿名函数即可，这样就省略了函数类型的编写
五、作业
1、python 的collections包下有哪些类型
collections 是 python 的内置模块，提供了很多方便且高性能的关于集合的操作，掌握这些知识有助于提高代码的性能和可读性
参考博客：https://www.cnblogs.com/zhihuanzzh/p/16807316.html#四常用内置模块
2、python实现排序算法
参考博客：https://zhuanlan.zhihu.com/p/452098057
Python可以使用多种排序算法进行排序，以下是常见的几种排序算法的Python实现代码：
- 冒泡排序（Bubble Sort）：
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr
- 选择排序（Selection Sort）：
def selection_sort(arr):
n = len(arr)
for i in range(n):
min_idx = i
for j in range(i+1, n):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
return arr
- 插入排序（Insertion Sort）：
def insertion_sort(arr):
n = len(arr)
for i in range(1, n):
key = arr[i]
j = i-1
while j >= 0 and key < arr[j]:
arr[j+1] = arr[j]
j -= 1
arr[j+1] = key
return arr
- 快速排序（Quick Sort）：
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[0]
left = []
right = []
for i in range(1, len(arr)):
if arr[i] < pivot:
left.append(arr[i])
else:
right.append(arr[i])
return quick_sort(left) + [pivot] + quick_sort(right)
