1、go语言的数组和python的列表不一样，python的列表没有限定类型，而go的数组限定的类型，理由是这样的，请看下面的图
go语言的数组会数组中第一个值的内存地址，在我们上面的例子中，数组中的元素是整型，一个整型占4个字节，那么第一个值的内存地址起始地址比如是0x25，那么第二个值的内存起始地址就是0x29，这样以此类推，我们就可以拿到这个数组中的所有的值，这也是为什么go语言不支持不同类型的值在一个数组中的缘故
在看我们的python，python的内部会在维护一个数组，这个数组是数组中每个元素的内存地址，这样，就可以使得python的数组支持不同类型的元素，因为他实际维护了2个数组，一个是真正数据的数组，一个是真正数据的内存地址的数组
通过上面的解释，大家应该知道为什么python的列表支持不同类型了吧，同样带来的后果肯定是更大的内存消耗和更大的性能消耗
2、go语言的数组
package main
import "fmt"
//go语言的数组类似python中的列表
//申明数组
//var 数组名[数组长度] 数组类型
//数组的长度定好之后不能修改
//go语言的数组定义了类型，就只能存储这种类型，不能存储其他类型
func main() {
//首先定义一个一维数组
//定义一个int类型的数组
var arr1 [5] int
//申明加赋值数组
arr2 := [5]int{1,2,3,4,5}
//可以省略大小
arr3 := [...]int{1,2,3,4,5}
arr4 := [10]int{1,2,3,4,5}
fmt.Println(arr1,arr2,arr3,arr4)
//[0 0 0 0 0] [1 2 3 4 5] [1 2 3 4 5] [1 2 3 4 5 0 0 0 0 0]
//定义一个二维数组,四行五列的数组，一般也用的比较少
var grid [4][5] int
fmt.Println(grid)
//[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]
//数据的遍历，一个for一个range
//方式1
for i :=0;i < len(arr3);i++{
fmt.Println(i,arr3[i])
}
//方式2
for i := range arr3 {
fmt.Println(i,arr3[i])
}
for i,v := range arr3 {
fmt.Println(i,v)
}
}
3、go语言的数组是值类型，不是引用
package main
import "fmt"
func printArr(arr [5]int) {
arr[0] = 100
fmt.Println(arr)
}
func main() {
//var arr1 [5] int
//printArr(arr1)
//[100 0 0 0 0]
//fmt.Println(arr1)
//[0 0 0 0 0]
//报错
//arr2 := [3]int{1,2,3}
//printArr(arr2)
// .\test20.go:23:10: cannot use arr2 (type [3]int) as type [5]int in argument to printAr
arr3 := [...]int{1,2,3,4,5}
printArr(arr3)
//[100 2 3 4 5]
fmt.Println(arr3)
//[1 2 3 4 5]
}
上面的例子中我们传递一个数组给函数，在函数中修改了这个数组中的值，对原来的数组是没有影响的，说明传递进去的数组是一个全新的数组，和原来的数组没有关系
4、一个函数接受一个指针作为参数
//这个函数接受一个指针作为参数
func printArr2(arr *[5]int) {
arr[0] = 100
fmt.Println(*arr)
}
调用这个函数
arr3 := [...]int{1,2,3,4,5}
//printArr(arr3)
//[100 2 3 4 5]
//fmt.Println(arr3)
//[1 2 3 4 5]
//如果传递一个指针进去，则在函数中修改这个指针指向的数组，外面的数组也会同步修改
printArr2(&arr3)
fmt.Println(arr3)
结果如下
[100 2 3 4 5]
[100 2 3 4 5]
菜鸟教程中的数组的讲解
Go 语言数组
Go 语言提供了数组类型的数据结构。
数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。
相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。
数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。
声明数组
Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：
var variable_name [SIZE] variable_type
以上为一维数组的定义方式。例如以下定义了数组 balance 长度为 10 类型为 float32：
var balance [10] float32
初始化数组
以下演示了数组初始化：
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
该实例与上面的实例是一样的，虽然没有设置数组的大小。
balance[4] = 50.0
以上实例读取了第五个元素。数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为 1，以此类推。
访问数组元素
数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。例如：
var salary float32 = balance[9]
以上实例读取了数组balance第10个元素的值。
以下演示了数组完整操作（声明、赋值、访问）的实例：
package main
import "fmt"
func main() {
var n [10]int /* n 是一个长度为 10 的数组 */
var i,j int
/* 为数组 n 初始化元素 */
for i = 0; i < 10; i++ {
n[i] = i + 100 /* 设置元素为 i + 100 */
}
/* 输出每个数组元素的值 */
for j = 0; j < 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j] )
}
}
以上实例执行结果如下：
Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
数组初始化
初始化数组的初始化有多种形式。
[5] int {1,2,3,4,5}
长度为5的数组，其元素值依次为：1，2，3，4，5。
[5] int {1,2}
长度为 5 的数组，其元素值依次为：1，2，0，0，0 。
在初始化时没有指定初值的元素将会赋值为其元素类型 int 的默认值0，string 的默认值是 ""。
[...] int {1,2,3,4,5}
长度为 5 的数组，其长度是根据初始化时指定的元素个数决定的。
[5] int { 2:1,3:2,4:3}
长度为 5 的数组，key:value，其元素值依次为：0，0，1，2，3。在初始化时指定了 2，3，4 索引中对应的值：1，2，3
[...] int {2:1,4:3}
长度为5的数组，起元素值依次为：0，0，1，0，3。由于指定了最大索引 4 对应的值 3，根据初始化的元素个 数确定其长度为5赋值与使用。
切片的初始化
切片可以通过数组来初始化，也可以通过内置函数 make() 初始化。
初始化时 len=cap，在追加元素时如果容量 cap 不足时将按 len 的 2 倍扩容。
s :=[] int {1,2,3 } 直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3。其 cap=len=3。
s := arr[:] 初始化切片 s，是数组 arr 的引用。
s := arr[startIndex:endIndex] 将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。
s := arr[startIndex:] 缺省 endIndex 时将表示一直到 arr 的最后一个元素。
s := arr[:endIndex] 缺省 startIndex 时将表示从 arr 的第一个元素开始。
s1 := s[startIndex:endIndex] 通过切片 s 初始化切片 s1
s :=make([]int,len,cap) 通过内置函数 make() 初始化切片 s,[]int 标识为其元素类型为 int 的切片。
复习代码
package main
import "fmt"
//该函数接受一个数组作为参数，在函数中修改数组，不会对函数外面的数组产生影响
func func_test4_1(a [5] int) {
a[0] = 1000
fmt.Println(a)
}
//该函数接受一个数组指针作为参数，在函数中修改数组，会对函数外面的数据产生影响
func func_test4_2(a * [5] int) {
a[0] = 1000
fmt.Println(a)
}
func main() {
var test4_1 [5] int
fmt.Println(test4_1)
test4_2 := [5] int {0,1,2,3,4}
fmt.Println(test4_2,len(test4_2),cap(test4_2))
test4_3 := [...] int {0,1,2,3,4}
fmt.Println(test4_3,len(test4_3),cap(test4_3))
for k := 0;k < len(test4_3);k ++ {
fmt.Println(test4_3[k])
}
//如果有两个参数接受，那么这里的k是索引，v是指
for k,v := range test4_3 {
fmt.Println(k,v)
}
//如果有一个参数接受，那么这个参数就是k
for k:= range test4_3 {
fmt.Println(k)
}
fmt.Println(test4_3)
//[0 1 2 3 4]
func_test4_1(test4_3)
//[1000 1 2 3 4]
fmt.Println(test4_3)
//[0 1 2 3 4]
func_test4_2(&test4_3)
//&[1000 1 2 3 4]
fmt.Println(test4_3)
//[1000 1 2 3 4]
}
