go：go语言变量基本类型、常量、函数基础、函数高级

一、go语言变量基本类型
二、常量
三、函数基础
四、函数高级
五、作业
- 1、python 的collections包下有哪些类型
- 2、python实现排序算法

一、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)

posted @ 2023-04-25 22:17 wwwxxx123 阅读(62) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称：wwwxxx123 园龄：2年5个月粉丝：6 关注：33

昵称： wwwxxx123
园龄： 2年5个月
粉丝： 6
关注： 33

+加关注

只管努力，剩下的都交给时间|

2025年3月

日

一

二

三

四

五

六

wxlxl

go：go语言变量基本类型、常量、函数基础、函数高级

一、go语言变量基本类型

二、常量

三、函数基础

四、函数高级

五、作业

1、python 的collections包下有哪些类型

2、python实现排序算法

公告

搜索

常用链接

随笔档案

阅读排行榜

推荐排行榜

	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)

	}

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

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

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

	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

	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

	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

	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)