| python教程分享Go语言学习之数组的用法详解 | 您所在的位置：网站首页 › python数组用法 › python教程分享Go语言学习之数组的用法详解 |
python教程分享Go语言学习之数组的用法详解
|
引言
数组是相同数据类型的一组数据的集合，数组一旦定义长度不能修改，数组可以通过下标（或者叫索引)来访问元素。 相对于去声明 number0, number1, …, number99 的变量，使用数组形式 numbers[0], numbers[1] …, numbers[99] 更加方便且易于扩展。数组元素可以通过索引（位置）来读取（或者修改），索引从0 开始，第一个元素索引为 0，第二个索引为1，以此类推。 
一、数组的定义
1. 语法
var variable_name [size] variable_type
variable_name:数组的名称 size:数组长度，必须是常量 variable_type:数组保存元素的类型 2. 示例 package main import "fmt" func main() { var a [3]int //定义一个int类型的数组a，长度是3 var b [2]string //定义一个字符串类型的数组b，长度是2 fmt.printf("a: %tn", a) //使用%t来输出类型 fmt.printf("b: %tn", b) fmt.printf("a: %vn", a) fmt.printf("b: %vn", b) } //输出结果如下，可以看到没初始化的值，int是0，而字符串则是空的字符串 a: [3]int b: [2]string a: [0 0 0] b: [ ]从上面运行的结果中可以看出来，数组和长度和元素类型共同组成了数组的类型 二、数组的初始化初始化，就是给数组的元素赋值，没有初始化的数组，默认元素值都是零值，布尔类型是false，字符串是空字符串。 1. 未初始化的数组 package main import "fmt" func main() { var a [2]bool var b [2]int var c [3]string var d [3]float32 fmt.printf("a: %vn", a) fmt.printf("b: %vn", b) fmt.printf("c: %vn", c) fmt.printf("d: %vn", d) } //输出结果如下 a: [false false] b: [0 0] c: [ ] d: [0 0 0] 2. 使用初始化列表 package main import "fmt" func main() { var a = [3]int{1, 2, 3} var b = [2]string{"hello world"} var c = [2]bool{true, false} a1 := [2]int{1, 2} //类型推断 fmt.printf("a: %vn", a) fmt.printf("b: %vn", b) fmt.printf("c: %vn", c) fmt.printf("a1: %vn", a1) } //输出结果如下 a: [1 2 3] b: [hello world ] c: [true false] a1: [1 2]使用初始化列表，就是将值写在大括号里面 3. 省略数组长度如果数组长度不确定，可以使用 ...代替数组的长度，编译器会根据元素个数自行推断数组的长度 package main import "fmt" func main() { var a = [...]int{1, 2, 3, 4, 5} var b = [...]string{"hello", "world", "hello", "go"} var c = [...]bool{true, false} a1 := [...]int{1, 2} //类型推断 fmt.printf("a: %vn", a) fmt.printf("b: %vn", b) fmt.printf("c: %vn", c) fmt.printf("a1: %vn", a1) } //输出结果如下 a: [1 2 3 4 5] b: [hello world hello go] c: [true false] a1: [1 2] 4. 指定索引值的方式来初始化可以通过指定所有方式来初始化，未指定的所有默认值为零值 package main import "fmt" func main() { var a = [...]int{0: 1, 2: 2} var b = [...]string{1: "hello", 2: "go"} var c = [...]bool{2: true, 5: false} a1 := [...]int{1, 2} //类型推断 fmt.printf("a: %vn", a) fmt.printf("b: %vn", b) fmt.printf("c: %vn", c) fmt.printf("a1: %vn", a1) } //输出结果如下 a: [1 0 2] b: [ hello go] c: [false false true false false false] a1: [1 2]总结 初始化数组中{}中的元素个数不能大于[]中的数字。 如果忽略[]中的数字不设置数组大小，go 语言会根据元素的个数来设置数组的大小： 5. 访问数组元素数组元素可以通过索引（位置）来读取。 格式为数组名后加中括号，中括号中为索引的值。数组的最大下标为数组长度-1，大于这个下标会发生数组越界。 示例 package main import "fmt" func main() { var a [2]int a[0] = 100 a[1] = 200 fmt.printf("a[0]: %vn", a[0]) fmt.printf("a[1]: %vn", a[1]) //对数组进行修改 a[0] = 1 a[1] = 2 fmt.println("---------修改后--------") fmt.printf("a[0]: %vn", a[0]) fmt.printf("a[1]: %vn", a[1]) } //输出结果如下 a[0]: 100 a[1]: 200 ---------修改后-------- a[0]: 1 a[1]: 2
6. 根据数组长度遍历数组
可以根据数组长度，通过for循环的方式来遍历数组，数组的长度可以使用len函数获得 使用len()函数获取数组的长度 package main import "fmt" func main() { var a1 = [3]int{1, 2, 3} fmt.printf("len(a1): %vn", len(a1)) var a2 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} fmt.printf("len(a2): %vn", len(a2)) } //输出结果如下 len(a1): 3 len(a2): 9数组遍历，根据长度和下标 package main import "fmt" func main() { a := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} for i := 0; i < len(a); i++ { fmt.printf("a[%d]:%vn", i, a[i]) } } //输出结果如下 a[0]:1 a[1]:2 a[2]:3 a[3]:4 a[4]:5 a[5]:6 a[6]:7 a[7]:8 a[8]:9使用for range package main import "fmt" func main() { var a = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} for i, v := range a { //i也可以使用空白标识符代替，不接受索引的值 fmt.printf("a[%v]:%vn", i, v) } } //输出结果如下 a[0]:1 a[1]:2 a[2]:3 a[3]:4 a[4]:5 a[5]:6 a[6]:7 a[7]:8 a[8]:9 三. 访问数组元素 1. 访问数组元素 数组元素可以通过索引（位置）来读取。 格式为数组名后加中括号，中括号中为索引的值。数组的最大下标为数组长度-1，大于这个下标会发生数组越界。示例 ① package main import "fmt" func main() { var a [2]int a[0] = 100 a[1] = 200 fmt.printf("a[0]: %vn", a[0]) fmt.printf("a[1]: %vn", a[1]) //对数组进行修改 a[0] = 1 a[1] = 2 fmt.println("---------修改后--------") fmt.printf("a[0]: %vn", a[0]) fmt.printf("a[1]: %vn", a[1]) } //输出结果如下 a[0]: 100 a[1]: 200 ---------修改后-------- a[0]: 1 a[1]: 2
示例 ② package main import "fmt" func main() { //声明数组的同时快速初始化数组 balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} //输出数组元素 for i := 0; i < 5; i++ { fmt.printf("balance[i]: %fn", balance[i]) } //输出每个数组元素的值 balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0} for x := 0; x < 5; x++ { fmt.printf("balance2[x]: %fn", balance2[x]) } //将索引为1和3的元素初始化 balance3 := [5]float32{1: 2.0, 3: 7.0} for y := 0; y < 5; y++ { fmt.printf("balance3: %fn", balance3[y]) } } //输出结果如下 balance[i]: 1000.000000 balance[i]: 2.000000 balance[i]: 3.400000 balance[i]: 7.000000 balance[i]: 50.000000 balance2[x]: 1000.000000 balance2[x]: 2.000000 balance2[x]: 3.400000 balance2[x]: 7.000000 balance2[x]: 50.000000 balance3: 0.000000 balance3: 2.000000 balance3: 0.000000 balance3: 7.000000 balance3: 0.000000 2. 根据数组长度遍历数组可以根据数组长度，通过for循环的方式来遍历数组，数组的长度可以使用len函数获得 使用len()函数获取数组的长度 package main import "fmt" func main() { var a1 = [3]int{1, 2, 3} fmt.printf("len(a1): %vn", len(a1)) var a2 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} fmt.printf("len(a2): %vn", len(a2)) } //输出结果如下 len(a1): 3 len(a2): 9数组遍历，根据长度和下标 package main import "fmt" func main() { a := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} for i := 0; i < len(a); i++ { fmt.printf("a[%d]:%vn", i, a[i]) } } //输出结果如下 a[0]:1 a[1]:2 a[2]:3 a[3]:4 a[4]:5 a[5]:6 a[6]:7 a[7]:8 a[8]:9使用for range package main import "fmt" func main() { var a = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9} for i, v := range a { //i也可以使用空白标识符代替，不接受索引的值 fmt.printf("a[%v]:%vn", i, v) } } //输出结果如下 a[0]:1 a[1]:2 a[2]:3 a[3]:4 a[4]:5 a[5]:6 a[6]:7 a[7]:8 a[8]:9 四、冒泡排序1. 控制台输入十名学生的成绩，如果低于60自动修改为60，并最终展示成绩清单 package main import "fmt" func main() { var source [10]float32 //分数 var s float32 //初始化成绩 //遍历数组 for i := 0; i < 10; i++ { fmt.printf("请输入第%d学生的成绩:", i+1) fmt.scan(&s) if s < 60 { //修改为60分 source[i] = 60 } else { //添加学生成绩 source[i] = s } } fmt.println("成绩录入成功！") fmt.println("成绩清单如下") for j := 0; j < 10; j++ { fmt.printf("第%d名学生的成绩", j+1) fmt.println(source[j]) } } //终端输入结果 ps d:goprojectsrcdev_codeday10testmain> go run . 请输入第1学生的成绩:50 请输入第2学生的成绩:55 请输入第3学生的成绩:80 请输入第4学生的成绩:70 请输入第5学生的成绩:90 请输入第6学生的成绩:50 请输入第7学生的成绩:30 请输入第8学生的成绩:44 请输入第9学生的成绩:55 请输入第10学生的成绩:66 成绩录入成功！ 成绩清单如下 第1名学生的成绩60 第2名学生的成绩60 第3名学生的成绩80 第4名学生的成绩70 第5名学生的成绩90 第6名学生的成绩60 第7名学生的成绩60 第8名学生的成绩60 第9名学生的成绩60 第10名学生的成绩662. 随机输入5个数字，求出最大值 package main import ( "fmt" ) func main() { var ( tmp int //用来接收比较出来最大的那个数字 num int //录入的数字 numbers [5]int //5个数字 ) for i := 0; i < 5; i++ { fmt.printf("请输入第%d个数字:", i+1) fmt.scan(&num) //输入的数字添加到集合中 numbers[i] = num } fmt.println("录入成功！") tmp = numbers[0] for j := 0; j < 5; j++ { //比较最大的数，大的那个数用tmp来接收保存，循环的进行比较 if numbers[j] > tmp { //如果是求最小值，把>改为 go run . 请输入第1个数字:888 请输入第2个数字:756 请输入第3个数字:358 请输入第4个数字:218 请输入第5个数字:8489 录入成功！ 最大值: 84893. 冒泡排序 思路 冒泡排序要对一个列表多次重复遍历。它要比较相邻的两项，并且交换顺序排错的项，每对列表进行一次遍历，就有一个最大项排在了正确的位置。 列表的每一个数据项都会在其相应的位置 冒泡。如果列表有 n 项，第一次遍历就要比较 n-1 对数据。 一旦列表中最大的数是所比较的数据对中的一个，它就会沿着列表一直后移，直到这次遍历结束
package main import "fmt" var arr = [...]int{34, 61, 22, 75, 42} func main() { fmt.println("初始值为:", arr) //外循环控制比较的轮数 for j := 0; j < len(arr)-1; j++ { //内循环控制比较的次数 for i := 0; i < len(arr)-j-1; i++ { //内层的每轮比较的次数都-1次 if arr[i] > arr[i+1] { //两数比较以后进行位置交换 arr[i], arr[i+1] = arr[i+1], arr[i] } } } fmt.println("----排序结束----") fmt.println(arr) } //输出结果如下 初始值为: [34 61 22 75 42] ----排序结束---- [22 34 42 61 75]
控制台随机输入几个数，进行冒泡排序 package main import "fmt" var ( numbers int //指定输入的数 arr = []int{} //空数组 ) func main() { for i := 0; i < 5; i++ { fmt.printf("请输入第%d个数字:", i+1) fmt.scan(&numbers) arr = append(arr, numbers) //使用append进行添加数组元素 fmt.println("添加成功") } fmt.println("初始值为:", arr) //外循环控制比较的轮数 for j := 0; j < len(arr)-1; j++ { //内循环控制比较的次数 for i := 0; i < len(arr)-j-1; i++ { //内层的每轮比较的次数都-1次 if arr[i] > arr[i+1] { //两数比较以后进行位置交换 arr[i], arr[i+1] = arr[i+1], arr[i] } } } fmt.println("----排序结束----") fmt.println(arr) } //输出结果如下 请输入第1个数字:88 添加成功 请输入第2个数字:99 添加成功 请输入第3个数字:50 添加成功 请输入第4个数字:146 添加成功 请输入第5个数字:48 添加成功 初始值为: [88 99 50 146 48] ----排序结束---- [48 50 88 99 146] 五、多维数组go 语言支持多维数组，如下 //常用的多维数组声明方式： var variable_name [size1][size2]...[sizen] variable_type //三维的整型数组： var threedim [5][10][4]int 1. 二维数组二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的。 二维数组定义方式如下 var arrayname [ x ][ y ] variable_typevariable_type 为 go 语言的数据类型，arrayname 为数组名，二维数组可认为是一个表格，x 为行，y 为列 下图演示了一个二维数组 a 为三行四列：
二维数组中的元素可通过 a[i][j]来访问 package main import "fmt" func main() { //创建数组 numbers := [][]int{} //使用 append() 函数向空的二维数组添加两行一维数组 x := []int{1, 2, 3} y := []int{4, 5, 6} numbers = append(numbers, x) numbers = append(numbers, y) //显示两行数据，查看二维数组中的第一个数组和第二个数组 fmt.printf("二维数组中的第1个一维数组为: %vn", numbers[0]) fmt.printf("二维数组中的第1个一维数组为: %vn", numbers[1]) fmt.printf("二维数组中的第1个一维数组的第一个元素为: ") fmt.println(numbers[0][0]) //numbers[0]里面的第一个元素[0]，为1 } //输出结果如下 二维数组中的第1个一维数组为: [1 2 3] 二维数组中的第1个一维数组为: [4 5 6] 二维数组中的第1个一维数组的第一个元素为: 1 2. 初始化二维数组多维数组可通过大括号来初始值，以下为一个3行4列的二维数组 a := [3][4]int { {0,1,2,3}, //第1行索引为0 {4,5,6,7}, //第2行索引为1 {8,9,10,11}, //第3行索引为2 }注意，上面的代码中倒数第二行的 }必须有逗号，因为最后一行的 }不能单独一行，也可以写成下面这样 a := [3][4]int { {0,1,2,3}, //第1行索引为0 {4,5,6,7}, //第2行索引为1 {8,9,10,11}} //第3行索引为2示例，初始化一个2行2列的二维数组 package main import "fmt" func main() { //创建二维数组 list := [2][2]string{} //向二维数组中添加元素 list[0][0] = "你好" //第1个一维数组中的第1个元素 list[0][1] = "欢迎" //第1个一维数组中的第2个元素 list[1][0] = "来到" //第2个一维数组中的第1个元素 list[1][1] = "南京" //第2个一维数组中的第2个元素 //输出结果 fmt.println(list) } //输出结果如下 [[你好 欢迎] [来到 南京]] 3. 访问二维数组二维数组通过指定坐标来访问。如数组中的行索引与列索引，例如： //访问二维数组 val 第三行的第四个元素 val := a[2][3] //或 var value int = a[2][3]二维数组可以使用循环嵌套来输出元素 package main import "fmt" func main() { nums := [2][3]int{ {1, 2, 3}, {4, 5, 6}, } //遍历二维数组中的每个元素 //外层循环读取行 for i := 0; i < 2; i++ { //内层循环读取列 for j := 0; j < 3; j++ { fmt.println(nums[i][j]) } } } //输出结果如下 1 2 3 4 5 6创建各个维度元素数量不一致的多维数组 package main import "fmt" func main() { // 创建空的二维数组 list := [][]string{} // 创建三一维数组，各数组长度不同 num1 := []string{"zhang", "wang", "zhao"} num2 := []string{"li"} num3 := []string{"sun", "jin"} // 使用 append() 函数将一维数组添加到二维数组中 list = append(list, num1) list = append(list, num2) list = append(list, num3) // 循环输出 for i := range list { fmt.printf("list: %vn", i) fmt.println(list[i]) } } //输出结果如下 list: 0 [zhang wang zhao] list: 1 [li] list: 2 [sun jin] 六、向函数传递数组如果想向函数传递数组参数，需要在函数定义时，声明形参为数组，可通过如下两种方式来声明： 1. 形参设定数组大小 void myfunction(param [10]int) { . . . } 2. 形参未设定数组大小 void myfunction(param []int) { . . . } 3. 示例函数接收整形数组参数，另一个参数指定了数组元素的个数，并求和 package main import "fmt" //定义数组,有5个元素 var numbers [5]int func main() { numbers = [5]int{10, 20, 30, 40, 50} fmt.println("元素和为:", sum(numbers)) } func sum(arr [5]int) int { //定义求和的变量s s := 0 //求和过程 for i := range arr { s += arr[i] } return s } //输出结果如下 元素和为: 150函数接收整形数组参数，另一个参数指定了数组元素的个数，并求出平均值 package main import "fmt" var ( //数组长度为5 nums = [5]int{10, 20, 40, 60, 80} avg float32 s int ) func main() { //数组作为参数传递给函数 avg = sums(nums, len(nums)) //输出返回的平均值 fmt.printf("平均值为: %f", avg) } //传入数组和他的长度，返回值的类型为float32 func sums(x [5]int, length int) float32 { for i := 0; i < length; i++ { s += x[i] } avg = float32(s) / float32(length) return avg } //输出结果如下 平均值为: 42.000000 总结数组的元素可以通过下标的方式来访问，下标的最大长度为数组长度-1，如果大于这个下标则会越界 遍历数组的两种方法： ① 通过 for循环，长度可以使用len()获取 ② 通过for range循环遍历数组，返回数组下标和对应的值；若不想要下标，可以使用空白标识符_来取代 以上就是go语言学习之数组的用法详解的详细内容，更多关于go语言数组的资料请关注其它相关文章！ 需要了解更多python教程分享Go语言学习之数组的用法详解，都可以关注python教程分享栏目—猴子技术宅（www.ssfiction.com） 本文来自网络收集，不代表猴子技术宅立场，如涉及侵权请点击右边联系管理员删除。 如若转载，请注明出处：https://www.ssfiction.com/pythons/1085901.html |
【本文地址】
公司简介
联系我们