昨日回顾
使用setuptools将python项目打包
# https://zhuanlan.zhihu.com/p/624648232
# python----》setuptools--》whl包结构
公司内部写了包---》公司内部用---》开源出来
公司写好的项目，打包好，发给客户，客户可以直接运行起来
# 你们下的第三方包都是：requests-2.28.2-py3-none-any.whl whl 结尾的
# 我们做好的---》可以传到pypi，私有服务，直接发给对方
-pip install 路径/xxx.whl --->把这个包，项目，装在我们自己的解释器上了
-import导入即可
# 我们自己的项目打包成whl格式--》分发---》图书馆里系统---》django写的
# lqz_books-0.1.1-py3-none-any.whl
# pip install lqz_books-0.1.1-py3-none-any.whl
下载的第三方包都是以whl结尾的：
在项目根路径安装我们打好的包：
这个包会安装到site-packeages，我们进入这个路径启动项目即可。
前后端联调
也就是连接到前端。之前是连接到接口。后端跑在本机0.0.0.0上面就行了，需要给前端你的ip地址。
先ping下能不能ping通 关掉防火墙 随便写一个服务监听5000端口 看看是程序的问题还是网络的问题。
docker-compose起不来，查看端口。
ping用来测试网络通不通 telnet用来测试端口通不通 curl测试能不能访问到端口服务
# go 介绍---》编译型强类型
# 开发环境搭建---》
-go sdk：1.20.x
-编辑器：goland，vscode
# 第一个helloworld
- go 必须属于一个包
- go项目要运行，必须有入口 main包下的main函数
- fmt.Println("hello world")
- 编译： go build s1.go 可执行文件
- 执行 （跨平台编译，交叉编译）
-包导入必须要使用，不使用会报错 goland自动删除不用的包
-go run s1.go 编译并运行
-右键编译并运行
# 变量定义规范
-25关键字：for if return func ...
-37个保留字:
-内置函数：panic
-内置类型：int string
-true false nil iota
-变量，函数名建议用驼峰
-文件名建议用下划线
# 变量的定义
-三种方式定义变量
-完整定义 var 变量名 类型 =值
-类型推导 var 变量名 = 值
-简略声明 变量名 :=变量值
-同时定义多个变量
-变量不能重复定义
-变量类型是固定的，不能改变
-变量定义了必须使用，不使用会报错
今日内容
1 go语言变量类型
# 数字
# int 整数有正负 int8 int16 int32 int64
java byte short int long
-int8 一个字节表示(8个比特位) 范围： -2的7次方 到 +2的7次方-1
-int16 2个字节表 范围： -2的15次方 到 +2的15次方-1
-同理以此类推
-int：32位机器，是int32,64位机器是int64
# uint 正整数 uint uint8 uint16 uint32 uint64
-uint8 一个字节表示(8个比特位) 范围： 0 到 +2的8次方-1
-uint16 2个字节表示(8个比特位) 范围： 0 到 +2的16次方-1
-uint：32位机器，是uint32,64位机器是uint64
# 浮点型：表示小数 表示小数后范围不一样
float32：
float64：
# 复数类型 实部和虚部
complex64
complex128
# rune byte
byte 是 uint8 的别名
rune 是 int32 的别名
# string
-双引号包裹的：不能换号
-反引号包裹的：可以换行
# go 也有单引号包裹的，它不是字符串
# 布尔类型
true
false
int和int8不能做运算。说明go是强类型语言。
nt8可以只能表示到-128到127
int 和 int8在内存中申请了不同的空间：
长度不一样，所以不能相加。
python的整型不仅仅存储了值，还存储了各种内置方法。
写的代码和cpu要亲和。
int写的时候不知道他的类型。只有编译之后才知道是int32还是int64，他是根据你的机器来的。
java的四种整数类型：
byte short int long
int8 int16 int32 int64
float32 float
float64 double
python中可以区分出字符串中的英文字符和中文字符，返回真正的字符长度。go无法区别字符长度，而是返回字节长度。
字符串类型，需要使用双引号：
使用单引号定义不是字符串，只能放一个字符，存储的时候存储的是数字。byte用于存储ascii码字符，rune用于存储各种字符包括中文。
使用单引号存储汉字：
使用byte存储ascii码字母：
布尔类型：
定义但是不赋值：
在全局定义变量不支持:=这种定义方式。可以使用完整定义或者类型推导。
2 常量
package main
import "fmt"
// 常量：恒定不变的变量，一旦定义，值固定了，不允许修改 const关键字定义的变量
//func main() {
//
// // 定义常量 const
// //const name string="lqz"
// const name ="lqz"
// fmt.Println(name)
//
//}
// 变量，常量的作用域范围 (变量只要不再同一个范围内，是可以再定义的)
var name = "lqz"
//name:="lqz"
func main() {
//var name = "pyy"
name="pyy"
fmt.Println(name)
}
// LEGB各自代表的含义
// 5 iota的使用 必须用const关键字
// 同时定义多个常量，第二个如果没有赋初值，初值就是上一个的值
// iota的用法一：后续定义的常量会自增，后续的就可以不用等于iota，会自增
// 只要用了iota，后续的都会自增1，
// iota 放在第几行，值就是多少，后续的都会自增
const (
a = 10
b
c
d = iota
e
)
func main() {
fmt.Println(c)
}
go语言中const定义的是常量，常量不允许更改。
常量可以一次性定义多个。
iota可以自增的声明常量：
编辑器的提示：
后续无需再写Iota也会自增：
同时定义多个常量，会依赖于上面的常量的值：
如果又使用了iota:
只要使用了iota，后续的都会自增。iota和赋值没有关系，而是这个iota放在第几行，iota的值就是多少。这个值是从0开始的：
通过这个iota可以实现枚举类型。iota还可以和位运算结合使用。
3 函数基础
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, "成功"
}
go是编译型语言，所以不存在python先定义再调用这个问题：
有参数的函数，必须指定参数类型。传入参数也必须要传入这个类型，类型必须严格一致，有几个值必须传几个值。go语言只有位置传参，没有关键字传参。
多个参数是同一个类型，可以简写代码：
只有一个返回值：
需要指名返回值的类型。
接受返回值：
多个返回值：
接受多个返回值：
go语言必须使用多个返回值接受，python可以使用*这种语法解包接受，获得一个包含多个返回值的元组。
接受返回值的时候，有些返回值不想使用，但是不用又会报错：
可以使用下划线忽略不想要的变量。python中的_是一个变量，可以打印出这个变量的值。而go语言不能打印_，就是一个空白：
4 函数高级
# 同一个包下，变量，函数只能定义一次
# 匿名函数：函数没有名字，一般定义在其他函数内部
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 // 闭包函数
}
同一个包内定义的名字不能重复：
匿名函数：
或者：
匿名函数加括号直接调用：
匿名函数的类型是什么？
查看类型：
函数是一种类型，这种类型叫func()类型：
函数是一等公民可以将函数赋值给变量。可以赋值给变量的都叫一等公民，又叫头等函数。
函数的参数和返回值都是类型的一部分:
函数的类型可以自行推导：
也就是说函数的传参，还有返回值值不一样，可以说这两个函数就不是一个类型。
不同类型的例子：
在编写的时候就把很多错误给屏蔽了。
闭包函数：
接收闭包函数：
补充
# python 的collections包下有哪些类型
-collections是python的内置模块，提供了很多方便且高性能的关于集合的操作，掌握这些知识有助于提高代码的性能和可读性
# python实现排序算法