python中复合数据类型有_Go 语言学习笔记 -第4章复合数据类型
Go 语言学习笔记 -第4章
[toc]
复合数据类型
数组
Golang中操作数组或者序列化数据需要用到slice，程序中写作“[]"
slice 指向数组的值，并且同时包含了长度信息
package main
import "fmt"
func main() {
// list := []int{1, 2, 3, 4}
list := [...]int{1, 2, 3, 4}
fmt.Println(list)
fmt.Printf("Type %T\n", list)
for i := 0; i < len(list); i++ {
fmt.Printf("list[%d]=%d\n", i, list[i])
}
//重新切片s[low:high], low->(high-1)
fmt.Println(list[1:1]) //[]
fmt.Println(list[0:3]) //[1 2 3]
fmt.Println(list[:2]) //[1 2]
fmt.Println(list[1:]) //[2 3 4]
fmt.Println(list[:0]) //[]
}
切片slice
package main
import "fmt"
func main() {
//使用make进行声明切片
list := make([]int, 5)
fmt.Println("list=", list) //list= [0 0 0 0 0]
fmt.Printf("len=%d,cap=%d", len(list), cap(list)) //len=5,cap=5
}
切片长度和容量,长度为5,容量为5
默认情况下长度和容量是一样的
怎么理解长度和容量？
切片的长度就是它所包含的元素个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
再看一个例子：
package main
import "fmt"
func main() {
aSlice := []int{1, 2, 3, 4, 5}
fmt.Printf("before aSlice length=%d,cap=%d,self=%v\n", len(aSlice), cap(aSlice), aSlice)
//before aSlice length=5,cap=5,self=[1 2 3 4 5]
aSlice = append(aSlice, 6)
fmt.Printf("after aSlice length=%d,cap=%d,self=%v\n", len(aSlice), cap(aSlice), aSlice)
//after aSlice length=6,cap=10,self=[1 2 3 4 5 6]
//这里如何理解？加入一个元素，但是容量增加了一倍？并没有变成6?
bSlice := make([]int, 5, 10)
bSlice[0] = 1
bSlice[1] = 2
bSlice[2] = 3
bSlice[3] = 5
bSlice[4] = 6
fmt.Printf("before bSlice length=%d,cap=%d,self=%v\n", len(bSlice), cap(bSlice), bSlice)
//before bSlice length=5,cap=10,self=[1 2 3 5 6]
bSlice = append(bSlice, 6)
fmt.Printf("after bSlice length=%d,cap=%d,self=%v\n", len(bSlice), cap(bSlice), bSlice)
//after bSlice length=6,cap=10,self=[1 2 3 5 6 6]
// list := make([]int, 3, 5)
// fmt.Println(len(list), cap(list))
// list[0] = 1
// list[1] = 2
// list[2] = 3
// // list[3] = 4
// fmt.Println(len(list), cap(list))
// fmt.Println("list=", list)
}
如果我们最开始 slice 的容量是 10，长度是 5 ，那么再加一个元素是不会改变切片的容量的。
也就是说，当我们往 slice中增加元素超过原来的容量时，slice 会自增容量，
当现有长度 < 1024 时 cap 增长是翻倍的，当超过 1024，cap 的增长是 1.25 倍增长
可以查看slice.go源码
下面几个链接地址可以看看：
map散列
1.map 的作用类似哈希表或者python里面的字典
基本语法：
var map 变量名 map[keytype] valuetype
valuetype的类型和key基本一样：
通常为: 数字、string、map、struct
注意：
声明式不会分配内存的，初始化需要make,分配内存后才能赋值和使用
例子：
package main
import "fmt"
func main() {
//map声明
var a map[string]string
a = make(map[string]string)
//上面两行也可以写成一行 a := make(map[string]string)
//在使用map前,需要先make, make的作用是给map分配数据空间
//key不能重复，如果重复了以最后一个为准
//值是可以重复的
//key-value是无序的, 也就是print没有顺序
//这里如果值写的是整数类型而不是字符串类型，就会报错-----强判断型
a["no1"] = "AA"
a["no2"] = "BB"
a["no1"] = "CC"
a["no3"] = "DD"
fmt.Println(a)
}
2.map三种方式
package main
import "fmt"
func main() {
//第一种方式
// var a map[string]string
// a = make(map[string]string, 10)
//第二种方式
// a := make(map[string]string)
// a["no1"] = "AA"
// a["no2"] = "BB"
// a["no1"] = "CC"
// a["no3"] = "DD"
//第三种方式
a := map[string]string{
"no1": "AA",
"no2": "BB",
}
fmt.Println("a=", a)
}
3.map的使用
package main
import "fmt"
func main() {
a := make(map[string]string)
a["no1"] = "AA"
a["no2"] = "BB"
a["no1"] = "CC"
a["no3"] = "DD"
//删除
// delete(a, "no1")
//删除不存在的key,删除不会操作，也不会报错
// delete(a, "no4")
//一次性删除所有key
// a = make(map[string]string)
//查询key
val, ok := a["no6"]
if ok {
fmt.Println("no1=", val)
} else {
fmt.Println("没有key")
}
}
4.map遍历
package main
import "fmt"
func main() {
a := make(map[string]string)
a["no1"] = "AA"
a["no2"] = "BB"
a["no1"] = "CC"
a["no3"] = "DD"
//遍历map
// for k, v := range a {
// fmt.Printf("k=%v, v=%v\n", k, v)
// }
//长度
fmt.Println("length:", len(a))
}
5.map切片
package main
import "fmt"
func main() {
a := make([]map[string]string, 2)
if a[0] == nil {
a[0] = make(map[string]string, 2)
a[0]["no1"] = "AA"
a[0]["no2"] = "BB"
}
if a[1] == nil {
a[1] = make(map[string]string, 2)
a[1]["no1"] = "CC"
a[1]["no2"] = "DD"
}
// if a[2] == nil {
// a[2] = make(map[string]string, 2)
// a[2]["no1"] = "EE"
// a[2]["no2"] = "FF"
// }
//动态增加
newa := map[string]string{
"no1": "111",
"no2": "22",
}
a = append(a, newa)
fmt.Println("a:", a)
}
结构体
Golang没有class, 用结构体来实现class特征
去掉了传统OOP的继承、方法重载、构造函数、析构函数、隐藏的this指针等
具体继承、封装、多态，只是实现方式跟其他OOP语言不一样
1.结构体例子
package main
import "fmt"
//结构体
type Cat struct {
Name string
Age int
Color string
}
func main() {
var cat1 Cat
//访问结构体变量，直接用.符号连接
//结构体可以給部分成员赋值
cat1.Name = "小白"
cat1.Age = 3
cat1.Color = "白色"
fmt.Println("cat1=", cat1)
}
2.结构体与slice map
package main
import "fmt"
//结构体
type Cat struct {
Name string
Age int
Color string
ptr *int
slice []int
map1 map[string]string
}
func main() {
var cat1 Cat
cat1.Name = "小白"
cat1.Age = 3
cat1.Color = "白色"
//使用slice要先make
cat1.slice = make([]int, 10)
cat1.slice[0] = 100
//使用map要先make
cat1.map1 = make(map[string]string)
cat1.map1["key1"] = "tom"
fmt.Println("cat1=", cat1)
}
3.结构体赋值
package main
import "fmt"
//结构体
type Monster struct {
Name string
Age int
}
func main() {
var monster1 Monster
monster1.Name = "牛魔王"
monster1.Age = 500
monster2 := monster1 //默认是值拷贝
monster2.Name = "狐狸精"
fmt.Printf("monster1=%v, monster2=%v", monster1, monster2)
//monster1={牛魔王 500}, monster2={狐狸精 500}
}
package main
import "fmt"
//结构体
type Monster struct {
Name string
Age int
}
func main() {
//方法1
// var monster1 Monster
// monster1 := Monster{}
// monster1.Name = "牛魔王"
// monster1.Age = 500
//方法2
// monster1 := Monster{"牛魔王", 500}
//方法3
var p3 *Monster = new(Monster)
(*p3).Name = "牛魔王"
(*p3).Age = 500
//(*p3).Name也可以写成p3.Name = "xxx"
p3.Name = "狐狸精"
p3.Age = 100
//方法4, 通过指针进行获取
var monster *Monster = &Monster{}
(*monster).Name = "玉兔精"
// monster.Name = "XX"
fmt.Printf("monster1=%v", monster)
}