go----day02（）

昨日回顾

# 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

# 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

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)
}

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, "成功"
}

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 // 闭包函数
}

作业

# python 的collections包下有哪些类型
	-collections 是 python 的内置模块，提供了很多方便且高性能的关于集合的操作，掌握这些知识有助于提高代码的性能和可读性
    
# python实现排序算法