golang技术分享

最新推荐文章于 2023-06-02 17:30:02 发布

SYaoJun

最新推荐文章于 2023-06-02 17:30:02 发布

阅读量730

点赞数 1

分类专栏： Go

本文链接：https://blog.csdn.net/SYaoJun/article/details/107953681

版权

Go 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1、python2和python3的bytes

if __name__ == '__main__':
	ss = 'terry0609_08\x04\x04\x04\x04'
		print(type(ss))
	 	print(ss[-1])
	 	print(ss[-2])

python3中bytes可以是任何二进制数据，文本/图片/视频/音频等等。str就是文本数据。

python2中把b'abcd'视为str，对str的切片是把\x04当作1位，数字8被视为unicode即char，输出的就是'8'。
python3中对bytes的切片是把\x04当作1位，数字8被视为utf-8的int，输出的都是数值56。

出错的代码

def  unpadding(self, s):
	return s[0:-ord(s[-1])]

出错代码原因分析：

  没有注明类型，不能进行类型的判读，代码的写法比较trick。

python3中bytes和str的转换

b = b"example" # bytes object  
s = "example"  # str object  
s2b = bytes(s, encoding = "utf8")    # str to bytes 
s2b = str.encode(s) # str to bytes 
s2b = s.encode("utf8") # str to bytes 
b2s = str(b, encoding = "utf8")      # bytes to str  
b2s = bytes.decode(b) #  bytes to str  
b2s = b.decode("utf8") #  bytes to str

bytes不一定能变成str,当bytes是图片，视频等非文本的二进制内容时，bytes就不能decode成str了。

2、typing标注类型和类型别名

python3.5 以后的新特性

typing模块的作用：

类型检查，防止运行时传入参数不符合。
作为开发文档附加说明，方便使用者调用传入和返回类型。
如果传入参数类型不匹配会报错【IDE层面的报错】。

def  func(name: str) -> str:
	return  "Hello"  + name
if  __name__ == '__main__':
	print(func(123))

使用标注前首先需要导入typing标注库, 常用的标注

from typing import List, Dict, Tuple
	List[str]
	Dict[str, str]
	Dict[List[str], str]
	Tuple[str, str]

注意：解释器不会对返回类型做检查，比如实际返回是一个dict，但是标注的是str，程序可以正常运行。

3、 golang的string，byte和rune

中文字符在unicode下占2个字节，在utf-8编码下占3个字节，而golang默认编码正好是utf-8。

string不可变，当使用range遍历时，自动转换为[]rune

s := "hello 中国"
for c, v  := range s {
     fmt.Printf("%d %c\n", c, v)
}

输出结果
可以发现输出的序号跟预期不太符合

0 h
1 e
2 l
3 l
4 o
5  
6 中
9 国

byte可变，按照utf-8输出

package main

import "fmt"

func main() {
	s := "hello 中国"
	a := []byte(s)
	for c, v  := range a {
		fmt.Printf("%d %d\n", c, v)
	}
}

byte中的汉字被解码为3个字节

如果想要输出可以识别的字符，通常使用string转换一下

rune可变，按照unicode输出

rune=int32 四个字节
byte=int8 1个字节

package main

import "fmt"

func main() {
	s := "hello 中国"
	a := []rune(s)
	for c, v  := range a {
		fmt.Printf("%d %s\n", c, string(v))
	}
}

输出结果

0 h
1 e
2 l
3 l
4 o
5  
6 中
7 国

4、 json与map之间的相互转换

map转json

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	//创建一个map
	m := make(map[string]interface{}, 4)
	m["company"] = "byte"
	m["subjects"] = []string{"GO", "C++", "Java"}
	m["ok"] = true
	m["price"] = 666.666
	//编码成json
	//result, err := json.Marshal(m)
	result, err := json.MarshalIndent(m, "", "  ")
	if err != nil {
		fmt.Printf("error: %s", err)
		return
	}
	fmt.Printf("result = %v", string(result))

}

因为map是无序的，所以不能保证每次输出的顺序相同。

json转map

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	//创建一个json
	result := `{
		 "company": "bytedance",
		 "isok": true,
		 "price": 666.666,
		 "subjects": ["GO","C++","Java"]
   	}`
	//创建一个用于接收的map
	mp := make(map[string]interface{}, 99)
	json.Unmarshal([]byte(result), &mp)
	fmt.Println(mp)
}

输出的结果

map[company:bytedance isok:true price:666.666 subjects:[GO C++ Java]]

5、 json与结构体之间的转换

json转结构体

package main

import (
	"encoding/json"
	"fmt"
)

//变量名必须大写
type IT struct {
	Company string   `json:"company"`
	Subject []string `json:"subjects"`
	Isok    bool     `json:"-"` //不输出
	Price   float64  `json:",string"`
}

func main() {
	//定义一个结构体变量 同时初始化
	s := IT{"bytedance", []string{"GO", "C++", "Python", "Java"}, true, 666.66}
	//编码 根据内容生成Json文本
	//buf, err := json.Marshal(s)
	buf, err := json.MarshalIndent(s, "", "        ")
	if err != nil {
		fmt.Printf("error %s", err)
	}
	fmt.Printf("%+v", string(buf))
}

结构体转json

package main

import (
	"encoding/json"
	"fmt"
)

//变量名必须大写
type IT struct {
	Company string
	Subject []string
	Price   float64
}

func main() {
	result := `{
		 "Company": "bytedance",
		 "Subject": ["GO","C++","Python","Java"],
		 "Price": 666.66
   }`
	/*创建一个结构体变量*/
	var it IT
	err := json.Unmarshal([]byte(result), &it)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%#v\n", it)

}

main.IT{Company:“bytedance”, Subject:[]string{“GO”, “C++”, “Python”, “Java”}, Price:666.66}

golang中的自定义排序

golang内置了一些基础数据类型的排序，如int，string，float等，其他类型的结构体需要自己实现less, map,len三个函数。

内置排序

package main

import (
	"fmt"
	"sort"
)

func main() {
	// int排序
	ints := []int{1, 8, 4, 5}
	sort.Ints(ints)
	fmt.Println(ints)
	// string排序
	names := []string{"hello", "world", "yao", "jun"}
	sort.Strings(names)
	fmt.Println(names)
}

自定义排序

package main

import (
	"fmt"
	"sort"
)

type Student struct {
	name string
	age  int
}

type stuSlice []Student
func (s stuSlice) Len() int {
	return len(s)
}

func (s stuSlice) Less(i, j int) bool {
	return s[i].age < s[j].age
}
func (s stuSlice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

func main() {
	students := []Student{{"mike", 16}, {"jane", 22}, {"Ben", 19}}
	sort.Sort(stuSlice(students))
	for k, v := range students {
		fmt.Println(k, v)
	}
}

输出结果

0 {mike 16}
1 {Ben 19}
2 {jane 22}

7、golang中的单元测试

t *testing.T 普通测试函数
b *testing.B benchMark测试

普通测试函数

通常test文件的命名规范是xxx_test.go

test case的函数命名为TestXxx形式否则go test会跳过该test不执行


func  F(a,b int)int{
	return a+b
}

测试代码

package main

import "testing"

func TestF(t *testing.T) {
	res := F(3, 4)
	if res != 7 {
		t.Errorf("add wrong!")
	}
}

Go test不保证多个test按照顺序执行，但是我们通常会要求按照顺序执行。

使用t.Run来执行subtests可以做到控制test执行的顺序

package main

import (
	"fmt"
	"testing"
)

func TestF(t *testing.T) {
	t.Run("a1", func(t *testing.T) { fmt.Println("a1") })
	t.Run("a2", func(t *testing.T) { fmt.Println("a2") })
	t.Run("a3", func(t *testing.T) { fmt.Println("a3") })
}

使用TestMain作为初始化test，并且使用m.Run()来调用其他tests可以完成一些需要初始化操作的testing，比如数据库连接，文件打开，rest服务登录等。如果没有在TestMain中调用m.Run()则除了TestMain以外的其他tests都不会被执行。

func  TestMain(m *testing.M){
	fmt.Println("test main first")
	m.Run()
}

benchmark测试

benchmark函数一般以BenchMark开头

benchmark函数的case一般会跑b.N次，而且每次执行都会如此

在执行过程中会根据实际case的执行时间是否稳定会增加b.N的次数以达到稳态

go test -bench =. //命令行
func BenchmarkF(b *testing.B) {
for i := 0; i < b.N; i++{
	F(100, 10)
	}
}
func F(a, b int)int{
	return a+b
}

如果benchmark测试的函数执行时间始终无法趋于稳态则永远无法执行完

func  unstable(n int){
	for n > 0{
		n--
	}
}
func BenchmarkF(b *testing.B)
	for i := 0; i < b.N; i++{
		unstable(i) //如果benchmark测试的函数执行时间始终无法趋于稳态 则永远无法执行完
	}
}

8、golang中切片的坑

slice传参数时新增失败

package main
import "fmt"
func modifySlice(s []string) { //切片新增无效
	s[0] = "modify 123"
	s = append(s, "456")
}

func main() {
	s := []string{"123"}
	modifySlice(s)
	fmt.Println(s) //返回结果 [modify 123] 新增的数据没有生效
	s = modifySliceNew(s)
	fmt.Printf("%v", s) //必须重新接收返回值 此时生效 因为修改的指针返回了

}

正确使用方式

原因是传入的参数是指针的拷贝但是新增数据是修改的指针

func  modifySliceNew(s []string)[]string{  //切片新增生效
    s[0] = "modify 123"
	s = append(s, "456")
	return s
}

9、golang中删除切片中某个元素

方法1: 删除某个元素后，剩余的元素往前移动
方法2: 重新开一个切片，把满足条件的往新切片中放入
方法3: 索引累计，如果是删除的元素索引就不加1，最后根据累计的索引进行切片

package main

import (
	"fmt"
)

func main() {
	//创建一个slice
	sliceU := []int{1, 0, 1, 1, 0, 1, 0, 1, 1}
	// 要求：把切片中所有的0删除掉
	//slice的删除方式1
	//删除剩余的元素往前移动
	for i, v := range sliceU {
		if v == 0 {
			sliceU = append(sliceU[:i], sliceU[i+1:]...)
		}
	}
	fmt.Println(sliceU)
	//slice的删除方式2
	//重新开一个数组，把满足条件的往新数组中写入
	var newSliceU []int
	for _, v := range sliceU {
		if v != 0 {
			newSliceU = append(newSliceU, v)
		}
	}
	fmt.Println(newSliceU)
	// slice的删除方式3
	// 索引累计 最后切片
	index := 0
	for _, v := range sliceU {
		if v != 0 {
			sliceU[index] = v
			index++
		}
	}
	fmt.Println(newSliceU[:index])
}

从上面的结果可以看出，数据范围较小时，方法2和方法3性能差不多，数据量大以后，方法1总体上要差于其他两个策略。

方法1

时间复杂度：O(n^2)

空间复杂度：O(n)

方法2

时间复杂度：O(n)

空间复杂度：O(n)

方法3

时间复杂度：O(n)

空间复杂度：O(1)

10、数组传参

package main

import "fmt"
func f(arr [10]int){  //不仅是数组还必须长度一致
	arr[1] = 100
	fmt.Println(arr)
}
func main(){
	/*
	数组：类型和长度确定。
	值类型：传递参数时，进行值拷贝。
	*/
	var arr [10]int
	arr[1] = 2
	arr[2] = 3
	f(arr)
	fmt.Println(arr)
	arr2 := arr
	arr2[1] = 100  //拷贝以后改变 没影响
	fmt.Println(arr2)
	fmt.Println(arr)

}

11、深浅拷贝

package main

import "fmt"
func f(arr [10]int){  //不仅是数组还必须长度一致
	arr[1] = 100
	fmt.Println(arr)
}
func main(){
	/*
	切片：slice是对底层数组一段内容的引用，slice是一个fat pointer存储的是实际数组的地址，切片的长度，最大容量
	注意：应该避免在两个变量中修改同一个底层数组
	data[low:high:max]high和max都是不包含当前下标的。
	len()
	cap()
	append()
	copy() 可以实现对切片的深拷贝 切片间的直接赋值是浅拷贝，只是赋值了共同的底层数组地址
	对同一个数组进行的不同切片，对某个切片进行操作，对其他切片是没有感知的，但是如果是对底层数组修改，两者都有感知。

	引用类型都是浅拷贝
	操作切片也是操作底层数组，slice采用两倍扩容机制，一旦扩容就重新指向一个新的底层数组。
	cap是切片开始位置到数组末尾的长度

	*/
	var arr [10]int
	arr[0] = 100
	arr[1] = 200
	arr[2] = 300
	slice1 := arr[0:2]
	slice2 := arr[1:5]
	fmt.Println(cap(slice1))
	fmt.Println(cap(slice2))

	slice3 := slice2
	arr[1] = 20000
	fmt.Println("_______")
	fmt.Println(slice1)
	fmt.Println(slice2)
	fmt.Println(slice3)

}

12、golang常用操作

strings.Contains(str, “hello”) 是否包含某个字符串
strings.Count(str, “hello”) 字符串数量统计
字符串拆分为数组strings.Split(s, sep)，sep表示以什么什么来拆分s字符串。
字符串大小写转换，strings.ToUpper(s)转大写，strings.ToLower(s)转小写
strings.Trim(s, cutset)，cutset代表要去除的两边字符。strings.TrimLeft(s, cutset)。
strings.HasPrefix(s, prefix)。判断字符串是否以什么开头。

13、字符串转整形

val, typeErr := strconv.Atoi(myStr2)
b2, errs:= strconv.ParseInt(s2, 2, 64) //把字符串二进制转换为十进制整数

14、整型转字符串

value := strconv.Itoa(myInt)
ss2 := strconv.FormatInt(b2, 2) //把整数以二进制转换为字符串

15、字符串转[]byte

myByte := []byte(myStr3)

16、编码

一个英文字符对应一个byte，一个中文字符对应三个byte。

一个rune对应一个UTF-8字符，所以一个中文字符对应一个rune。%c输出对应的字符和汉字。

rune相当于go的char。

byte=uint8

rune=uint32

17、时间

t:= time.Now() //当前时间

18、读一行

bf := bufio.NewReader(os.Stdin)
ss, errs := bf.ReadString('\n')
lst := string.Field(ss) //按照空格切分字符串

19、数组初始化

cities := [...]string{"北京", "上海","深圳"}
cities := []string{"上海", "成都"}
	for index,value := range cities{
		fmt.Println(index, value)
	}

SYaoJun

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
golang技术分享

1、python2和python3的bytesif __name__ == '__main__': ss = 'terry0609_08\x04\x04\x04\x04' print(type(ss)) print(ss[-1]) print(ss[-2]) python3中bytes可以是任何二进制数据，文本/图片/视频/音频等等。str就是文本数据。python2中把b'abcd'视为str，对str的切片是把\x04当作1位，数字8被视为unicode即char，输出的就是
复制链接

扫一扫

专栏目录