【Go】go语言变量类型 常量 函数基础 函数高级 setuptools将python项目打包 前后端联调

昨日回顾

使用setuptools将python项目打包

# 详细：
	python----》setuptools--》whl包结构
	https://zhuanlan.zhihu.com/p/624648232

# 使用setuptools打包
需求：
	1.公司内部写了包，只想公司内部用
	2.我想开源代码出来
	3.公司写好的项目，打包好，发给客户，客户可以直接运行起来

# 我们安装的第三方包都是：whl 结尾的
比如：requests-2.28.2-py3-none-any.whl  

# 我们可以自己打包whl文件
	1.可以传到pypi
	2.发到私有服务器
	3.直接发给对方

# 对方安装whl包：
	-pip install 路径/xxx.whl --->把这个包，项目，装在解释器上
    -这个包会安装在解释器装第三方包的路径：'/Lib/site-packages'
    -import导入即可

# 我们自己的项目打包成whl格式
lqz_books-0.1.1-py3-none-any.whl  # 这是一个django项目打包
pip install lqz_books-0.1.1-py3-none-any.whl

下载的第三方包都是以whl结尾的：

安装whl包：

运行项目：

前后端联调

也就是连接到前端。之前是连接到接口。后端跑在本机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

# 请注意：
	不同类型之间不能进行运算，即使是int和int8也不能运算

	-int8 一个字节表示(8个比特位) 范围： -2的7次方  到  +2的7次方-1
    int8用一个字节表示数字，所以有2的8次方的变化，但是需要一个比特位表示正负，所以int8范围：-128 到 127。
    int8只在内存中申请了1个bytes，int16申请了两个bytes。长度不同，所以两个无法相加。
    python int 有数据（int64）和方法，占用的内存更多，所以运行起来慢。更高级的代码优化：代码和操作系统、cpu亲和。

    -int16 2个字节表      范围： -2的15次方  到  +2的15次方-1
    -同理以此类推

    -int：int很奇怪，如果是32位机器，是int32，如果64位机器是int64。只有编译完，才知道是哪个平台，写int的时候是不知道int的范围的。
    举例：定义了int等于一个很大的数字，在64位机器上编译，可以通过。而在32位机器上编译，报错，原因就是超长了。（编译成int32，然后赋值的时候值大于int32的范围）

# uint  正整数  uint  uint8  uint16   uint32   uint64
	-uint8 一个字节表示(8个比特位) 范围： 0 到  +2的8次方-1
	-uint16 2个字节表示(8个比特位) 范围： 0 到  +2的16次方-1
    -uint：32位机器，是uint32,64位机器是uint64

    定义人的年龄，合适使用：uint8

# 浮点型：表示小数  表示小数后范围不一样
	go		java
	float32： float（单精度）
    float64： double（双精度）
	go语言中没有float.
 float32一般7位左右，float64一般16位左右，根据平台会不同。 

# 复数类型  实部和虚部
    complex64
    complex128

# rune  byte
byte 是 uint8 的别名
rune 是 int32 的别名
uint8 = 8个bit = 1 byte = 可以表示一个英文字母
rune = 可以表示一个字符 = 1个unicode字符最多占4个字节 = int32
这两个可以表示ascii码或者unicode字符。
python中的len函数得到的是字符长度，go中使用len得到的是字节长度。
var a = 'abc中国'
fmt.Println(len(a))
结果：9

# string
	-双引号包裹的：不能换行(使用/n换行)
    -反引号包裹的：可以换行

# go 也有单引号包裹的，它不是字符串
var a = 'c'
fmt.Println(a) // 99
fmt.Println("%T",a) // int32
99是c对应的ascii码

var a = '你'
fmt.Println(a) // 20320
fmt.Println("%T",a) // int32

默认使用int32给你存储这个字符，也可以进行指定用byte存储，但是这样字符就只能写ascii码。

'''
单引号引起来不是字符串，而且只能存一个字符，这个字符用数字表示。
'''

# go注释
单行注释：//
多行注释：/* */

# 布尔类型
	true
    false
在go中做逻辑判断只能用bool判断，不能用数字。
定义bool值未赋值，默认值为false。

代码：

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)

}

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)
//
//}
常量的定义不能使用简略声明，必须带const关键字。

// 变量，常量的作用域范围   (变量只要不再同一个范围内，是可以再定义的，跟python差不多)

var name = "lqz"
//name:="lqz"
func main() {
	//var name = "pyy"
	name="pyy"
	fmt.Println(name)
}

`
在函数外面定义变量的时候，不支持简略声明,必须使用完整声明或类型推导
`

//  LEGB各自代表的含义

// 5 iota关键字的使用  必须用const关键字定义
// iota的值只跟它所在的行有关系，并且iota从0开始自增，也就是第一行的iota为0

// iota的用法一：后续定义的常量会自增，后续的就可以不用等于iota，会自增
const (
	a = iota  // 0
	b		 // 1
	c		 // 2
)

// 写多个iota无效：
const (
	a = iota  // 0
	b		 // 1
	c = iota  // 2
    d 		  // 3
)

// 同时定义多个常量，第二个如果没有赋初值，初值就是上一个的值
const (
	a = 10
	b		// 10
	c		// 10
)

// 只要用了iota，后续的都会自增1，
// iota 放在第几行(从0开始算)，值就是多少，后续的都会自增.
// 如下例子中：lota在第3行，所以d等于3。iota跟前面的赋值没有关系。
const (
	a = 10
	b			// 10
	c			// 10
	d = iota	// 3
	e		    // 4
)

func main() {
	fmt.Println(c)
}
// 从1开始自增：
package main

import "fmt"

const (
 c0 = iota + 1
 c1
 c2
)

// 跳过空白值
func main() {
 fmt.Println(c0, c1, c2) // Print : 1 2 3
}

package main

import "fmt"

const (
 c1 = iota + 1
 _
 c3
 c4
)

func main() {
 fmt.Println(c1, c3, c4) // Print : 1 3 4
}
// iota可以用来实现枚举类型

// iota定义数量级 结合位运算
const(
    _  = iota
    KB = 1 << (10*iota) // 1 << 10 相当于 1024
    MB  // 左移20位
)
1相当于 : 0000000001 --左移10位-->   1000000000

go语言中const定义的是常量，常量不允许更改。

常量可以一次性定义多个。

iota可以自增的声明常量：

编辑器的提示：

后续无需再写Iota也会自增：

同时定义多个常量，会依赖于上面的常量的值：

如果又使用了iota:

只要使用了iota，后续的都会自增。iota和赋值没有关系，而是这个iota放在第几行，iota的值就是多少。这个值是从0开始的：

通过这个iota可以实现枚举类型。iota还可以和位运算结合使用。

3 函数基础

package main

import "fmt"

// 函数

func main() {
	//1 调用普通函数
	//test()  // 在go语言中无需'先定义再使用'，这跟Python不一样。因为go是编译型语言，在编译的过程中会去查找是否有该函数。

	// 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一个函数可以有两个return吗？
在Go中，一个函数可以拥有多个return语句，但需要注意的是，所有的return语句必须返回相同的类型（或者兼容的类型，比如可以隐式转换的类型），这样才能保持函数的类型一致性。

go是编译型语言，所以不存在python先定义再调用这个问题：

有参数的函数，必须指定参数类型。传入参数也必须要传入这个类型，类型必须严格一致，有几个值必须传几个值。go语言只有位置传参，没有关键字传参。

多个参数是同一个类型，可以简写代码：

只有一个返回值：

需要指名返回值的类型。

接受返回值：

多个返回值：

接受多个返回值：

go语言必须使用多个返回值接受，python可以使用*这种语法解包接受，获得一个包含多个返回值的元组。

接受返回值的时候，有些返回值不想使用，但是不用又会报错：

可以使用下划线忽略不想要的变量。python中的_是一个变量，可以打印出这个变量的值。而go语言不能打印_，就是一个空白：

4 函数高级

# 同一个包下，变量，函数只能定义一次
# 多个go文件，处于一个包下，这些文件相当于公用一个全局命名空间，其中变量，函数都只能定义一次。

# 匿名函数：函数没有名字，一般定义在其他函数内部
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("我是内层函数")
//	//}
//	var 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实现排序算法