GO期末考试大纲
一·单选题考点
new—分配内存的数据类型
整型----int64、int32、int16、int8、int（范围跟随操作系统的位数）
浮点型----float32（小数位少）、float64（小数点位多）
布尔类型—bool----结果为两种—true || false
数组类型—[长度]数据类型—[7]int----一个长度为7 的 数组----长度是一个定值—只能存相同的数据类型
结构体----type 结构体名 struct----里面可以放不同的数据类型的数据
make函数----分配内存的数据类型
切片----[ ]数据类型—切片是引用数据类型—分配内存时要用make来分配哦—底层有一个隐藏数组来为切片做支撑----切片通过调用底层数组各个小标的地址来完成数据的呈现
字典----var 字典名 map[key]values----key—指键的数据类型、values-----指的是值的数据类型----定义字典的时候必须给其分配内存-----var 字典名 = make(map[int]int)
[1]：变量的声名【变量的赋值 初始化 变量的命名规范】
var 变量名 数据类型
var 变量名 = 数据
变量名 := 数据
1–1、例子：
package main
import "fmt"
func main(){
var a int=5
var b =2.355
c:=false
fmt.Printf("%T %T %T\n",a,b,c)
fmt.Printf("%d %0.2f %t",a,b,c)
}
1–1、结果
[2]：if和switch的使用【选择结构的执行过程】
if 条件表达式{
语句1
}
//-----------------------单支---//结果为bool类型---条件表达式的结果为true运行语句1
if 条件表达式 {
语句1
}else{
语句2
}
//-----------------------双支---//结果为bool类型---条件表达式的结果为true运行语句1 否则运行语句2
if 条件表达式1 {
语句1
}else if 条件表达式2{
语句2
}else{
语句3
}
//------------------多支--//结果为bool类型---条件表达式 1 的结果为true运行语句1 否则 对 条件表达式2进行判断---如果条件表达式 2 的结果为true 运行 语句2 否则运行 语句3 。
2–1、例子：
package main
import "fmt"
func main(){
{
//-------------------------------------------
//单分支
var a int
fmt.Scanf("%d", &a)
if a > 100 {
fmt.Printf("%d比100大", a)
}
if a<100{
fmt.Printf("%d比100小", a)
}
if a==100{
fmt.Printf("%d就是100", a)
}
fmt.Printf("\n")
}
{
//-------------------------------------------
//双支
var a int
fmt.Scanf("%d",&a)
if a < 0{
fmt.Printf("%d比0小",a)
}else{
fmt.Printf("%d比0大",a)
}
fmt.Printf("\n")
}
//-------------------------------------------
//多分支
{
var a int
fmt.Scanf("%d\n",&a)
if a < 0{
fmt.Printf("%d比0小",a)
}else if a > 100{
fmt.Printf("%d比100大",a)
}else{
fmt.Printf("%d比0大 也 比100小",a)
}
fmt.Printf("\n")
}
//-------------------------------------------
}
2–1、结果
[3]：switch…case
switch 变量 {
case:变量对应的值的情况
case:变量对应的值的情况
default:最后一种最坏的情况 //一般情况下都要有一个default
}
3–1、例子
package main
import "fmt"
func main(){
var a int
fmt.Printf("请输入1--7之间的任意数\n")
fmt.Scanf("%d",&a)
switch a {
case 1 :fmt.Printf("今天是星期一")
case 2 :fmt.Printf("今天是星期二")
case 3 :fmt.Printf("今天是星期三")
case 4 :fmt.Printf("今天是星期四")
case 5 :fmt.Printf("今天是星期五")
case 6 :fmt.Printf("今天是星期六")
case 7 :fmt.Printf("今天是星期天")
}
}
3–1、结果
[4]：切片的声明与赋值
4-1、【切片的声明 赋值 内存分配 引用数组 切片元素的引用 追加】
//切片的声明
var 切片名 []数据类型-----var nums []int
nums = make([]int,5) //为切片分配内存+长度为5
nums = append(nums,10) //为切片 追加 一个元素
4–1、例子
package main
import "fmt"
func main(){
var zSlice []int = make([]int,0)
for i:=1;i<=10;i++{
if i % 2==0{
zSlice = append(zSlice,i)
}
}
fmt.Printf("%d",zSlice)
fmt.Printf("\n现在我来给切片追加一个元素--->")
zSlice = append(zSlice,99)
fmt.Printf("现在--%d",zSlice)
}
4–1、结果
[5]·：字典的使用
5-1、【字典的声明 内存分配 字典的初始化 增删改查 遍历 键是否存在】
//字典的声明
var 字典名 字典数据类型----var mymap map[int]int---中括号里的是键的数据类型---外面的是值的数据类型
//内存分配(初始化)
var 字典名 字典数据类型---第一种：var mymap map[int]int = make(map[int]int)
-----------------------第二种：var mymap = make(map[int]int)
-----------------------第三种：mymap :=make(map[int]int)
-----------------------第四种：mymap :=map[int]int{2:1}
//增删改查
字典名[2]=1 //增加
字典名[已存在的键] = 新值 //改字典中键对应的值
delete(字典名，已经存在的键) //删除字典中的键
//遍历字典
for。。。。range 字典名
//判断键是否存在
_,ok :=字典名[输入的键]----ok的结果只有两种---true or false
5–1、例子
package main
import "fmt"
func main(){
var MyMap = make(map[string]string) //对字典进行内存分配---初始化
MyMap["张三"]="法律"
MyMap["李四"]="语文"
MyMap["王五"]="数学"
MyMap["李华"]="英语"
//增加字典的元素
MyMap["zzj"]="计算机"
//遍历---for。。。range
for index,values :=range MyMap{
fmt.Printf("%s-->%s\n",index,values)
}
//判断键是否存在
var str string //用来存储你想要查找的键
fmt.Printf("请输入你想要查找的键值\n")
fmt.Scanf("%s",&str) //输入键的值
_,ok :=MyMap[str]
if ok==true{
fmt.Printf("key= %s--存在\n",str)
}else{
fmt.Printf("key= %s--不存在\n",str)
}
delete(MyMap,"zzj")
}
5–1、结果
[6]：数组的使用
6-1、【数组的声明 赋值 初始化 遍历 数组元素的引用 for range】
//数组的声明
var 数组名 [长度]数据类型 //数组的长度的固定不是动态的
//数组的初始化
var nums =[10]int{1,2,3,4,5,6,7,8,9,10}
//数组的赋值
nums[0] = 99
//数组元素的引用（使用数组下标）
fmt.Printf("%d",nums[0]) //结果为 99
//数组元素的遍历（for循环遍历）
//第一种
for i:=0;i<len(nums);i++{ //数组的下标是从 0 开始的所以 i 的值从 0 开始增加
fmt.Printf("%d",nums[i])
}
//第二种
for index,values :=range nums{
fmt.Printf("[%d] = ",index) //---index是数组的下标
fmt.Printf("%d\n",values) //---values是数组的值
}
6–1、例子
package main
import "fmt"
func main(){
var nums =[10]int{1,2,3,4,5,6,7,8,9,10}
for i:=0;i<len(nums);i++{
fmt.Printf("%d ",nums[i])
}
fmt.Printf("\n")
nums[0]=99
fmt.Printf("现在:\n")
for index,values :=range nums{
fmt.Printf("[%d] = ",index)
fmt.Printf("%d\n",values)
}
}
6–1、结果
[7]：函数的声明
【函数的声明 参数 返回值 形参和实参 值传参和地址传参】
//函数的声明
func Zzj(){} //无参函数
func Zzj(n int){} //有参函数---参数为 形式参数 int
func Zzj(n int)int{} //有参函数+返回值---形参为int---返回值为int类型---return int类型的值
7–1、无参函数
package main
import "fmt"
func main(){
menu()
fmt.Printf("\t0、求和系统\n")
fmt.Printf("\t1、最大值系统\n")
fmt.Printf("\t2、排序系统\n")
fmt.Printf("\t3、退出系统\n")
menu()
}
func menu(){
fmt.Printf("=====================\n")
}
7–2、有参函数
package main
import "fmt"
func main(){
var str string
fmt.Scanf("%s",&str)
FanYi(str)
}
func FanYi(s string){
for _,values :=range s{
switch values {
case '0':fmt.Printf("你")
case '1':fmt.Printf("一")
case '2':fmt.Printf("爱")
case '3':fmt.Printf("生")
case '4':fmt.Printf("世")
case '5':fmt.Printf("我")
case '6':fmt.Printf("六")
case '7':fmt.Printf("亲")
case '8':fmt.Printf("爸")
case '9':fmt.Printf("久")
}
}
}
7–3、有参函数+返回值
package main
import "fmt"
func main(){
var a,b,sum int
fmt.Printf("请输入两个值\n")
fmt.Scanf("%d %d",&a,&b)
sum = ZSum(a,b)
fmt.Printf("两数之和为%d",sum)
}
func ZSum(a int,b int)int{
var sum int
sum = a+b
return sum
}
[8]：结构体的使用
7-1、【结构体数据类型的定义 type 结构体变量声明 字段访问】
//结构体的声明
type student struct{
name string
age int
sex string
}
var str student
//字段访问
str.name = "zzj"
str.age = 18
str.sex = "男"
7-1、【结构体变量的初始化 结构体字段为数组 结构体数组】
//结构体数组的声明
type student struct{
name string
age int
sex string
}
var str [5]student //创建了一个长度为 5 的数组
二·填空题考点
[1]：字符串函数的使用
【函数应该是哪一个包 包中函数的调用格式 参数 返回值】
//strings包-----------------------------------------------------------------------------
strings.Count("aabbcc","a")) //寻找与 "a" 有相同的个数
strings.Contains("aabbcc","c")) //判断 字符串中是否包含 "c"
strings.ToUpper("aabbcc")) //转大写
strings.ToLower("aabbcc")) //转小写
strings.Index("aabbcc","a")) //判断字符串中 "a" 第一次出现的位置
strings.LastIndex("aabbcc","a")) //判断字符串中 "a" 最后一次出现的位置
//strconv包------------------------------------------------------------------------------
s :=strconv.Itoa(123) //int 转 string----》一定成功
ok,nums :=strconv.Atoi("789")
//string 转 int--不一定成功---ok 就是来接收错误信息的--这里ok = <nil>表示成功转换---转换的字符串为789
ok2,nums1 :=strconv.Atoi("789a")
//当字符串中有除以外的字符时----ok = *strconv.NumError----表示转换失败---这时候nums1的值为 0
//--例子--------------------------------
package main
import (
"fmt"
"strconv"
)
func main(){
var num int = 50
var str string = "123"
var str1 string = "123a"
s :=strconv.Itoa(num)
ok,nums :=strconv.Atoi(str)
ok2,nums1 :=strconv.Atoi(str1)
fmt.Printf("%T\n",s)
fmt.Printf("%T %T\n",nums,ok)
fmt.Printf("%T %d",nums1,ok2)
}
//结果--------------------------------
string
<nil> int
*strconv.NumError 0
进程 已完成，退出代码为 0
1–1、例子
package main
import (
"fmt"
"strings"
)
func main(){
fmt.Printf("%v\n",strings.Count("aabbcc","a"))
//寻找与 "a" 有相同的个数
fmt.Printf("%v\n",strings.Contains("aabbcc","c"))
//判断 字符串中是否包含 "c"
fmt.Printf("%v\n",strings.ToUpper("aabbcc")) //转大写
fmt.Printf("%v\n",strings.ToLower("aabbcc")) //转小写
fmt.Printf("%v\n",strings.Index("aabbcc","a"))
//判断字符串中 "a" 第一次出现的位置
fmt.Printf("%v\n",strings.LastIndex("aabbcc","a")) //判断字符串中 "a" 最后一次出现的位置
}
1–1、结果
[2]：数据结构理论知识
见数据结构文件
三·改错题考点
[1]：指针的使用
【指针变量的声明 指针的变量的使用 & *】
//指针的声明
var a int = 1
var pra *int = &a //假如不指向一个地址，那就是"一个野指针--十分危险"---现在指向的是a 的地址
// & 取地址符号
var b int = 2
prb :=&b //c的值就是b的地址
// * 取值符号
var d int = 3
e :=&d //e 的值为d的地址
f := *e //f 的值为3
//代码实现------------------------
package main
import "fmt"
func main(){
var a int = 1
var pra *int = &a //假如不指向一个地址，那就是"一个野指针--十分危险"---现在指向的是a 的地址
// & 取地址符号
var b int = 2
prb :=&b //c的值就是b的地址
// * 取值符号
var c int = 3
prc :=&c //e 的值为d的地址
f := *prc //f 的值为1
fmt.Printf("&a = %p---pra = %p\n",&a,pra)
fmt.Printf("&b = %p---prb = %p\n",&b,prb)
fmt.Printf("&c = %p---prc = %p\n",&c,prc)
fmt.Printf("f = %d\n",f)
}
//结果--------------------------
&a = 0xc00000a0b0---pra = 0xc00000a0b0 //a的地址
&b = 0xc00000a0b8---prb = 0xc00000a0b8 //b的地址
&c = 0xc00000a0c0---prc = 0xc00000a0c0 //c的地址
f = 3 //f 的值==c 的值---因为prc储存了c的地址---*prc相当于取了地址中的值
进程 已完成，退出代码为 0
1–1、例子
package main
import "fmt"
func main(){
var a int = 1
var b *int = &a
var c int = *b
fmt.Printf("a=%d\nb=%p\nc=%d",a,b,c)
}
1–1、结果
[2]：切片的使用
==》见单选题第四点
[3]：字典的使用
==》见单选题第五点
四·编程题考点
第一题
[1]：for ==》冒泡排序（从小到大）
package main
import "fmt"
func main(){
var nums =[10]int{9,12,15,3,4,87,1,15,4,0}
for i:=0;i<len(nums)-1;i++{
//10个数所以排 9 次---最后一个并不用排
for j :=0;j<len(nums)-1;j++{
//冒泡排序的将相邻的两个数作比较----每循环玩全部次数可以将最大值放在最后--除去上一次已经排序的最大值
if nums[j+1]<nums[j]{
//当后面的比前面大时交换位置
nums[j],nums[j+1]=nums[j+1],nums[j]
}
}
fmt.Printf("第%d次排序后：%d\n",i+1,nums)
}
fmt.Printf("排序完成\n")
for _,values :=range nums{
fmt.Printf("%d ",values)
}
}
[2]：if 多分支
==》见单选考点第二点的例子2–1
第二题
[1]：结构体的使用
package main
import "fmt"
type student struct {
studentName string
studentNo int
classNo string
college string
}
var str student
func main(){
str.studentName = "zzj"
str.studentNo = 202004949
str.classNo = "C200302
str.college = "信息技术学院"
fmt.Printf("---------------------------\n")
fmt.Printf("姓名：%s\n学号：%d\n班级：%s\n学院：%s\n", str.studentName, str.studentNo, str.classNo, str.college)
fmt.Printf("---------------------------")
}
[2]：求最值的实现
package main
import (
"fmt"
)
const (
NUM = 3 //控制数组的长度
)
type student struct{ //结构体
student_no int
student_name string
score_go float64
score_mysql float64
score_ps float64
}
var str=make([]*student,0,NUM)
func input() *student{
var (
no int
name string
ps,go_score,mysql float64
)
fmt.Printf("请输入学号：")
fmt.Scanf("%d\n", &no)
fmt.Printf("请输入姓名：")
fmt.Scanf("%s\n", &name)
fmt.Printf("请输入PS成绩：")
fmt.Scanf("%f\n", &ps)
fmt.Printf("请输入go语言成绩：")
fmt.Scanf("%f\n", &go_score)
fmt.Printf("请输入MySQL成绩：")
fmt.Scanf("%f\n", &mysql)
return &student{ //返回输入的信息
student_no: no,
student_name: name,
score_ps: ps,
score_go: go_score,
score_mysql: mysql,
}
}
func add(){ //增加学生信息函数
ptr := input()
str = append(str, ptr)
}
func compare(s []*student)float64{ //比较函数
var max float64=0
var sum [NUM]float64 //储存三个学生的分数
for i:=0;i<NUM;i++{
sum[i]=s[i].score_go+s[i].score_ps+s[i].score_mysql
if sum[i]>max{
max=sum[i]
}
}
return max
}
func printf(){ //打印函数
var max float64
max=compare(str) //调用比较总分的函数
fmt.Printf(" %d 个学生中三科成绩总分最高的是%0.2f",NUM,max)
}
func menu(){
//菜单函数用来调用其他函数的运行---可以因为函数调用完就销毁
for i:=0;i<NUM;i++{
fmt.Printf("输入第%d个学生的信息\n",i+1)
add()
fmt.Printf("---------------------------\n")
}
compare(str)
printf()
}
func main(){
menu()
}
简单的多功能系统demo
//简单的多功能系统demo
package main
import (
"fmt"
"time"
)
func sum(test [4]int) {
fmt.Printf("你已进入求和系统\n")
time.Sleep(1 * time.Second)
fmt.Printf("你输入的数为")
for i := 0; i < len(test); i++ {
fmt.Printf("%d ", test[i])
time.Sleep(1 * time.Second)
}
var sum int
for i := 0; i < len(test); i++ {
sum = sum + test[i]
}
fmt.Printf("总成绩为%d\n", sum)
time.Sleep(1 * time.Second)
}
func 冒泡排序(intArray [4]int) {
fmt.Printf("你选择的是冒泡排序\n")
time.Sleep(1 * time.Second)
fmt.Printf("冒泡排序前：%d\n", intArray)
time.Sleep(1 * time.Second)
fmt.Printf("\n")
for i := 0; i < len(intArray)-1; i++ {
for j := 0; j < len(intArray)-1; j++ {
if intArray[j+1] < intArray[j] {
intArray[j], intArray[j+1] = intArray[j+1], intArray[j]
}
}
fmt.Printf("第%d次排序后结果为%d\n", i+1, intArray)
fmt.Printf("\n")
time.Sleep(1 * time.Second)
}
}
func 选择排序(intArray1 [4]int) {
fmt.Printf("你选择的是选择排序\n")
time.Sleep(1 * time.Second)
fmt.Println("选择排序前：", intArray1)
fmt.Printf("\n")
for i := 0; i < len(intArray1)-1; i++ {
for j := i + 1; j < len(intArray1); j++ {
if intArray1[j] < intArray1[i] {
intArray1[i], intArray1[j] = intArray1[j], intArray1[i]
}
}
fmt.Printf("第%d次排序后结果为%d\n", i+1, intArray1)
fmt.Printf("\n")
time.Sleep(1 * time.Second)
}
}
func 插入排序(intArray2 [4]int) {
fmt.Printf("你选择的是插入排序\n")
time.Sleep(1 * time.Second)
fmt.Println("插入排序前：", intArray2)
fmt.Printf("\n")
for i := 1; i < len(intArray2); i++ {
var j int
j = i
for ; j > 0; j-- {
if intArray2[j] < intArray2[j-1] {
intArray2[j-1], intArray2[j] = intArray2[j], intArray2[j-1]
}
}
fmt.Printf("第%d次排序后结果为%d\n", i+1, intArray2)
fmt.Printf("\n")
time.Sleep(1 * time.Second)
}
}
func paixu(intArray [4]int) {
fmt.Printf("你已进入排序系统\n")
time.Sleep(1 * time.Second)
fmt.Printf("你输入的数为：")
for i := 0; i < len(intArray); i++ {
fmt.Printf("%d ", intArray[i])
time.Sleep(1 * time.Second)
}
fmt.Printf("\n")
time.Sleep(1 * time.Second)
fmt.Printf("总共%d个数\n", len(intArray))
time.Sleep(1 * time.Second)
fmt.Printf("请选择排序方法\n")
time.Sleep(1 * time.Second)
fmt.Printf("=====================\n")
fmt.Printf("|| 1、Maopao ||\n")
fmt.Printf("|| 2、Xuanzhe ||\n")
fmt.Printf("|| 3、Chaoru ||\n")
fmt.Printf("=====================\n")
fmt.Printf("请输入你的选择\n")
time.Sleep(1 * time.Second)
var ssq int
for {
fmt.Scan(&ssq)
switch ssq {
case 1:
冒泡排序(intArray)
case 2:
选择排序(intArray)
case 3:
插入排序(intArray)
default:
fmt.Printf("请重新输入\n")
}
break
}
}
func max(test [4]int) {
fmt.Printf("你已进入求最大值系统\n")
time.Sleep(1 * time.Second)
var max int
max = test[0]
fmt.Printf("你输入的数为")
for i := 0; i < len(test); i++ {
fmt.Printf("%d ", test[i])
time.Sleep(1 * time.Second)
}
fmt.Printf("\n")
for i := 0; i < len(test); i++ {
if test[i] > max {
max = test[i]
}
}
fmt.Printf("最大值为%d\n", max)
time.Sleep(1 * time.Second)
}
func moban() {
fmt.Printf("=========================\n")
fmt.Printf("|| 1、进入求和系统 ||\n")
fmt.Printf("|| 2、进入排序系统 ||\n")
fmt.Printf("|| 3、进入求最大值系统 ||\n")
fmt.Printf("|| 4、进入退出系统 ||\n")
fmt.Printf("=========================\n")
fmt.Printf("请输入你的选择\n")
}
func main() {
var test [4]int
var z int
for i := 0; i < len(test); i++ {
z++
fmt.Printf("请输入第%d个同学的成绩\n", z)
fmt.Scan(&test[i])
}
fmt.Printf("你已进入校园网系统\n")
for {
moban()
var a int
fmt.Scan(&a)
if a == 4 {
fmt.Printf("你选择的退出\n")
fmt.Printf("倒计时开始\n")
time.Sleep(1 * time.Second)
fmt.Printf("3\n")
time.Sleep(1 * time.Second)
fmt.Printf("2\n")
time.Sleep(1 * time.Second)
fmt.Printf("1\n")
time.Sleep(1 * time.Second)
fmt.Printf("==>退出成功")
time.Sleep(1 * time.Second)
break
} else {
switch a {
case 1:
sum(test)
case 2:
paixu(test)
case 3:
max(test)
}
}
}
}
1893
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
