分类型变量预测连续型变量_跟光磊学Go语言-变量和数据类型

变量的定义

变量就是用于描述计算机数据的存储空间,常见的计算机数据有数字,字符串,图片,音频,视频等等,生活中的案例:酒店的房间就是存储空间,而变量就的作用是用于临时保存内存中的数据

计算机为了更高效的存储数据,合理利用存储空间,将内存分为不同的存储单元,每个存储单元存储不同类型的数据

而为了更方便的存数据和取数据,需要明确识别存储单元的方式和使用的用途,其中识别方式使用变量名例如age;而使用用途表示的存储的内容,例如10;

变量的声明,初始化,赋值

变量的声明

变量声明的格式 var 变量名称 变量类型,例如 var age int ,go语言的语法检查比较严格, 变量声明后必须使用(例如打印变量的值),而且变量根据类型会有对应的初始化默认值,即使是在方法中声明的变量,如果想要一次性声明多个变量,变量之间使用逗号隔开

package mainimport "fmt"/*   变量的声明   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 10:05 上午   @since Go1.15.5*/func main()  {//声明变量//go语言的语法比较严格,变量声明后必须使用,否则程序会出现编译错误var age int//整数变量的初始化默认值为0fmt.Println(age)//声明整数变量 变量名是numbervar number intfmt.Println(number)// 如果想要声明多个相同类型的变量,多个变量之间使用,隔开var data,value intfmt.Println(data)fmt.Println(value)}

程序运行结果

想要在变量声明时指定其他的值时,可以通过变量初始化和赋值两种方式实现

变量的初始化

变量的初始化指的是声明变量时赋初始值,例如var age int =28

package mainimport "fmt"/*   变量的初始化:声明时赋值   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 10:12 上午   @since Go1.15.5*/func main( )  {//声明整型变量 age 并初始化赋值为10// =表示把右边的值赋值给左边的变量var age int=28//使用变量->打印输出age变量的值fmt.Println(age)var number int =100fmt.Println(number)//fmt.Println()可以接受多个参数,参数之间使用,分割fmt.Println(age,number)}

变量的赋值

变量的赋值是在变量定义之后先不初始化,而后再给变量赋值,也就是先声明后赋值

package mainimport "fmt"/*   变量的赋值:先声明后赋值   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 10:17 上午   @since Go1.15.5*/func main() {//先声明var age int//后赋值age = 10//先声明var number int//后赋值number=100//打印输出age和number的值fmt.Println(age,number)}

变量赋值时除了将常量值赋值给变量外,还可以将一个变量的值赋值给另外一个变量

//将一个变量的值赋值给另外一个变量var myAge intmyAge = 28var yourAge int//将myAge变量的值赋值给变量yourAgeyourAge = myAge//因此yourAge的值也是28fmt.Println(yourAge)

并且变量中原有的值会被新值替换

var left int = 10var right int = 20fmt.Println(left)fmt.Println(right)//将变量left的值赋值给rightright = leftfmt.Println(left)//此时right原来的20会被10覆盖,因为打印输出结果是10fmt.Println(right)

交换两个变量的值(1)

通过中间变量实现变量的交换

package mainimport "fmt"/*   交换两个变量的值:通过中间变量实现   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 10:28 上午   @since Go1.15.5*/func main() {var left int = 10var right int = 20//打印输出交换之前left和right的值fmt.Println(left, right)//声明中间变量var tmp int//将right的值赋值给right// 此时right=20 tmp=20tmp = right//将left的值赋值给right// 此时left=10 right=10right = left//将tmp的值赋值给left// 此时left =20 tmp=20left = tmpfmt.Println("通过中间变量交换之后")//打印输出交换之后left和right的值//left=20 right=10fmt.Println(left, right)}

在不会使用GoLand的调试功能之前,可以使用fmt.Println()传递参数,观察程序的执行流程,默认情况下程序是从上到下执行的

自动推导类型

自动推导类型是Go语言提供的另外一种变量声明赋值的方式

变量初始化

var age int =10

变量的声明与赋值

var age intage = 28

自动推导类型的语法为 变量名 := 变量值 ,例如 number :=10,相比之前的两种变量赋值的方式:变量初始化和赋值而言,不需要使用var关键字,也不需要指定变量类型

自动推导类型通过赋值的数据类型来自动推导变量的数据类型

同时自动推导类型支持多个变量赋值,多个变量名和变量值之间使用逗号隔开,例如left, middle, right := 10,20,30

日常开发中经常使用自动推导类型来使用变量

package mainimport "fmt"/*   变量声明赋值的另外一种方式:自动推导类型   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 10:45 上午   @since Go1.15.5*/func main() {//自动推导类型的格式 变量名 := 变量值number := 100fmt.Println(number)var myAge int = 28yourAge := myAgefmt.Println(yourAge)//多变量的自动推导类型left, middle, right := 10,20,30fmt.Println(left,middle,right)}

交换两个变量的值(2)

package mainimport "fmt"/*   变量的交换   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 10:53 上午   @since Go1.15.5*/func main() {left := 10right := 20//打印输出交换之前left和right的值fmt.Println(left, right)//right的值赋值给left,left的值赋值给rightleft, right = right, left//打印输出交换之后left和right的值fmt.Println(left, right)}

输出格式

之前在打印输出多个变量的值,其输出结果看不出来多个变量值和变量的对应关系,程序显得不太友好,这里给出一种更加友好的写法,让开发者从程序的运行结果中一眼就能看到运行结果所表达的意图

package mainimport "fmt"/*   输出函数fmt.Println()的使用   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 10:57 上午   @since Go1.15.5*/func main() {left := 10middle := 0right := 20//打印输出三个变量的值 10 0 20//但是从输出的结果中看不出来哪个值对应的是哪个变量fmt.Println(left,middle,right)//更容易理解的变量值输出方式fmt.Println("left =",left)fmt.Println("middle =",middle)fmt.Println("right =",right)}

当程序中想要打印输出多个变量的值时建议使用fmt.Printf()结合字符串格式符实现,相对于fmt.Println()而言代码更加优雅,可读性强,需要注意的是fmt.Printf()输出不会换行,需要使用转义字符实现

package mainimport "fmt"/*   格式化输出多个整数   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 11:04 上午   @since Go1.15.5*/func main() {left := 10// %d表示输出的是一个整数 表示换行fmt.Printf("%d ",left)fmt.Printf("left = %d ",left)midle :=0right :=20// 表示Tabfmt.Printf("left = %d  middle = %d  right = %d ",left,midle,right)//对比fmt.Println()fmt.Println("left =",left," middle =",midle," right =",right)//相比fmt.Println(),fmt.Printf()输出多个变量时码更加优雅,可读性更强}

程序运行结果

接收键盘输入

Go语言提供了两个函数来接收键盘的输入:fmt.Scanf(字符串格式符,变量的地址)和fmt.Scan(变量地址),格式符是根据用户输入数据类型来决定的,如果是整数,那么格式符就是"%d",变量名只能表示变量代表的内存空间,而变量地址通过&变量名获取,所谓变量地址就是系统会在内存中为变量开辟对应的存储单元,为了能够获取该存储单元的数据,系统会给每个单元加上一个唯一的编号,这编号就是内存地址,类似于生活中酒店的房间号

使用fmt.Scanf()读取用户从键盘输入的整数,并使用fmt.Println()和fmt.Printf()函数获取整数变量age地址,然后输出用户从键盘输入的整数值

package mainimport "fmt"/*   格式化输入fmt.Scanf()   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 11:16 上午   @since Go1.15.5*/func main()  {var age intfmt.Println("请输入你的年龄(回车表示结束输入):")//通过fmt.Scanf()函数将键盘输入的整数赋值给age,该函数是带阻塞的,即一直等待用户输入,才会继续往下执行fmt.Scanf("%d",&age)//&age表示获取age变量的内存地址值,类似于酒店的唯一房间编号//内存地址默认是使用十六进制表示的,0x表示十六进制开头的整数,相对于内存地址,变量名更加好记忆,因此通常使用变量名操作变量fmt.Println("age变量的内存地址是",&age)//使用fmt.Println()结合格式符%p输出变量地址fmt.Printf("age变量的内存地址是%p",&age)//读取用户从键盘输入的值,并输出到终端上fmt.Println("你输入的年龄是",age)}

使用fmt.Scan()读取键盘输入的值并输出

package mainimport "fmt"/*   格式化输入fmt.Scan()   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 11:28 上午   @since Go1.15.5*/func main()  {var age intfmt.Println("请输入你的年龄(回车表示结束输入):")//相对于fmt.Scanf()而言,fmt.Scan()接收键盘输入的数据不需要指定格式符,使用起来更加简单fmt.Scan(&age)fmt.Println("你输入的年龄是",age)}

通过对比,相对于fmt.Scanf()而言,fmt.Scan()函数在接收键盘输入时不需要指定字符串格式符,使用起来更加简单,因此开发中通常使用fmt.Scan()来读取键盘的输入

计算机进制

在打印输出变量地址时默认的输出进制是十六进制,生活中最常用的就是十进制,计算机中常用的进制有八进制和十六进制,计算机底层都是以二进制存储数据,只能由0和1表示数据,因为计算机由逻辑电路组成的,逻辑电路有两个状态:开和关,正好和二进制的1和0相对应,使用二进制运算简单,比较容易实现

按照进位原则进行计数的方法叫做进位计数制,简称为进制

进制的特点

1. 使用一组固定的数字表示数值的大小 例如十进制就是由0,1,2,3,4,5,6,7,8,9组成,十六进制由0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f组成
2. 每一种进制在参与运算时都要遵循 加法: 逢R进1 减法:借1当R

进制的要素

• 基数:基数就是各种进制中允许选用的基本数码的个数,例如十进制的基数就是10,十六进制的基数就是16
• 位权: 1234=1*10^3+2*10^2+3*10^1+4*10^0 其中10^3,10^2,10^表示位权
• 按权相加法:让每一位上的数字字符乘以它们所代表的的位权

1234=1*10^3+2*10^2+3*10^1+4*10^0

由于计算机底层采用二进制存储数据,而生活中大多数使用的是十进制,那么就需要在二进制和十进制之间进行转换

二进制转十进制就是按权相加法

例如将二进制的1011转换成十进制计算的结果是13

1101=1*2^3+1*2^2+1*2^0=8+4+1=13

十进制转二进制是按照"除2直到商数为0取余,直到,逆排序"法

十进制的237转换为二进制

然后将余数的结果从下到上串联起来的结果:11101101，即十进制的237转换为二进制的结果为11101101。

变量的命名规范

Go语言的变量命名有如下规范,开发过程中应该严格遵守规范

• 只能由字母,数字,下划线组成
• 不能以数字开头
• 严格区分大小写,例如int和Int是完全不同的含义
• 不能是关键字,例如int,var都是关键字
• 变量名一定要见名知意,增强程序的可读性,降低程序后期维护成本
• 使用驼峰命名法小驼峰命名法:单词首字母小写,后面单词首字母大写,.例如myName,yourAge大驼峰命名法:单词首字母大写,后面单词首字母大写,例如FirstName

数据类型概要

在声明变量时需要指定数据类型,数据类型决定了存储的数据是整数,小数,还是字符串等等

Go语言数据类型说明

整型

整型分类

整型分为有符号整型和无符号整型

• 有符号整型(int)包含负整数,0和正整数,整型默认是有符号的
• 无符号整型(uint)包含0和正整数,即无符号整数不能存储负数,否则会溢出

package mainimport "fmt"/*   整型变量的使用   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 2:13 下午   @since Go1.15.5*/func main()  {//无符号整数不能存储负数,这里会发生溢出错误var number uint=-10// constant -10 overflows uint//在以后的编程中,如果变量不允许使用负整数,就使用unitfmt.Println(number)}

整型的范围

位(bit)是计算机的最小存储单位,计算机中存储的就是二进制的0和1,位就是使用二进制来存储

字节(Byte)是内存最小的计量单位,1Byte=8bit,除此以外还有KB,MB,GB,TB,PB,EB,它们之间都是以2的10次方即1024来换算的,即1KB=1024B,1MB=1024KB,依次类推

• 有符号整型 32位系统：int是4个字节, 取值范围：-2147483648 到 2147483647 64位系统：int是8个字节，取值范围：-9223372036854775808到 9223372036854775807
• 无符号整型 在32位系统中：是4个字节， 取值范围：0 到 4294967295 在64位系统中：是8个字节， 取值范围：0 到 18446744073709551615

整型在内存中的存储

• 有符号整数(int):数值二进制的最高位(即最左边的那个数字)是符号位,0表示正数,1表示负数,其他位表示数据位

以4个字节为例:

1的二进制表示为 0000 0000 0000 0000 0000 0001 ,最左边的0表示符号位,0该数是正数,数据位是000 0000 0000 0001

-1的二进制表示为1000 0000 0000 0000 0000 0001,最左边的1表示符号位,1表示该数是负数,数据位是000 0000 0000 0001

• 无符号整数(uint)就表示数据没有正负之分,即全是正数无符号数没有符号位,全是数据位1 的二进制表示 1的二进制表示为 0000 0000 0000 0001 ,数据位是0000 0000 0000 0001

浮点型

浮点型表示带小数点的数据,例如圆周率3.14

Go语言中提供了两种不同精度的浮点型类型:float32,float64

其中float32精确到小数点后7位,float64精确到小数点后15位,因此float64精度高于float32

由于Go中涉及到关于数学运算的包中都要求使用float64这个类型,因此浮点类型建议使用float64存储,自动推导类型创建的变量也是float64类型存储

package mainimport "fmt"/*   浮点类型变量的使用:声明,赋值,查看变量值   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 2:44 下午   @since Go1.15.5*/func  main()  {var height float64height=178.0000009// %f默认保留小数点后6位(四舍五入)输出fmt.Printf("height = %f ",height)var newHeight=180.006//浮点数保留两位 同时进行了四舍五入输出fmt.Printf("newHeight = %.2f",newHeight)//使用自动类型推导给weight变量赋值weight :=150.00fmt.Printf("%.2f",weight)//%T字符串格式符可以输出变量的类型//输出结果显示浮点数默认是float64fmt.Printf("%T",weight)}

布尔型

布尔型(bool)用于存储条件判断的结果,例如3>4的结果是false,而4>3的结果就是true

布尔类型的取值范围只能有true和false,默认值是false

%t表示布尔类型的字符串格式符

package mainimport "fmt"/*   布尔类型变量的使用   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 2:54 下午   @since Go1.15.5*/func main()  {var flag bool//bool变量的默认值是falsefmt.Println(flag)//将布尔类型的变量flag的值改为trueflag=truefmt.Println(flag)// %t表示布尔类型的字符串格式符fmt.Printf("flag = %t",flag)}

字符型

在日常生活中使用字母A,B,C,D 来表示考试成绩或者等级,A,B,C,D在Go语言中称为字符(byte),使用一对单引号''包含,需要注意的是字符(byte)只能存储单个英文字符,如果存储中文运行程序会出现越界的错误

当使用fmt.Println()打印输出字符变量时,默认输出的是字符对应的ASCII值,例如字符'a'输出的ASCII值就是97,如果要输出字符,可以使用fmt.Printf()结合%c字符串格式符即可

package mainimport "fmt"/*   字符变量的使用   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 3:01 下午   @since Go1.15.5*/func main() {var lowerCaseA byte='a'//输出的是字符'a'表示的ASCII值fmt.Println(lowerCaseA)// %c 表示字符 字符串格式符fmt.Printf("lowerCaseA = %c",lowerCaseA)// %d输出字符,就是输出字符的ASCII值fmt.Printf("lowerCaseA = %d",lowerCaseA)//小写转大写var upperCaseA byte=lowerCaseA-('a'-'A')fmt.Printf("upperCaseA = %c",upperCaseA)}

ASCII表

通过ASCII表得知

• 小写字母转大写字母 -32 ,例如小写字母a的ASCII值是97,97-32=65,而65刚好是大写字母A的ASCII值
• 大写字母转小写字母 +32,例如大写字母A的ASCII值是65,65+32=97,而97刚好是小写字a的ASCII值

var lowerCaseA byte='a'var upperCaseA byte=lowerCaseA-('a'-'A')fmt.Printf("upperCaseA = %c",upperCaseA)

字符串型

由于字符只能存储单个字符,程序如果想要存储多个字符,例如姓名,地址,学校名称等等就要使用字符串来存储

Go语言中的字符串(string)常量使用一对双引号包含,变量使用string表示,字符串的字符串格式符是%s

package mainimport "fmt"/*   字符串变量的使用   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 3:16 下午   @since Go1.15.5*/func main() {//将字符串常量tony赋值给字符串变量namevar name string ="tony"fmt.Printf("name = %s",name)//使用自动类型推导声明变量str :="跟光磊学Go语言应用开发与架构设计"//输出str变量的类型fmt.Printf("str变量的类型是%T",str)}

需要注意的是字符串常量值都是以0结尾,在使用fmt.Println()或者是fmt.Printf()函数打印输出字符串时,输出的是0之前的内容,通过Go语言提供的len()函数可以获取字符的长度(即字符的个数),但是该函数会忽略'0',其中英文字母占据一个字符,而为了和Linux保持一致,一个中文占据3个字符

 package mainimport "fmt"/*   字符串变量的使用   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 3:16 下午   @since Go1.15.5*/func main() {//将字符串常量tony赋值给字符串变量namevar name string = "tony"fmt.Printf("name = %s", name)//使用自动类型推导声明变量str := "跟光磊学Go语言应用开发与架构设计"//输出str变量的类型fmt.Printf("str变量的类型是%T", str)fmt.Printf("字符串常量Go的长度是%d",len("Go"))//在Go语言中,一个汉字占据3个字符,为了与Linux系统保持一致fmt.Printf("字符串跟光磊学Go语言应用开发与架构设计的长度是%d", len(str))}

字符与字符串的区别

• 字符使用''包含起来,存储单个字符
• 字符串使用""包含起来,使用0结束字符
• len()函数测试字符串的长度,不包含0
• 在go语言中一个汉字占据3个字符

强制类型转换

在购物结算时,通常会抹除零头,例如本来价格是100.5块,但是实际付款金额是100块,这里就涉及到将浮点型转换为整型

类型转换就是将一种类型变量转换为另外一种类型的变量

• 整数转换为浮点数:float64(整数变量或者常量)
• 浮点数转换为整数:int(浮点数常量或者变量)

package mainimport "fmt"/*   强制类型转换   float64转换为int类型: int(变量或者常量)   int转换为float64  float64(变量或者常量)   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 3:33 下午   @since Go1.15.5*/func main() {var amount float64=100.5fmt.Printf("抹去零头的金额是%d",int(amount))fmt.Printf("整数178转换为浮点型的结果是%.2f",float64(178))}

类型转换还有个应用场景:类型提升

在Go语言中,不同类型的数据不能参与运算,例如float32类型的变量和float64类型的变量,因此需要将float32的变量转换为float64后再参与运算,在类型转换时,建议将低类型转换为高类型,保证数据精度,例如这里的float32转换为float64

package mainimport "fmt"/*   类型转换的案例:类型提升   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 3:43 下午   @since Go1.15.5*/func main() {var left float32 = 3.14var right float64 = 5.67// left和right 不是同一个类型,不能参与运算,编译错误//这里需要将left提升为float64类型,然后再参与运算//为啥不将right转换为float32呢?//在类型转换时,建议将地类型转换为高类型,保证数据精度var result = float64(left) + rightfmt.Printf("3.14 + 5.67 = %.2f",result)//高类型转换为低类型的数据溢出案例var number int =8888//int8表示的范围是-128到127之间 这里溢出fmt.Printf("number = %d",int8(number))}

如果将高类型的数据转换为低类型的数据,结果可能会溢出或者丢失精度

//高类型转换为低类型的数据溢出案例var number int =8888//int8表示的范围是-128到127之间 这里溢出fmt.Printf("number = %d",int8(number))

fmt包的格式化输入与输出

Go语言中常用的字符串格式符

其中常用的字符串格式符如下列表所示,之前都已经使用过,此处不再赘述

• %c 字符
• %d 十进制整数
• %f 浮点数
• %p 内存地址
• %s 字符串
• %t 布尔值
• %T 类型

还有一些不常用的字符串格式符,例如整数的三种进制字符串格式符的使用

package mainimport "fmt"/*   字符串格式符(不常用)   整数的三种进制形式   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 4:01 下午   @since Go1.15.5*/func main() {number := 100// %b表示以二进制获取结果fmt.Printf("100的二进制形式为%b ", number)// %o表示以八进制获取结果fmt.Printf("100的八进制形式为%o ", number)// %x 表示以十六进制的结果 如果有a-f的字母显示为小写字母fmt.Printf("100的十六进制形式为%x ", number)value := 12// %x 表示以十六进制的结果 如果有A-F的字母显示为大写字母fmt.Printf("12的十六进制形式为%X ", value)}

数据类型案例

根据用户输入的姓名和年龄,在终端是输出您好,{用户的姓名}您的年龄是{用户输入的年龄}

package mainimport "fmt"/*  根据用户输入的姓名和年龄,在终端是输出您好,{用户的姓名}您的年龄是{用户输入的年龄}   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 4:07 下午   @since Go1.15.5*/func main() {fmt.Println("请输入你的姓名")var name stringfmt.Scanf("%s",&name)fmt.Println("请输入你的年龄")var age intfmt.Scanf("%d",&age)fmt.Printf("%s您好,您的年龄是%d",name,age)}

程序运行结果

常量

变量是在程序运行过程中可以改变的量,而常量就是程序在运行的过程中不会改变的量

Go语言中的常量使用const关键字完成,常量定义的格式为 const CONST_NAME type = CONST_VALUE,并且常量名建议大写

需要注意的是自动类型推导可以声明初始化赋值变量外,不能用来声明初始化常量

常量也不同通过地址符&加常量名获取常量地址

package mainimport "fmt"/*   常量的声明和使用   1.变量的声明和使用   2.常量的声明和使用   3.常量的特点   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 4:13 下午   @since Go1.15.5*/func main() {//变量var number int =20//可以改变值number=100fmt.Println("number = ",number)//常量定义的格式  constconst HEIGHT float64=8848.44fmt.Printf("喜马拉雅山的高度是%.2f",HEIGHT)//常量一旦声明并初始化赋值后const PI = 3.14//值就不能被再次修改,此处不允许被再次赋值//PI=3.1415fmt.Printf("圆周率的值是%.2f",PI)//常量不能通过地址符&加常量名获取内存地址//fmt.Printf("浮点类型常量PI的内存地址是%p",&PI)}

除了使用const声明的常量外,还有字面常量(literal),字面常量就是程序中硬编码的常量

package mainimport "fmt"/*   常见的字面常量   @author liuguanglei 18601767221@163.com   @wechat 18601767221   @version  2020/11/17 4:24 下午   @since Go1.15.5*/func main() {//常见的字面常量fmt.Println(28)fmt.Println(180.00)fmt.Println("刘光磊")fmt.Println(false)}