python转go学习笔记———数组、切片和map

数组和切片

数组

func main() {
	//定义数组
	var array [3]int
	//数组赋值
	array[0] = 1
	array[1] = 1
	array[2] = 1
	fmt.Println(array)
}
//[1 1 1]

定义数组

func main() {
	var array01 [3]int = [3]int {1,2,3}
	var array02 = [3]int {1,2,3}
	var array03 = [...]int {1,2,3}
	//指定元素值对应的下标
	var name = [3]string {1:"tom",2:"flandre",0:"翠花"}
}

遍历数组（和python一样）

for index,value := range array {
    ....
}

注意事项

1. 数组长度是固定的，不能动态变化
2. 数组中元素可以是任何数据类型，但是值类型和引用类型不能混用
3. 数组创建后，若没有赋值会有默认值（0,"",false）
4. go的数组属值类型，默认情况下是值传递，会进行值拷贝
5. 如果在其他函数中，去修改原来的数组，可以使用引用传递(指针)

数组反转

//要求：随机生成5个数，并将其反转打印
func main() {
	var array [5]int
	rand.Seed(time.Now().Unix())
	for i := 0; i<len(array); i++ {
		array[i] = rand.Intn(100)
	}
	fmt.Println(array)
	temp := 0
	for i := 0;i <len(array)/2;i++ {
		temp = array[len(array)-1-i]
		array[len(array)-1-i] = array[i]
		array[i] = temp
	}
	fmt.Println(array)
}

切片

python中也有切片，但是在go中切片是一种数据类型，用于保存一组数据但是数据长度不确定的情况。切片是一种引用类型，切片长度可以变化，相当于是动态数组

var slice01 []int   	//声明切片
slice := array[1:3]  	//[1:3]左闭右开

func main() {
	var array = [5]int{1,22,333,44,5}
	slice := array[1:3]

	fmt.Println("array = ",array)					// [1 22 333 44 5]
	fmt.Println("slice = ",slice)					// [22 333]
	fmt.Println("len(slice) = ",len(slice))			// 2
    fmt.Println("slice.capacity=",cap(slice))		// 4 (一般是长度的两倍，会动态变化)
}

切片的使用

1. 定义一个切片，用切片去引用一个创建好的数组
2. 通过make来创建切片
3. 定义一个切片，直接指定具体的数组，原理类似make

var strSlice []string = []string{"flandre","翠花"}

方式一和方式二的区别：

方式一是直接引用数组，数组存在；方式二是通过make创建切片，make也会创建一个数组，切片在底层进行维护。

切片遍历

func main() {
	var array [5]int = [...]int{10,20,30,40,50}
	// 第一种方式：使用常规的for循环遍历切片
	slice := array[1:4] // 20,30,40
	for i := 0;i<len(slice);i++ {
		fmt.Println(i," = ",slice[i])
	}
	// 第二种方式：for-range遍历
	for i,v := range slice {
		fmt.Println("i = ",i,"v = ",v)
	}
}

使用append函数对切片动态追加

var array []int = []int{10,20,30,40,50}
array_1 := append(array,60,70,80)		//[10 20 30 40 50 60 70 80]

切片拷贝

func main() {
	var array []int = []int{10,20,30,40,50}
	var slice = make([]int,10)		// [0 0 0 0 0 0 0 0 0 0]
	fmt.Println(slice)
	copy(slice,array)			
	fmt.Println(slice)				// [10 20 30 40 50 0 0 0 0 0]
}

• string和slice
  • string底层是一个byte数组，所以slice可以进行切片处理
  • string是不可变的，不能通过str[]="z"来修改字符串
  • 若修改字符串，string—>[]byte或[]rune—>修改—>string

func main() {
    // 转换成[]byte,该方法不能转中文
	str := "hello@flandre!"
	array := []byte(str)
	array[5] = '!'
	str = string(array)
	fmt.Println(str)		// hello!flandre!
    
    // 转换成[]rune
    array := []rune(str)
	array[0] = '我'
	str = string(array)
	fmt.Println(str)		// 我ello@flandre
}

二维数组

var arr_1 [4][6]int  // 4行6列的二维数组
var arr_2  = [2][3]int{{1,2,3},{4,5,6}}	//赋值

二维数组遍历

func main()  {
	var arr = [2][3]int{{1,2,3}, {4,5,6}}
	// 第一种方式：使用常规的for循环遍历切片
	for i:=0;i<len(arr);i++ {
		for j:=0;j<len(arr[i]);j++{
			fmt.Printf("%v\t",arr[i][j])			//1 2 3	 4	5	6	
		}
	}
	fmt.Println()
	// 第二种方式：for-range遍历
	for i,v1 := range arr{
		for j,v2 := range v1{
			fmt.Printf("arr[%v][%v]=%v",i,j,v2)		//arr[0][0]=1arr[0][1]=2arr[0][2]=3
		}											//arr[1][0]=4arr[1][1]=5arr[1][2]=6
		fmt.Println()
	}
}

map

是一种key-value数据结构，类似于python的字典

声明map

//1.map[keytype]valuetype
var a =  map[int]string			//此时map=nil
a = make(map[int]string,10)		//使用map前需要用make给map分配数据空间
//2.使用make直接声明
cities := make(map[string]string)
//3.声明，直接赋值
var cc map[string]string = map[string]string{
		"No.3" : "成都",}

slice、map、function不可以做key~!

func main()  {
	var  a  map[int]string
	// 使用map前需要用make给map分配数据空间
	a = make(map[int]string,10)
	a[1] = "翠花"
	a[0] = "flandre"
	fmt.Println(a)		//map[0:flandre 1:翠花]
}

map的crud操作

//增加和更新
map["key"] = value 		//key存在就是更新；不存在就是增加
//删除
delete(map,"key")		//使用内置函数删除，若key不存在，则不操作也不报错
//删除所有的key
c = make(map[string]string)	//遍历所有的key删除或者重新make，原来的map就会被gc回收
//查找
val,ok := cities["No.1"]	//如果存在，ok返回true，否则返回false
if ok {
	fmt.Println("存在值",val)
} else {
	fmt.Println("不存在值")
}

map遍历

for key,value := range myMap{
	fmt.Println("key =",key)
	fmt.Println("value =",value)
}

**map排序：**golang中map是无序的。