array_test

  1. package main
  3. import "fmt"
  5. func printArray(toPrint [5]string) {
  6.     //[] string 这是切片类型
  7.     toPrint[0] = "bobby"
  8.     fmt.Println(toPrint)
  9. }
  10. func main() {
  11.     //go语言中的数组和python的list可以对应起来理解 slice和python的list更像
  12.     //静态语言中的数组：1.大小确定 2.类型一致
  13.     //数组的申明
  14.     //var courses [10]string
  15.     //var courses = [5]string{"django", "scrapy", "tornado"}
  16.     course := [5]string{"django", "scrapy", "tornado"}
  17.     //静态语言要求严格，动态语言是一门动态类型的
  19.     //1.修改值 取值 删除值 添加某一个值 数组一开始就要指定大小
  20.     //取值 修改值
  21.     fmt.Println(course[0])
  22.     //修改值
  23.     course[0] = "django3"
  24.     fmt.Println(course)
  26.     //数组的另一种创建方式
  27.     //var a [4] float32
  28.     var a = [4]float32{}
  29.     fmt.Println(a)
  31.     var c = [5]int{'A', 'B'}
  32.     fmt.Println(c)
  33.     //首次接触语法糖 ...
  34.     d := [...]int{1, 2, 3, 4, 5}
  35.     fmt.Println(d)
  36.     //将index = 4的值置为100
  37.     e := [5]int{4: 100}
  38.     fmt.Println(e)
  40.     f := [...]int{0: 1, 4: 1, 9: 100}
  41.     fmt.Println(f)
  43.     //数组操作第一种场景: 求长度
  44.     fmt.Println(len(f))
  45.     //数组操作第二种场景: 遍历数组
  46.     for i, value := range course {
  47.         fmt.Println(i, value)
  48.     }
  49.     //使用for-range求和
  50.     sum := 0
  51.     for _, value := range f {
  52.         sum += value
  53.     }
  55.     //使用for语句也可以遍历数组
  56.     sum = 0
  57.     for i := 0; i < len(course); i++ {
  58.         sum += f[i]
  59.     }
  60.     fmt.Println(sum)
  62.     //数组是值类型
  63.     courseA := [3]string{}
  64.     courseB := [...]string{"django1", "scrapy1", "tornado1", "python+go", "asyncio"}
  65.     //courseA 和 courseB 应该是同一类型 都是数组类型
  66.     //在go语言当中courseA courseB都是数组， 但是不是同一种类型
  67.     fmt.Println("%T\n", courseA)
  68.     fmt.Println("%T\n", courseB)
  69.     //如果courseA courseB是同一种类型的话，为什么前面要加一个数字 长度不一样的数组类型是不一样的
  70.     //正是基于这些，函数在go语言中函数传递参数的时候,数组作为参数，实际调用的时候是值传递
  71.     printArray(courseB)
  72.     fmt.Println(courseB)
  73. }

map_test

  1. package main
  3. import "fmt"
  5. func main() {
  6.     //go语言中的map ->python中的dict
  7.     //go语言中的map的key和value类型声明的时候就要指明
  8.     //1.字面值
  9.     m1 := map[string]int{
  10.         "m1": 1,
  11.     }
  12.     fmt.Printf("%v\n", m1)
  14.     //2.make函数 make函数可以创建slice 可以创建map
  15.     m2 := make(map[string]int) //创建时不添加元素
  16.     m2["m2"] = 2
  17.     fmt.Printf("%v\n", m2)
  19.     //3.定义一个空的map
  20.     m3 := map[string]string{}
  21.     fmt.Printf("%v\n", m3)
  23.     //map中的key不是所有的类型都支持，该类型需要支持 ==或者 != 操作
  24.     //int rune
  25.     //a := []int{1, 2, 3}
  26.     //b := []int{1, 2, 3}
  27.     //两个切片之间不能比较
  28.     //if a == b {
  29.     //
  30.     //}
  31.     //var m1 map[[]int]string
  33.     //数组支持比较
  34.     //a := [3]int{1, 2, 3}
  35.     //b := [3]int{1, 2, 3}
  36.     //if a == b {
  37.     //    println("yes")
  38.     //}
  40.     //map的基本操作
  41.     m := map[string]string{
  42.         "a": "va",
  43.         "b": "vb",
  44.         "d": "",
  45.     }
  47.     //1.进行增加 修改
  48.     m["c"] = "vc"
  49.     m["b"] = "vb1"
  50.     fmt.Printf("%v\n", m)
  52.     //查询 你返回空的字符串到底是没有获取到还是值本身就是[]
  53.     v, ok := m["d"]
  54.     if ok {
  55.         fmt.Println("找到了", v)
  56.     } else {
  57.         fmt.Println("没找到", v)
  58.     }
  59.     fmt.Println(v, ok)
  61.     //删除
  62.     //delete(m, "a")
  63.     //delete(m, "e") //删除不存在的元素时 不抛异常
  64.     //delete(m, "a") //删除已经删除过的元素时 不抛异常
  65.     //fmt.Printf("%v\n", m)
  67.     //遍历
  68.     for k, v := range m {
  69.         fmt.Println(k, v)
  70.     }
  72.     //go语言中也有一个list 就是数据结构中提到的链表
  73.     //指针 为什么指针在java python等很多语言中不存在
  75. }

slice_test

  1. package main
  3. import "fmt"
  5. func replace(mySlice []string) {
  6.     mySlice[0] = "Wozen"
  7. }
  8. func main() {
  9.     //什么是切片
  10.     //数组有一个很大的问题 大小确定 不能修改 - 切片
  11.     //var identifier []type
  12.     //第一种：var courses []string //定义了一个切片
  13.     //var courses = []string{"django", "scrapy", "tornado"}
  14.     //fmt.Println(courses)
  15.     //fmt.Printf("%T\n", courses)
  17.     //切片的另一种初始化方法 make
  18.     //切片不是没有长度限制 为什么使用make初始化的时候需要我们传递一个长度
  19.     //那我传递了长度之后是不是意味着就像数组一样长度不能变了呢？
  20.     //第二种: courses := make([]int, 10, 15)
  21.     //println(cap(courses))
  22.     //println(len(courses))
  23.     //slice对标python中的list
  25.     //第三种方法 通过数组 变成一个切片
  26.     //var courses = [5]string{"django", "scrapy", "tornado", "python", "golang"}
  27.     //subCourse := courses[1:4] //python中的用法叫切片 go语言中切片是一种数据结构
  28.     //python中切片的用法非常灵活非常的多
  29.     //切片
  30.     //replace(subCourse)
  31.     //fmt.Println(subCourse)
  32.     //subCourse[0] = "hello"
  33.     //fmt.Println(courses)
  34.     //fmt.Printf("%T\n", subCourse)
  36.     //第四种方式: new
  37.     //subCourse := *new([]int) //[]
  38.     //subCourse := new([]int) //&[]
  39.     //fmt.Println(subCourse)
  41.     //数组的传递是值传递 切片不是 切片是引用传递
  42.     //slice很重要 很常用
  44.     //slice是动态数组 所以说我们需要动态添加值
  45.     //fmt.Println(subCourse[1])
  46.     //subCourse[1] = "bobby"
  47.     //fmt.Println(subCourse)
  48.     //subCourse2 := subCourse[1:3]
  49.     //fmt.Printf("%T, %v\n", subCourse2, subCourse2)
  51.     //append 函数 可以向切片元素追加元素
  52.     //subCourse2 = append(subCourse2, "anwma1", "anwma2", "anwma3")
  53.     //fmt.Println(subCourse2)
  55.     //append函数追加多个元素
  56.     //appendCourse := []string{"anwma1", "anwma2", "anwma3"}
  57.     //subCourse2 = append(subCourse2, appendCourse...)
  58.     //subCourse3 := make([]string, 2)
  59.     //subCourse3 := make([]string, len(subCourse2))
  60.     //fmt.Println(len(subCourse3))
  61.     //copy(subCourse3, subCourse2)
  63.     //拷贝的时候 目标对象长度需要设置好
  64.     //fmt.Println(subCourse3)
  66.     //append 函数 既然是切片 那为什么这个时候又来提出长度的要求
  67.     //想从slice中删除元素怎么办
  68.     //deleteCourses := [5]string{"django", "scrapy", "tornado", "python", "golang"}
  69.     //courseSlice := deleteCourses[:]
  70.     //courseSlice = append(courseSlice[:1], courseSlice[2:]...) //取巧的做法
  71.     //fmt.Println(courseSlice)
  73.     //如何判断某个元素在切片中
  75.     //python和go的slice区别 玩出花样 go的slice更像是python的list
  76.     //go语言的slice 是基于数组实现的 python的list底层也是基于数组实现的(C)
  77.     //slice进行的操作都会影响原来的数组 slice更像是一个指针 本身不存值
  79.     //slice的原理 因为很多底层的知识相对来说很多时候并不难而是需要花费比较多的时间去慢慢理解
  80.     //1.第一个现象
  81.     a := make([]int, 0)
  82.     b := []int{1, 2, 3}
  83.     fmt.Println(copy(a, b)) //0
  84.     fmt.Println(a)          //[]
  85.     //2.第二个现象 修改切片的时候影响原数组
  86.     c := b[:]
  87.     //c[0] = 8
  88.     fmt.Println(b) //[1 2 3]
  89.     fmt.Println(c) //[1 2 3]
  90.     //3.第三个现象
  91.     c = append(c, 9)
  92.     fmt.Println(b) //[1 2 3] //append函数没有影响到原来的数组
  93.     fmt.Println(c) //[1 2 3 9]
  94.     c[0] = 8
  95.     fmt.Println(b) //[1 2 3]
  96.     fmt.Println(c) //[8 2 3 9]//为什么append函数之后再调用c[0] = 8不会影响原来的数组呢
  97.     //4.第四个现象
  98.     fmt.Println(len(c))
  99.     fmt.Println(cap(c)) //cap指的是容量 长度 容量这是两个不同的概念
  100.     //切片底层是使用数组实现的 既要使用数组 又要满足动态的功能 怎么实现？
  101.     //假设有一个值 实际上申请数组的时候可能是两个
  102.     //如果后续要增加数据那么就直接添加到数据的结尾    这个时候我不要额外重新申请
  103.     //切片有不同的初始化方式
  104.     //1.使用make方法初始化 len 和 cap是多少
  105.     d := make([]int, 5, 6)
  106.     fmt.Printf("len=%d,cap=%d\n", len(d), cap(d))
  108.     //2.通过数组取切片
  109.     data := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  110.     slice := data[2:4]
  111.     newSlice := data[3:6]
  112.     for index, value := range slice {
  113.         fmt.Println(index, value)
  114.     }
  115.     fmt.Printf("len=%d,cap=%d\n", len(slice), cap(slice))
  116.     fmt.Printf("len=%d,cap=%d\n", len(newSlice), cap(newSlice))
  118.     //3.
  119.     slice2 := []int{1, 2, 3}
  120.     fmt.Printf("len=%d,cap=%d\n", len(slice2), cap(slice2))
  122.     //切片扩容问题 扩容阶段会影响速度 python中的list中底层实际上也是数组 也会面临动态扩容的问题
  123.     //python的list中数据类型可以不一致
  124.     oldSlice := make([]int, 0)
  125.     fmt.Printf("len=%d,cap=%d\n", len(oldSlice), cap(oldSlice))
  126.     oldSlice = append(oldSlice, 0)
  127.     fmt.Printf("len=%d,cap=%d\n", len(oldSlice), cap(oldSlice))
  128.     /*
  129.         Go中切片的扩容机制
  131.         首先判断，如果新申请（cap）大于2倍的就容量，最终容量（newcap)就是新申请的容量
  132.         否则判断，如果旧切片的长度小于1024 则最终容量（newcap)就是旧容量（old.cap）的两倍，即（newcap=doublecap）
  133.         否则判断，如果旧切片长度大于等于1024 则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4
  134.         即（newcap）
  135.         如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）
  136.     */
  137.     //如果小于1024 扩容速度是两倍 如果大于1024 扩容速度就是1.25倍
  139.     //切片来说
  140.     //1.底层是数组 如果是基于数组产生的 会有一个问题就是会影响原来的数组
  141.     //2.切片的扩容机制
  142.     //3.切片的传递是引用传递
  143.     oldArr := [3]int{1, 2, 3}
  144.     newArr := oldArr
  145.     newArr[0] = 5
  146.     fmt.Println(newArr, oldArr)
  148.     //go语言中slice的原理讲解很重要 有坑（对于初学者来说）
  149.     //有经验的程序觉得这个不是坑
  150.     //程序员也是消费者 - java c++ go python -才会站在使用者的角度上去考虑 对于处理器就不友好
  151.     //当make遇上了append容易出现的坑
  152.     s1 := make([]int, 5)
  154.     s1 = append(s1, 6)
  155.     fmt.Println(s1)
  156.     //很多人对make函数产生了一个假象 s1 := make([]int, 5) 好比是python的s1 = []
  157. }