程序员经验分享-hwhale

Go语言学习——4、数据存储：数组，切片，映射

2023-10-26

目录

一、数组

1、声明数组

2、初始化数组

 3、遍历数组

二、切片

1、从数组或切片生成新的切片的语法格式：

2、直接生成一个新的切片

3、切片添加元素

4、从切片删除元素

5、遍历切片

三、映射

1、 声明映射

2、   初始化映射

3、    遍历映射

4、    从映射中删除键值对

四、拓展：并发操作映射（map）

1、map在单线程中不会出现错误，但多个线程并发访问一个map，会导致程序异常退出。

2、用sync包对map进行加锁，可以实现map多线程编程。

3、由于加锁会对程序产生一定的影响，所以使用sync.map进行map的安全开发

一、数组

        数组是具有相同类型且长度固定的一组数据项序列，数组中存放的数据类型可以是整形、字符串或其他数据类型。 使用数组前需要先声明数组，声明是必须指定数组的大小且指定后不能改变，数组元素可以通过下标来读取或修改，数组下标是从零开始的。

1、声明数组

数组声明语法格式如下：

    var 数组变量名 [数组长度]元素类型

//例如：声明数组student，长度为3，元素类型为string
    var student [3]string

只声明数组，没有对数组进行赋值，打印时为空数组。 

func example01() {
	fmt.Println("example01()..........")
	var student [3]string
	fmt.Println("student数组：",student)
	fmt.Println("----------------------\n")
}

/*
运行结果如下：
    example01()..........
    student数组： [  ]
    ----------------------
*/

2、初始化数组

初始化数组：数组可在声明时进行赋值，如下：

var student = [3]string{"Tom","Mike","Peter"}

         使用这种方式初始化数组，需要保证大括号中元素数量与数组大小一致。忽略中括号里的数字，不设置数组大小，可以通过"..."来代替数组大小。例如：

var student = [...]string{"Tom","Mike","Peter"}

数组初始化的举例：

func example02() {
	fmt.Println("example02()..........")
	var student = [...]string{"Tom", "Mike", "Peter"}
	fmt.Println("student数组：",student)
	fmt.Println("----------------------\n")
}

/*
运行结果如下：
    example02()..........
    student数组： [Tom Mike Peter]
    ----------------------
*/

 3、遍历数组

遍历数组：数组元素可以通过数组下标来读取或修改，数组下标从0开始，第一个元素的数组下标为0，第二个数组元素的下标为1，通过for循环进行遍历。

func example04() {
	fmt.Println("example04()..........")
	var student = [...]string{"Tom","Mike","Peter"}
	for k,v :=range student{
		fmt.Println("数组下标：",k,"\t对应元素：",v)
	}
	fmt.Println("---------------------")
}

/*
运行结果如下：
    example04()..........
    数组下标： 0 	对应元素： Tom
    数组下标： 1 	对应元素： Mike
    数组下标： 2 	对应元素： Peter
    ---------------------
*/

二、切片

        相对于数组，切片（slice）是一种更加强的数据结构，是多个同类型元素的连续集合，但是切片本身不存储任何元素，只是对现有数组的引用。

        切片的结构包括：地址，长度和容量

                （1）、 地址：切片的地址一般指切片中第一个元素指向的内存地址，十六进制表示。

                （2）、 长度：切片中实际存在的元素个数。

                （3）、容量：从切片起始元素开始到底层引用数组的最后一个元素的个数。

        切片的长度和容量都是可变的，通过追加元素使切片的长度和容量增大

        切片的生成方式由三种：

                 （1）、从数组生成一个新的切片。

                 （2）、从切片生成一个新的切片。

                 （3）、直接生成一个新的切片。

        切片的长度用len()函数获取 ，切片的容量用cap()函数获取。

1、从数组或切片生成新的切片的语法格式：

 var slice = 数组/切片[开始位置:结束位置]

从数组或切片新生成的切片有如下特性：

        （1）、新生成切片的长度：结束位置-开始位置。

        （2）、新生成切片取出的元素不包括结束位置对应的元素。

        （3）、新生成的切片是对原有数组或切片的引用，其地址与截取的数组或切片开始位置对应的元素地址相同。

        （4）、新生成切片的容量指从切片起始元素到其底层数组或切片中的最后一个元素的个数。

举例：

func example01() {
	fmt.Println("example01()...........") 
	var student = [...]string{"John", "Tom", "Mike", "Peter", "Ben", "Jack"}
	var student1 = student[1:5]
	var student2 = student1[0:2]
	fmt.Println("student数组：", student)               
	fmt.Println("student数组第1个元素的地址是：", &student[0]) 
	fmt.Println("student数组第2个元素的地址是：", &student[1]) 
	fmt.Println("student数组的长度是：", len(student))    
	fmt.Println("student数组的容量是：", cap(student))     

	//从数组生成新的切片
	fmt.Println("\nstudent1切片：", student1)        
	fmt.Println("student1数组的地址是：", &student1[0])  
	fmt.Println("student1切片的长度是：", len(student1)) 
	fmt.Println("student1切片的容量是：", cap(student1)) 

	//从切片生成新的切片
	fmt.Println("\nstudent1切片：", student2[:])     
	fmt.Println("student2数组的地址是：", &student2[0])  
	fmt.Println("student2切片的长度是：", len(student2)) 
	fmt.Println("student2切片的容量是：", cap(student2)) 
	fmt.Println("----------------------")
}

/*
运行结果如下：
    example01()...........
    student数组： [John Tom Mike Peter Ben Jack]
    student数组第1个元素的地址是： 0xc000048060
    student数组第2个元素的地址是： 0xc000048070
    student数组的长度是： 6
    student数组的容量是： 6

    student1切片： [Tom Mike Peter Ben]
    student1数组的地址是： 0xc000048070
    student1切片的长度是： 4
    student1切片的容量是： 5

    student1切片： [Tom Mike]
    student2数组的地址是： 0xc000048070
    student2切片的长度是： 2
    student2切片的容量是： 5
    ----------------------

2、直接生成一个新的切片

        切片的声明格式如下：

var 切片变量名 []元素类型

        切片声明后其内容为空，长度、容量都为0。需要对切片进行初始化，初始化切片的两种语法格式如下：

        （1）、在声明时初始化：

 var slice = []元素类型{value1,value2,value3}

        （2）、使用make()函数初始化：

var slice = make([]元素类型,切片长度,切片容量)

注意：初始化后会自动填充默认值。切片的容量必须大于等于切片的长度，否则程序会报错.

举例：

func example02() {
	fmt.Println("\n\nexample02()...........")
	var student []int
	fmt.Println("student切片：", student) 
	fmt.Println("student切片长度：", len(student)) 
	fmt.Println("student切片容量：", cap(student))  
	fmt.Println("student切片是否为空：", student == nil)

	//声明变量时初始化
	var student1 = []int{1, 2, 3, 4, 5}
	fmt.Println("\nstudent1切片：", student1)  
	fmt.Println("student1切片长度：", len(student1)) 
	fmt.Println("student1切片容量：", cap(student1)) 
	fmt.Println("student1切片是否为空：", student1 == nil)  

	//使用make()函数初始化
	var student2 = make([]int,4,5)
	fmt.Println("\nstudent2切片：", student2) 
	fmt.Println("student2切片长度：", len(student2)) 
	fmt.Println("student2切片容量：", cap(student2)) 
	fmt.Println("student2切片是否为空：", student2 == nil)  
	fmt.Println("----------------------")
}

/*
运行结果如下：
    example02()...........
    student切片： []
    student切片长度： 0
    student切片容量： 0
    student切片是否为空： true

    student1切片： [1 2 3 4 5]
    student1切片长度： 5
    student1切片容量： 5
    student1切片是否为空： false

    student2切片： [0 0 0 0]
    student2切片长度： 4
    student2切片容量： 5
    student2切片是否为空： false
    ----------------------

3、切片添加元素

         使用append()函数来对切片进行元素的添加。当切片不能再容纳其他元素时（即当前切片长度等于容量值）。 下一次使用append()函数添加元素，切片的容量会自动扩容两倍。

举例：

func example03() {
	fmt.Println("\n\nexample03()..............")
	student := make([]int,1,1)
	for i:=0;i<=8;i++ {
		student = append(student,i)
		fmt.Println("i的值为：",i,"当前切片的长度：",len(student),"当前切片容量：",cap(student))
	}
	fmt.Println(student)    
	fmt.Println("-----------------------------")
}

/*
运行结果如下：
    example03()..............
    i的值为： 0 当前切片的长度： 2 当前切片容量： 2
    i的值为： 1 当前切片的长度： 3 当前切片容量： 4
    i的值为： 2 当前切片的长度： 4 当前切片容量： 4
    i的值为： 3 当前切片的长度： 5 当前切片容量： 8
    i的值为： 4 当前切片的长度： 6 当前切片容量： 8
    i的值为： 5 当前切片的长度： 7 当前切片容量： 8
    i的值为： 6 当前切片的长度： 8 当前切片容量： 8
    i的值为： 7 当前切片的长度： 9 当前切片容量： 16
    i的值为： 8 当前切片的长度： 10 当前切片容量： 16
    [0 0 1 2 3 4 5 6 7 8]

如果切片是从其他数组或切片生成的。新切片的元素添加会覆盖对原有数组或切片中的元素。

举例：

func example04() {
	fmt.Println("\n\nexample04().............")
	var student = []string{"John", "Mike", "Ben", "Tom", "Jack"}
	var student1 = student[0:1]
	fmt.Println("student数组：",student)  
	fmt.Println("student1切片：",student1)   
	student1 = append(student1, "Peter")
	fmt.Println("student数组：",student)    
	fmt.Println("student1切片：",student1)  
	fmt.Println("----------------------------")
}

/*
运行结果如下：
    example04().............
    student数组： [John Mike Ben Tom Jack]
    student1切片： [John]
    student数组： [John Peter Ben Tom Jack]
    student1切片： [John Peter]
    ----------------------------

4、从切片删除元素

        Go语言没有为删除切片元素提供方法，我们需要手动的将删除点前后元素连接在一起，实现切片元素的删除。

        要清空切片中的所有元素，可以把开始下标和结束下标设置为0

举例：

func example05() {
	fmt.Println("\n\nexample05().................")
	var student = []string{"John", "Mike", "Ben", "Tom", "Jack"}
	fmt.Println("原student切片：",student)

	//删除元素
	student = append(student[0:1],student[3:]...)
	fmt.Println("student切片：",student)
	fmt.Println("student切片长度：", len(student))
	fmt.Println("student切片容量：", cap(student))

	//清空切片中的元素
	student = student[0:0]
	fmt.Println("student切片：",student)
	fmt.Println("student切片长度：", len(student))
	fmt.Println("student切片容量：", cap(student))
	fmt.Println("--------------------------------")
}

/*
运行结果如下：
    example05().................
    原student切片： [John Mike Ben Tom Jack]
    student切片： [John Tom Jack]
    student切片长度： 3
    student切片容量： 5
    student切片： []
    student切片长度： 0
    student切片容量： 5
--------------------------------
*/

5、遍历切片

        切片的遍历与数组相似，可以通过切片下标来遍历。切片下标从零开始。

举例：

func example06() {
	fmt.Println("\n\nexample06().................")
	var student = []string{"John", "Mike", "Ben", "Tom", "Jack"}
	for k,v := range student{
		fmt.Println("切片下标：",k,"对应切片元素：",v)
	}
	fmt.Println("---------------------------------")
}

/*
运行结果如下：
    example06().................
    切片下标： 0 对应切片元素： John
    切片下标： 1 对应切片元素： Mike
    切片下标： 2 对应切片元素： Ben
    切片下标： 3 对应切片元素： Tom
    切片下标： 4 对应切片元素： Jack
    ---------------------------------
*/

三、映射

映射（map）：是一种无序的键值对的集合，map的键类似于索引，指向数据的值，当程序中需要存放有关联关系的数据，就会使用map

1、 声明映射

        语法格式如下：

var map = map[键类型]值类型{}

举例：

func example01() {
	fmt.Println("example01()..........")
	var studentMap = map[string]int{}
	fmt.Println(studentMap)
	fmt.Println("--------------------")
}

/*
运行结果如下：
    example01()..........
    map[]
    --------------------
*/

2、   初始化映射

        方式有两种

        （1）、声明时进行初始化

        （2）、使用make()函数进行初始化

举例：

func example02() {
	fmt.Println("\n\nexample02()............")
	//声明时初始化
	var studentMap = map[string]int{
		"Tom":  90,
		"John": 43,
		"Jack": 99,
	}
	fmt.Println(studentMap)

	//使用make()函数进行初始化
	var student map[string]int
	student = make(map[string]int)
	student["John"] = 90
	student["Tom"] = 30
	student["Ken"] = 80
	fmt.Println(student)
	fmt.Println("-----------------------")
}

/*
运行结果如下：
    example02()............
    map[Jack:99 John:43 Tom:90]
    map[John:90 Ken:80 Tom:30]
    -----------------------
*/

3、    遍历映射

        通过for循环遍历，遍历时可同时获取键和值，也可只获取键，只获取值。

举例：

func example03() {
	fmt.Println("\n\nexample03().........")
	var studentMap = map[string]int{
		"Tom":  90,
		"John": 43,
		"Jack": 99,
	}

	//遍历键和值
	for k, v := range studentMap {
		fmt.Println(k, v)
	}

	//只遍历键
	for k := range studentMap{
		fmt.Println(k)
	}

	//只遍历值
	for _ , v := range studentMap{
		fmt.Println(v)
	}
	fmt.Println("-------------------------")
}

/*
运行结果如下：
    example03().........
    Tom 90
    John 43
    Jack 99
    Tom
    John
    Jack
    90
    43
    99
-------------------------

4、    从映射中删除键值对

        使用delete()函数进行删除操作。语法格式如下：

delete(map,键)

举例：

func example04() {
	fmt.Println("\n\nexample04().........")
	var studentMap = map[string]int{
		"Tom":  90,
		"John": 43,
		"Jack": 99,
	}
	fmt.Println("studentMap:",studentMap)
	delete(studentMap,"Tom")
	fmt.Println("studentMap:",studentMap)
	fmt.Println("------------------------")
}

/*
运行结果如下：
    example04().........
    studentMap: map[Jack:99 John:43 Tom:90]
    studentMap: map[Jack:99 John:43]
    ------------------------
*/

注意：Go语言没有提供map清空元素的方法，想要清空map就需要重新定义一个新的map

四、拓展：并发操作映射（map）

1、map在单线程中不会出现错误，但多个线程并发访问一个map，会导致程序异常退出。

举例：

func exampleB01() {
	var GoMap = map[int]int{}
	for i := 0; i < 10000; i++ {
		go writeMapB01(GoMap, i, i)
		go readMapB01(GoMap, i)
	}
	fmt.Println("B01 Over")
}

func readMapB01(GoMap map[int]int, key int) int {
	return GoMap[key]
}

func writeMapB01(GoMap map[int]int, key int, value int) {
	GoMap[key] = value
}


/*
运行结果如下：
    fatal error: concurrent map writes

    goroutine 8 [running]:
    runtime.throw(0x4d0744, 0x15)
	    E:/Go/src/runtime/panic.go:1116 +0x79 fp=0xc000043f58 sp=0xc000043f28 pc=0x432889
    runtime.mapassign_fast64(0x4b3c40, 0xc00006e330, 0x1, 0x0)
	    E:/Go/src/runtime/map_fast64.go:101 +0x32a fp=0xc000043f98 sp=0xc000043f58 pc=0x41047a
main.writeMapB01(0xc00006e330, 0x1, 0x1)
	    E:/Work/GO/src/Go语言入门/Middle/B_Go语言内置容器/C_映射/Example_B01.go:61 +0x48 fp=0xc000043fc8 sp=0xc000043f98 pc=0x49e418
    runtime.goexit()
	    E:/Go/src/runtime/asm_amd64.s:1373 +0x1 fp=0xc000043fd0 sp=0xc000043fc8 pc=0x45d241
created by main.exampleB01
	    E:/Work/GO/src/Go语言入门/Middle/B_Go语言内置容器/C_映射/Example_B01.go:50 +0x66

2、用sync包对map进行加锁，可以实现map多线程编程。

举例：

var lock sync.RWMutex

func exampleB02() {
	var GoMap = map[int]int{}
	for i := 0; i < 10000; i++ {
		go writeMapB02(GoMap, i, i)
		go readMapB02(GoMap, i)
	}
	fmt.Println("B02 Over")
}

func readMapB02(GoMap map[int]int, key int) int {
	lock.Lock() //读取map前先加锁
	m := GoMap[key]
	lock.Unlock() //读完后解锁
	return m
}

func writeMapB02(GoMap map[int]int, key int, value int) {
	lock.Lock() //写map前加锁
	GoMap[key] = value
	lock.Unlock() //写完后解锁
}

/*
运行结果如下：
    B02 Over
*/

3、由于加锁会对程序产生一定的影响，所以使用sync.map进行map的安全开发

         sync.map有以下特点：

                （1）、使用前无需初始化，直接声明即可。无需使用make()函数创建。

                （2）、Load()方法的第一个返回值是接口类型的。需要将其转换为map值的类型。

举例：

func exampleB03() {
	var GoMap sync.Map
	for i := 0; i < 1000; i++ {
		go writeMapB03(&GoMap,i,i)
		go readMapB03(&GoMap,i)
	}
	fmt.Println("B03 Over")
}

func readMapB03(GoMap *sync.Map, key int) int{
	res , ok := GoMap.Load(key)
	if ok==true {
		return res.(int)
	}else {
		return 0
	}
}

func writeMapB03(GoMap *sync.Map, key int, value int) {
	GoMap.Store(key,value)
}

/*
运行结果如下：
    B03 Over
*/

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

go语言

Go语言学习——4、数据存储：数组，切片，映射 的相关文章

  • Go基础（复杂类型）：指针

    Go语言指针 Go 具有指针 指针保存了变量的内存地址 类型 T 是指向类型 T 的值的指针 其零值是 nil var p int 符号会生成一个指向其作用对象的指针 i 42 p i 符号表示指针指向的底层的值 fmt Println p

  • 一个简单的Golang实现的HTTP Proxy方法

    最近因为换了Mac 以前的Linux基本上不再使用了 但是我的SS代理还得用 SS代理大家都了解 一个很NB的socks代理工具 但是就是因为他是Socks的 想用HTTP代理的时候很不方便 以前在Linux下的时候 会安装一个Privox

  • 【笔记】2022 Golang+Cobra 学习Cli命令行工具

    github源代码网址 GitHub spf13 cobra A Commander for modern Go CLI interactions 一 安装 由于Cobra更新新的版本 所以网络上之前的教程都需要进行修改 例 根据老的方法进

  • 在Windows上搭建Go开发环境

    Go语言是由谷歌开发的一个高性能 跨平台的编程语言 安装Go 首先先来安装一下Go语言的SDK 目前Go语言的最新版本为Go 1 8 3 Go下载页面列出了各种操作系统的安装包 如果选择Windows MSI安装包的话 会将Go安装到C G

  • Go语言学习5-切片类型

    切片类型 引言 1 切片 1 1 类型表示法 1 2 值表示法 1 3 属性和基本操作 1 4 切片使用的复杂用法 总结 引言 上篇我们介绍了 Go语言的数组类型 本篇将介绍Go语言的切片类型 主要如下 1 切片 切片可以看作是对数组的一种

  • go语言重大bug，make缓存读取数据漏洞，4096漏洞

    做一个小程序 需要对文件内容分片读取 但是读取过程中发现数据读取不全 经测试多个make缓存读取文件时发现问题 以下为漏洞测试部分 一 生成测试文件 AAA txt 创建一个AAA txt文件 写入1万个A wFile os OpenFil

  • 玩好go的切片

    go的slice 入门就会遇到 但这个东西大多数人都是停留在简单的使用 一些干了好几年的老程序员都说不明白里面的道道 这里面坑不少 恰巧今天有空 好好整理下 永不踩坑 1 为什么要用切片 其他语言大多用的都是数组 在go中 数组的长度是不可

  • 【笔记】Go语言学习笔记

    一 概述 什么是程序 程序 为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合 Go语言 是区块链最主流的编程语言 同时也是当前最具发展潜力的语言 Go语言是Google公司创造的语言 也是Google主推的语言 Googl

  • pprof 性能分析

    pprof 是一个强大的性能分析工具 可以捕捉到多维度的运行状态的数据 在程序运行过程中可以获取cpu heap block traces等执行信息 一般情况下使用下列三种pprof分析 runtime pprof 采集程序 非 Serve

  • go语言的常见函数

    1 make函数 创建数组切片 Go语言提供的内置函数make 可以用于灵活地创建数组切片 创建一个初始元素个数为5的数组切片 元素初始值为0 mySlice1 make int 5 创建一个初始元素个数为5的数组切片 元素初始值为0 并预

  • go ： GoLand安装及环境配置

    前因后果 新学期新气象 开学的第一节课是zw老师的区块链技术与应用领域 congratulations 涉及编程实验 使用Go语言 需要安装GoLand软件进行下一步 Go语言下载地址 golang下载链接 进去之后选择对应的版本下载 这里

  • error An unexpected error occurred: “https://registry.yarnpkg.com/axios: con 解决方案

    error An unexpected error occurred https registry yarnpkg com axios con 今天用在跑一个项目的时候发现了这个错误 看着像是网络连接不上 发现这里是用的Dokcerfile

  • golang的hijack篡取劫持

    一直不太明白golang的hijack是干什么的 只知道hijack这个词是篡取的意思 难道跟网关的作用一样 把client的请求发到这个服务上 然后这个服务帮忙转发到远端server 但是看了源码后就明白这个golang hijack是干

  • 42-Golang中的单元测试

    Golang中的单元测试 需求 传统方法 基本介绍 单元测试快速入门总结 综合案例 需求 在工作中 我们会遇到这样的情况 就是去确认一个函数 或者一个模块的结果是否正确 传统方法 在main函数中 调用addUpper函数 看看实际输出的记

  • Go-OpenWrt获取wan口ip、dns、网关ip

    Go OpenWrt获取wan口ip dns 网关ip 文章目录 Go OpenWrt获取wan口ip dns 网关ip 1 前言 2 解决方案思路 3 代码 1 前言 一般来说 Openwrt可以配置多个wan口和多个lan口 这里获取的

  • GoLang学习资源清单

    地鼠文档go语言文档网站通过收集整理go语言相关的学习文档 为大家提供一个学习平台https www topgoer cn 前景 Go语言中文文档https www topgoer com 文档 Gin Web FrameworkGin W

  • go添加国内镜像加速

    添加国内镜像加速 七牛云 七牛云镜像 全球CDN加速 全球CDN加速 打开你的命令终端输入Go 1 13 及以上 推荐 go env w GO111MODULE on go env w GOPROXY https goproxy cn di

  • Go语言学习18-基准测试

    基准测试 引言 基准测试 1 编写基准测试函数 2 计时器 3 内存分配统计 4 基准测试的运行 结语 引言 所谓基准测试 Benchmark Test 简称BMT 是指 通过一些科学的手段实现对一类测试对象的某项性能指标进行可测量 可重复

  • Go语言学习4-数组类型

    数组类型 引言 1 数组 1 1 类型表示法 1 2 值表示法 1 3 属性和基本操作 总结 引言 上篇我们了解 Go语言的基本数据类型 现在开始介绍数组类型 主要如下 1 数组 在Go语言中 数组被称为Array 就是一个由若干相同类型的

  • go语言教程哪里有？go 语言优秀开源项目汇总

    目录 监控系统 容器技术 PaaS工具 大数据 微服务 CI CD 数据库技术 存储技术 分布式系统 消息系统 服务器管理 安全工具 网络工具 Web工具 Web框架 区块链技术 其它 监控系统 项目 简介 OpenFalcon OpenF

随机推荐

  • 英文常见姓氏列表

    写论文时需要统一参考文献格式 外国人的名字经常分不清姓和名 这里汇总了大部分的外国人姓 美国人 1 史密斯 Smith 这一姓氏源自一种职业 是从事金属加工业的男士的姓氏 smith本身有铁匠或锻工之意 金属加工是最初几个对专业能力有特定要

  • 夜莺(Flashcat)V6监控(二)：夜莺页面全网最详细功能介绍及案列

    目录 一 如何把数据转发给多个时序库 二 监控仪表盘的配置 三 告警的配置管理 1 告警规则 基础配置 规则配置 分为Metric和Host机器类型的告警 生成配置 通知配置 2 内置规则 3 屏蔽规则 4 订阅规则 5 活跃告警 6 历史

  • Python编程 从入门到实践 12-4

    12 4 按键 创建一个程序 显示一个空屏幕 在事件循环中 每当检测到 pygame KEYDOWN 事件时都打印属性 event key 运行这个程序 并按各种键 看看 Pygame如何响应 import sys import pygam

  • node多版本安装--nvm丝滑切换node版本

    以下是我总结得俩种nvm切换node版本的方式 首先是第一种 需要手动配置的 第一步把自己电脑上面的node卸载 在本机应用程序中卸载 然后手动本机目录删除剩余残留node npm等文件 C Users 86184 AppData C Us

  • 函数的极值点、零点、驻点、拐点的理解

    总结 零点 函数值为0的点 极值点 函数单调性发生变化的点 驻点 函数的一阶导数为0的点 拐点 函数凹凸性变化的点 学习链接 https wenku baidu com view 4a009cf5650e52ea5418982e html

  • [工程数学]1_特征值与特征向量

    首先向b站up DR CAN致敬 视频二刷了 为了收获 理解更多 用极慢的方式 把笔记抄了下来 整理一遍 为了好翻阅 后续会转成pdf格式 放微信公众号后台获取 现代控制理论 2 state space状态空间方程 在state space

  • java是什么_Java是什么？Java有什么用？

    我们经常提到Java 很多小白只听说过但对其并没有太多具体的了解 那么Java是什么 Java有什么用 今天就来探讨一下 我们常常会听说 Java是世界第一语言 很多应用软件的开发都离不开Java Java真的这么强大吗 其实 Java的内

  • 多链路传输技术在火山引擎 RTC 的探索和实践

    动手点关注 干货不迷路 传统的数据传输方式大多是利用一个链路 选择设备的默认网卡进行传输 使用这种方式实现实时音视频通话时 如果默认网络出现问题 如断网 弱网等 用户的通信就会发生中断或者卡顿 影响用户体验 多链路传输 顾名思义 就是使用多

  • electron_vue—实现消息通知 及 解决通知不显示问题

    实现消息通知 window linux macOS 这三个操作系统都为应用程序提供了向用户发送通知的方法

  • python使用pip安装出现pip is configured with locations that require TLS/SSL异常处理方法

    问题描述 最近给服务器安装python环境 通过源码方式安装Python3 8之后 使用pip功能出现异常 提示 root localhost pip3 install you get pip is configured with loca

  • 大数据处理中的关键算子：分割（Split）和选择（Select）

    在大数据处理中 分割 Split 和选择 Select 是两个常用的算子 它们在数据转换和处理过程中发挥着重要的作用 本文将详细介绍这两个算子的功能和使用方法 并附上相应的源代码示例 1 分割 Split 分割算子用于将一个数据集拆分成多个

  • 图的深度遍历和广度遍历

    理论部分 图的深度遍历和广度遍历都不算很难像极了二叉树的前序遍历和层序遍历 如下面的图 可以用右边的邻接矩阵进行表示 假设以顶点0开始对整幅图进行遍历的话 两种遍历方式的思想如下 1 深度优先遍历 depthFirstSearch DFS

  • LISN到底是啥？干啥用的？

    LISN到底是啥 干啥用的 LISN是在EMC测试的时候 会被使用的设备 如下图所示 双路V型电源阻抗稳定网络 它完全符合CISPR16 1 2 MIL STD 461F VDE 0876 FCC Part 15标准的要求 其等效电路为50

  • 20191004

    A 解 1 我们发现只需要关心处于结果字符串前 k 位的字符 因此考虑从后往前处理 对于一个询问区间 我们暴力连边 用并查集维护 x 的父亲等于 y 相当于位于 x 的字符是从位于 y 的字符处复制过来的 然后删掉这个区间 更新其他元素的排

  • Hutool BeanUtils.copyProperties的四种用法 空不拷贝/忽略拷贝/空不和忽略拷贝/全拷贝

    关注公众号 奇叔码技术 回复 java面试题大全 或者 java面试题 即可领取资料 一 Hutool BeanUtils copyProperties的四种用法 空不拷贝 忽略拷贝 空不和忽略拷贝 全拷贝 1 第一种用法 BeanUtil

  • STM32-CubeMX学习笔记

    例程参考链接 http bbs elecfans com jishu 714935 1 1 html 1 首次使用参见文档 http blog csdn net tq384998430 article details 53466263 2

  • 彻底搞懂Java中的synchronized关键字

    synchronized的作用 synchronized 的作用主要有三 原子性 所谓原子性就是指一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断 要么就都不执行 被synchronized修饰的类或对象的所有操作都是原子

  • 【歪门邪道】懒得麻烦UI同学切图所以用AndroidStudio生成icon

    每次新建项目 是不是都默认生成一个 ic launcher 对于这个icon 你是不是从来都是一删了事 你有没有一次 打开并留意过里头 ic launcher foreground 和 ic launcher background 文件 如

  • 关于以太坊的nonce值

    文章目录 每笔交易nonce值的各个情况 总结 关于Nonce的保管 依赖节点 自行管理nonce 参考代码 nonce在区块链中是一个非常重要的概念 从比特币到以太坊都有nonce的身影 在比特币中 nonce主要用于调整pow挖矿的难度

  • Go语言学习——4、数据存储：数组，切片，映射

    目录 一 数组 1 声明数组 2 初始化数组 3 遍历数组 二 切片 1 从数组或切片生成新的切片的语法格式 2 直接生成一个新的切片 3 切片添加元素 4 从切片删除元素 5 遍历切片 三 映射 1 声明映射 2 初始化映射 3 遍历映射

热门标签