Go-day02

Go程序的基本结构

　　***func init() 会在main函数之前执行

　　1.包中的函数调用

　　　　a.同一个包中函数,直接调用

　　　　b.不同包中函数,通过包名+点+函数名进行调用

2.包的访问控制规则

　　　　a.大小写意味着这个函数/变量是可导出的

　　　　b.小写意味着这个函数/变量是私有的,包外部不能访问

练习题一：

　　写一个程序，对于给定一个数字n，求出所有两两相加等于n的组合。
　　比如： 对于n=5，所有组合如下所示：
　　　　0+5=5
　　　　1+4=5
　　　　2+3=5
　　　　3+2=5
　　　　4+1=5
　　　　5+0=5

package main

import (
	"fmt"
)

//两个数加和,遍历一个数然后另外一个数就是和减去当前值
func list(n int){
	for i := 0; i <= n ; i++ {
		fmt.Printf("%d+%d=%d\n",i,n -i ,n)
	}
}
func main() {
	list(10)
}

/*
0+10=10
1+9=10
2+8=10
3+7=10
4+6=10
5+5=10
6+4=10
7+3=10
8+2=10
9+1=10
10+0=10
*/

练习题二：

　　包别名的应用，开发一个程序，使用包别名来访问包中的函数？

package main

import(
     a "add" //设置别名
)

func main () {

fmt.Println("result:", a.Name)
fmt.Println("result:", a.age)
}

init的加载顺序

package main

import "fmt"
var a string = "xxxxx"  //加载顺序:先初始化全局变量,在初始化init,在执行main
var age int = 100

func init(){
	a  = "xx"
	age =  10
}
func main() {
	fmt.Println("a",a,"age",age)
}

main函数引入包的加载顺序(包中导入包):

　　程序的初始化和执行都起始于main包。如果main包还导入了其它的包，那么就会在编译时将它们依次导入。有时一个包会被多个包同时导入，那么它只会被导入一次（例如很多包可能都会用到fmt包，但它只会被导入一次，因为没有必要导入多次）。当一个包被导入时，如果该包还导入了其它的包，那么会先将其它包导入进来，然后再对这些包中的包级常量和变量进行初始化，接着执行init函数（如果有的话），依次类推。等所有被导入的包都加载完毕了，就会开始对main包中的包级常量和变量进行初始化，然后执行main包中的init函数（如果存在的话），最后执行main函数

包只初始化 不引用

_操作其实是引入该包，而不直接使用包里面的函数，而是调用了该包里面的init函数。

package main

import (
      _	"fmt" //下划线加空格 只初始化 不引用
)

func main() {

}

Go中的常量const

　　永远只读,不可以被修改

***最后一个const c = getValue()是不可以的,因为函数的返回值不确定

练习：

　　定义两个常量Man=1和Female=2，获取当前时间的秒数，如果能被Female整除，则在终端打印female，否则打印man

package main

import (
	"time"
	"fmt"
)

const (
	Man = 1
	Female = 2
)

func main() {

	Second :=  time.Now().Unix()
	if (Second % Female == 0){
		fmt.Println("female",Female)
	}else {
		fmt.Println("man",Man)
	}

}

Go变量

　　1.int初始值为0

　　2. string初始值为""

3.bool初始值为false

练习：

　　获取操作系统和path

package main

import (
	"os"
	"fmt"
)

func main(){
	var goos string = os.Getenv("GOOS")

	fmt.Printf("The operating system is %s\n",goos)

	path := os.Getenv("PATH")

	fmt.Printf("Path is %s\n" ,path)

}

32位操作系统指针是4字节，64位操作系统指针是8字节

值类型与引用类型

　　1.值类型,int,float,bool,string,数组和struct(结构体)

　　2.引用类型,指针,slice(切片),map,chan都是引用类型

package main

import (
	"fmt"
)
func main() {
	a := 5
	b := make(chan int,1)
	fmt.Println("a= ",a)
	fmt.Println("b= ",b)
}

/*
a=  5
b=  0xc420050070
*/

练习：

package main

import (
	"fmt"
)

func modify(a int){
	a = 10 //函数属于值类型
	return
}
func modify1(p *int) {
     *p = 100
	//指针是引用类型 所有会改变
}
func main() {
	a := 5
	b := make(chan int,1)
	fmt.Println("a= ",a)
	fmt.Println("b= ",b)
	modify(a)
	fmt.Println("a= ",a)
	modify1(&a)
	fmt.Println("a= ",a)
}

/* 

a=  5
b=  0xc420050070
a=  5
a=  100
*/

练习：

　　将first和second值交换(通过指针改变内存地址后的源数据)

package main

import (
	"fmt"
)

func swap(a *int,b *int){
	tmp := *a
        *a = *b
        *b = tmp

}

func main() {
	first :=100
	second :=200
	swap(&first,&second)
	fmt.Println("first= ",first)
	fmt.Println("second= ",second)

}

/*
first=  200
second=  100
*/

第二种方法：

package main

import (
	"fmt"
)

func swap1(a int,b int) (int,int) {
	return b,a
}

func main() {
	first :=100
	second :=200
	//swap(&first,&second)
	first,second = swap1(first,second)
	fmt.Println("first= ",first)
	fmt.Println("second= ",second)

}

/*
first=  200
second=  100
*/

局部变量和全局变量使用

package main
import (
	"fmt"

)

var a string  = "M" //定义了个全局变量

func main() {
	a := "G" //局部变量
	fmt.Println("from main",a) //找自己的局部变量
	f1()
}
func f2()  {
	fmt.Println("from f2",a) //局部变量没有,找全局的a
}

func f1(){
	a:="O"
	fmt.Println("from f1",a)
	f2()//执行f2函数相当于重新引用不会继承自己的局部变量
}
/*GOM*/

***重点观察

package main
import (
	"fmt"

)

var a = "G"

func main() {
	n()
	m()
	n()

}

func n (){
	fmt.Println(a)
}

func m (){
	a = "O" //将a赋值成O,因为m中未定义a所以修改的是全局的a
	fmt.Printf(a)
}

/*
GOO
*/

 ***重点观察

package main
import (
	"fmt"

)

var a string  //定义了个全局变量

func main() {
	a = "G" //局部变量，因为当前未生命a变量,所以修改的是全局的a
	fmt.Println("from main",a) //找自己的局部变量
	f1()
}
func f2()  {
	fmt.Println("from f2",a) //局部变量没有,找全局的a,这是全局的a已经被更改为G
}

func f1(){
	a:="O" //重新在函数内声明var a string = "O"
	fmt.Println("from f1",a)
	f2()//执行f2函数相当于重新引用不会继承自己的局部变量
}

/*
GOG
*/

数据类型和操作符

　　1.int8和uint8的区别？

　　　　uint8是无符号int,比int少一位 符号如:"+","-"

　　2.不同类型可以转换例子如下：

package main

import (
	"fmt"
)

func test() {

	var a int8 = 100
	var b int16 = int16(a) //将a的int8转换成int16赋值给b
	fmt.Printf("a=%d , b=%d" , a,b)
}

func main() {
	test()
}

　　3.int32是4字节,int64是8字节

练习

　　使用math/rand生成10个随机整数,10个小于100的随机整数,10个随机浮点数

package main

import (
	"math/rand"
	"fmt"
	"time"
)

func init(){
	//放到初始化里
	rand.Seed(time.Now().UnixNano()) //以时间戳做为当前随机数的种子,Nano是纳秒
}
func main() {

	for i := 0 ; i < 10 ; i++ {
		a := rand.Int() //获取整数
		fmt.Println(a)
	}
	for i := 0 ;i < 10 ; i++{
		a := rand.Intn(100) //获取100以内的随机整数
		fmt.Println(a)
	}
	for i := 0 ; i < 10 ; i++ {
		a := rand.Float32() //获取浮点数
		fmt.Println(a)
	}
}

字符和字符串

　　1.字符byte var a  byte = 'c' 一个byte占用1个字节 8位 ***字符必须是单引号

　　2.字符串由多个字符组成

3.字符串""与``的区别

　　　　``可以保存原有格式原封不动打印

package main

import "fmt"

func main() {
	var str = "hello world \n"
	var str1 = `
	go go go ,
	1231 123
	`
	var b  byte = 'c'
	fmt.Println(str)
	fmt.Println(str1)
	fmt.Println(b) //默认是数字标识
	fmt.Printf("%c\n",b) //字符格式化输出

}

/*
hello world 

	go go go ,
	1231 123

99
c

*/

fmt格式化输出详解

/*
一般：

	%v	相应值的默认格式。在打印结构体时，“加号”标记（%+v）会添加字段名
	%#v	相应值的Go语法表示
	%T	相应值的类型的Go语法表示
	%%	字面上的百分号，并非值的占位符
布尔：

	%t	单词 true 或 false。
整数：

	%b	二进制表示
	%c	相应Unicode码点所表示的字符
	%d	十进制表示
	%o	八进制表示
	%q	单引号围绕的字符字面值，由Go语法安全地转义
	%x	十六进制表示，字母形式为小写 a-f
	%X	十六进制表示，字母形式为大写 A-F
	%U	Unicode格式：U+1234，等同于 "U+%04X"
浮点数及其复合构成：

	%b	无小数部分的，指数为二的幂的科学计数法，与 strconv.FormatFloat
		的 'b' 转换格式一致。例如 -123456p-78
	%e	科学计数法，例如 -1234.456e+78
	%E	科学计数法，例如 -1234.456E+78
	%f	有小数点而无指数，例如 123.456
	%g	根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出
	%G	根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出
字符串与字节切片：

	%s	字符串或切片的无解译字节
	%q	双引号围绕的字符串，由Go语法安全地转义
	%x	十六进制，小写字母，每字节两个字符
	%X	十六进制，大写字母，每字节两个字符
指针：

	%p	十六进制表示，前缀 0x

*/

package main

import "fmt"

func main() {
	var a int = 100
	var b bool
	c := 'a'

	fmt.Printf("%v\n",a) //相应值的默认格式。在打印结构体时
	fmt.Printf("%#v\n",b)
	fmt.Printf("%T\n",c) //相应值的类型的Go语法表示
	fmt.Printf("90%%\n") //百分比
	fmt.Printf("%b\n",a) //二进制显示
	fmt.Printf("%f\n",199.22) //浮点数显示
	fmt.Printf("%q\n","this is a str") //单引号围绕的字符字面值，由Go语法安全地转义
	fmt.Printf("%p\n",&a) //打印内存地址

	//将一个int类型转化成str 不能用强制转换

	str := fmt.Sprintf("%d",a)
	fmt.Printf("%q\n",str)

}

/*
result:
100
false
int32
90%
1100100
199.220000
"this is a str"
0xc42007e008
"100"

*/

用Go实现字符串反转

package main

import "fmt"

func reverse(str string) (string){
	var result string
	strLen := len(str)
	for i := 0 ; i < strLen; i++ {
		result = result + fmt.Sprintf("%c",str[strLen -i -1])
	}
	return result
}

func main() {
	myStr:= "hello world"
	result := reverse(myStr)
	fmt.Println(result)
}

/*
dlrow olleh
*/

　通过数组反转

package main

import "fmt"

func reverse_arry(str string) (string){
	var result []byte //定义一个空数组
	length := len(str)
	for i := 0 ; i < length ; i++ {
		result = append(result,str[length -i -1]) //通过append往数组里追加值
	}
	return string(result) //最后在string化
}

func main() {
	myStr:= "hello world"
	result = reverse_arry(myStr)
	fmt.Println(result)
}

Go的字符串操作

package main

import "fmt"

func main() {
	str := "hello"
	str1 := "world"

	//result := str + " " +str1
	result := fmt.Sprintf("%s %s", str, str1) //字符串拼接
	q := result[6:] //字符串切片
	fmt.Println(result)
	fmt.Println(q)
}

/*

hello world
world
*/

练习：

　　求100到200的素数,用户随便输入

package main

import (
	"fmt"
	"math"
)

func isPrime(n int ) bool{

	for i := 2 ; i < int(math.Sqrt(float64(n))) ; i++ { //素数是大于1的自然数除了1和他本身不能有其他整除,类似于奇数
		if n % i == 0 {
			return false
		}

	}
	return true
}

func main() {
	var n int
	var m int
	fmt.Scanf("%d%d",&n,&m) //类似于python的input输入,传入Scanf函数是指针,这样就可以确保函数外定义的变量可以修改值

	for i := n ; i < m ; i++ {
		if isPrime(i) == true{
			fmt.Printf("%d\n",i)
			continue
		}
	}

}

　　 打印出100-999中所有的“水仙花数”，所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如：153 是一个  “水仙花数”，因为 153=1 的三次方＋5 的三次方＋3 的三次方

package main

import "fmt"

func isNumber(num int) bool{
	a := num % 10
	b := (num / 10) % 10
	c := (num / 100) % 10
	res := a*a*a + b*b*b + c*c*c
	return res == num
}

func main() {
	var n int
	var m int
	fmt.Scanf("%d%d",&n,&m)
	for i := n ; i < m ; i ++ {
		if isNumber(i) == true{
			fmt.Println("this is a shuixianhua = ",i)
		}
	}
}

/*
1  999
this is a shuixianhua =  1
this is a shuixianhua =  153
this is a shuixianhua =  370
this is a shuixianhua =  371
this is a shuixianhua =  407
*/

通过ascii码实现水仙花：

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var str string
	fmt.Scanf("%s" ,&str)

	var result = 0
	for i := 0 ; i < len(str) ; i++ {
		sum := int(str[i] - '0') //字符串切片默认是ascii码,通过ascii与0做运算 0代表48(十进制)，1代表49(十进制)做差仍为1
		result += (sum * sum * sum)
	}

	number,err := strconv.Atoi(str) //将字符串转化为int
	if (err != nil) {
		fmt.Printf("cat not convert %s to int \n",number)
		return
	}

	if result == number{
		fmt.Printf("%d is shuixianhua \n",number)

	}else{
		fmt.Printf("%d is not shuixianhua\n" ,number)
	}

}

对于一个数n，求n的阶乘之和，即： 1！ + 2！ + 3！+...n!

package main

import "fmt"

func sum(n int ) uint64{
	var s uint64 = 1
	var sum uint64 = 0
	for i := 1; i <= n ; i++ {
		s = s * uint64(i) //和乘以当前值 就是下一位阶乘的结果
		fmt.Printf("%d!=%v\n",i,s)
		sum += s //这是阶乘的和
	}
	return sum
}

func main() {
	var n int

	fmt.Scanf("%d", &n)

	s := sum(n)
	fmt.Println(s)

}

/*
10
1!=1
2!=2
3!=6
4!=24
5!=120
6!=720
7!=5040
8!=40320
9!=362880
10!=3628800
4037913
*/