go3

时间 2019-11-13

标签 go3 繁體版

原文原文链接

亲密---我感受,能够用和人和事处的时间长短,并用心前端

难?不去作?java

前做业:

1.什么是微服务
将整个项目，按照功能拆分，拆分后可以更容易地部署，扩展，没有技术壁垒python

2.微服务用什么优点，go或者py去作，怎么实现
经过RPC框架去连通mysql

3.分布式CAP理论是什么
了解分布式CAP理论
C：强一致性，全部节点同一时间数据彻底一致
A：可用性：服务一直可用（zookeeper）
P：分区容错性：出现分区问题了，能自动处理
CAP是3进2的原则，不可能都实现
RDBMS（CA），Redis（CP），大多数网站架构（AP）ios

4 . 分布式数据库BASE理论是什么?web

BASE: 基本可用,最终一致性
简单来讲,就是经过让系统,返送对某一时刻一致性的要求,达到面试

5 . mysql范式, 1,2,3 范式是什么, 逆范式有啥用?redis

1NF -- 原子性 , 关系数据库自动的
2NF -- 惟一性 , 主键
3NF -- 冗余性约束 , 外键算法

面试:外键查 , 链表查问得多,毕竟后端
没有外键,也能够链表查?sql

为了效率,牺牲一些范式,冗余

6 . 事务ACID是什么?

A:原子性,不可分割,要么都执行,要么都不执行
C:一致性,多个事务要保持一致
I:隔离性,多个事务不互相干扰
D:持久性,永久改变

7 . 数据库事务有哪些并发问题,为了解决这些问题,对应哪一个隔离级别<
mysql默认的级别有哪些?

脏读:T1读取到了T2未提交的修改的数据
不可重复读:T1没有提交时,读到了T2已经提交事务修改的数据
幻读:T1没有提交时,读到了 T2删除或者增长的字段

隔离级别:
读未提交:上面问题都会出现
读已提交:解决了脏读
可重复读:解决了不可重复读 Mysql默认的级别
串行化: 都解决了,不用--> 把别的都锁死了,效率低

8.分布式应用场景有哪些

分布式存储: mysql,oracle,HDFS(存大量数据TB以上,数据结构复杂(图片,视频什么都有))
分布式缓存: redis, memcache(缓存的,直接到内存,(redis还要给持久化存储到内存),更快,错误率低)
分布式服务: 微服务, SOA
分布式协调: zookeeper (公司里的大脑,集群全部的节点用此管理)
分布式消息队列: mq,kafka
分布式数据平台: storm
分布式等等: solr,Elsearch

做业:

go的面试题, go会的人少,网络能搭就行了,不问的那么细

映射,改的是下面的arr()

python是拷贝

mysql也有视图,同样的

len和cap

学新东西如何学?

若是不会的怎么处理?

为何要看文档,写文档,而不是看视频(前因后果)

由于作产品,你要作的是某一部分的.而不是都作了,原理的可能也不须要懂

作技术,追新,而不是别人弄出来了.视频的,前因后果都弄出来了,没有价值了,用别人的,别人作出来的为何会给你用呢!

把全部的gin项目都下载下来(34个),都运行一下,
而后运行,哪一个能够运行(10),
而后运行的还有注释(3),再研究

切片

func main(){
    // 建立切片
    // 跟数组区别就是不指定长度
    var s1 []int
    s2 := []int{}  // {} 必须得有值,赋个空
    // := 省略容量,就认为是同样的
    var s3 []int = make([]int ,0)
    var s4 []int = make([]int ,0,0)
    fmt.Println(s1,s2,s3,s4)   //[] [] [] []
}

切片 , 视图修改

func main(){
    arr:= [...]int{0,1,2,3,4,5,6,7}
    fmt.Println("arr[:6]",arr[:6])
    fmt.Println("arr[2:6]",arr[2:6])
    fmt.Println("arr[2:]",arr[2:])
    fmt.Println("arr[:]",arr[:])
}


func main(){
    var s1 []int
    s1 = append(s1,1)
    s1 = append(s1,2,3)
    s1 = append(s1,4,5,6)
    fmt.Println("s1",s1)  //s1 [1 2 3 4 5 6]

    s2 := make([]int,5)
    s2 = append(s2,6)
    fmt.Println(s2)   // [0 0 0 0 0 6]

    //s3:=[]int{1,2,3}

}

切片视图以及len和cap

func main(){
    // go 语言切片是视图的操做
    arr := [...]int{0,1,2,3,4,5,6,7}
    s1 := arr[2:]
    s1[0] = 100
    fmt.Println(s1)  // [100 3 4 5 6 7]

    // 坑
    fmt.Println(arr)  // [0 1 100 3 4 5 6 7]

    s2 := arr[2:6]
    s3 := s2[3:5]
    fmt.Println(s2,s3)  // [100 3 4 5] [5 6]
    // 6哪来的? 也是视图操做, 去arr中取
    // arr中没有的话, panic: runtime error: slice bounds out of range
    //  python 更重于开发,效率高 mvc快 // go 并发高,异步处理好,后端
    // 语法上有区别

    fmt.Println("s2=%v,len(s2)=%d,cap(s2)=%d\n",s2,len(s2),cap(s2))   // %v 类型  cap容量 ,取到最后
    //  [100 3 4 5] 4 6
}

一直切,看视图,不append了

func main(){
    arr := [...]int{0,1,2,3,4,5,6,7}
    s1 := arr[2:6]
    s2 := s1[3:5]
    s3:= append(s2,10)
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(arr)
    //[2 3 4 5]
    //[5 6]
    //[5 6 10]
    //[0 1 2 3 4 5 6 10]
    s4:= append(s3,11)
    fmt.Println(s4)  // [5 6 10 11]
    fmt.Println(arr)  // [0 1 2 3 4 5 6 10]  //不添加了,容量一直到7 , 替换了10 后来无法添加了

}

copy()

func main(){
    data  := []int{0,1,2,3,4,5,6,7,8,9}
    s1 := data[3:]
    s2 := data[:3]
    fmt.Println(s1,s2)  // [3 4 5 6 7 8 9] [0 1 2]
    // 将第二个切片元素,拷贝到第一个里面
    // 从前面日后面覆盖
    copy(s2,s1)
    fmt.Println("s1",s1)   // s1 [3 4 5 6 7 8 9]
    fmt.Println(s2)  // [3 4 5]
    fmt.Println(data)  // [3 4 5 3 4 5 6 7 8 9]
}

Map : 相似字典

func main(){
    // 1
    var m1 map[int]string
    fmt.Println(m1 == nil)  // true
    // 2
    m2 := map[int]string{}
    m3 := make(map[int]string)   // 和 var同样的
    m4 := make(map[int]string,5)  //指定长度的

    fmt.Println(m1,m2,m3,m4)  // map[] map[] map[] map[]

}

Map 初始化

func main(){
    // 初始化
    var m1 map[int]string = map[int]string{1:"xx",2:"yy",3:"xx",4:"yy",5:"xx",6:"yy"}

    fmt.Println(m1)  // map[1:xx 2:yy] 无序的 , 2:,1:,
    m2:= map[int]string{1:"id",2:"name"}
    m2[1] = "gender"
    m2[3] = "hobby"  //没有的话会追加
    fmt.Println(m2)   // map[1:gender 2:name 3:hobby]

    // 遍历
    for k,v := range m1{
        fmt.Printf("%d--->%s\n",k,v)  //2--->yy   3--->xx
    }

    // 删除 delete()
    delete(m1,3)   // 删除为3的  删除没有的不报错,处理了
    fmt.Println(m1)     // map[1:xx 2:yy 4:yy 5:xx 6:yy]
}

结构体

// 建立一个学生的类
type Student struct{
    id int
    name string
    sex byte
    age int
    addr string
}

func main(){
    // 1. 直接初始化
    var s1 Student = Student{1,"张三",'f',18,"沙河"}  // byte 用单引号
    fmt.Println(s1)

    // 2. 指定初始化成员
    s2 := Student{id:2,age:20}   // {1 张三 102 18 沙河}
    fmt.Println(s2)   // {2  0 20 }
    // 3. 结构体做为指针变量初始化
    var s3 *Student = &Student{3,"李四",'f',20,"沙河"}
    // 取一个字段
    fmt.Println((*s3).id)  //便于知道哪一个是指针   // 3
    fmt.Println(s3.id)   // 3

    // 指针和非指针对象区别: 传递出去是引用仍是值传递 ..
}

2

// 建立一个学生的类
type Student1 struct{
    id int
    name string
    sex string
    age int
    addr string
}
// 定义普通传递
func tmpStudent1(tmp Student1){
    tmp.id = 111
    fmt.Println("tmp=",tmp)
}


// 定义指针传递
func tmpStudent2(p *Student1){
    p.id = 222
    fmt.Println("p=",p)
}


func main(){
    // 1. 直接初始化
    var s1 Student1 = Student1{1,"张三","f",18,"沙河"}  // byte 用单引号
    tmpStudent1(s1)
    fmt.Println(s1)
    //tmp= {111 张三 f 18 沙河}
    //{1 张三 f 18 沙河}

    tmpStudent2(&s1)
    fmt.Println(s1)   // 改了

    //p= &{111 张三 f 18 沙河}
    //{111 张三 f 18 沙河}

    // 2. 指定初始化成员
    s2 := Student1{id:2,age:20}   // {1 张三 102 18 沙河}
    fmt.Println(s2)   // {2  0 20 }
    // 3. 结构体做为指针变量初始化
    var s3 *Student1 = &Student1{3,"李四","f",20,"沙河"}
    // 取一个字段
    fmt.Println((*s3).id)  //便于知道哪一个是指针   // 3
    fmt.Println(s3.id)   // 3
    
    // 指针和非指针对象区别: 传递出去是引用仍是值传递 ..
}

面向对象

继承

// 人
type Person struct {
    name string
    sex string
    age int
}
type Student2 struct {
    //
    Person   //继承
    id int
    addr string
}
func main(){
    // 给继承的对象赋值
    s1 := Student2{Person{"张三","female",20},1,"北京"}
    s2 := Student2{Person:Person{name:"李四"},id:2}
    fmt.Println(s1)  // {{张三 female 20} 1 北京}
    fmt.Println(s2)   // {{李四  0} 2 }
}

同名

type Student2 struct {
    // 匿名字段
    Person   //继承
    id int
    addr string

    // 同名字段
    name string
}
func main(){
var s Student2
    s.name = "zs"
    fmt.Println(s)   //{{  0} 0  zs}
    //为父类字段赋值
    s.Person.name= "王五"   
    fmt.Println(s)   // {{王五  0} 0  zs}
}

自定义类型

package main
// 人
type Person3 struct {
    name string
    sex string
    age int
}

// 基础类型
type mystr string

type Student3 struct {
    Person3   //自定义类型
    mystr  //自定义类型
    int   //内置类型
} 

func main(){
    
}
//用法和上面是同样的

指针类型的匿名字段

type Person4 struct {
    name string
    sex string
    age int
}

type Studnet4 struct {
    *Person4
    id int
    addr string
}
func main(){
    // 指针类型的匿名字段
    s1 := Studnet4{&Person4{"zs","female",11,},1,"shahe"}
    fmt.Println(s1)    // {0xc00005c360 1 shahe}
    fmt.Println(s1.name)     //zs

}

给string提供mystr,

面向对象方法

type MyInt int

// 传统定义方式
func Add(a,b MyInt)MyInt{
    return a+b
}
// 面向对象的定义方式

func (a MyInt) Add(b MyInt) MyInt{
    return a+b
}

func main(){
    var a MyInt = 1
    var b MyInt = 2
    fmt.Println("Add(a,b)=",Add(a,b))   // Add(a,b)= 3  //面向过程其实
    fmt.Println("a.Add(b)", a.Add(b))   // a.Add(b) 3   //面向对象
}

面向对象自定义类型

// 结构体做为接收者
type Person5 struct {
    name string
    sex string
    age int
}

type Studnet5 struct {
    Person5
    id int
    addr string
}
// 算是封装了
func (p Person5) testxx(){
    fmt.Println(p.name,p.sex)   // p是别名
}
func main(){
    s1 := Studnet5{Person5{"zhang","f",11},1,"shahe"}
    s1.testxx()  // zhang f
}

中国和美国, 相差五年, 看5年前的美国,参考一点 ---或者能够研究一下(火了比较稳得),刚火的,机会更大了.可是一阵

ios 和 Android至关简单,不用写前端,后台传数据,.可是也容易被替代,刚开始20.而后如今不行了. 学技术不要学太简单的,容易被换

将来的三驾马车:java 大数据 go 区块链 python 人工智能
基础语言之上的

20万 python 百万级的数据用java

// 引用语义
func (p *Person6) setInfoPointer(){
    (*p).name = "zhangsan"
    p.sex = "f"
    p.age = 22
    fmt.Println(p.name,p.sex,p.age)   // p是别名
}

//值语义
func (p Person6) setInfoValue(){
    p.name = "zhangsan"
    p.sex = "f"
    p.age = 23
    fmt.Println(p.name,p.sex,p.age)   // p是别名
}
func main(){
    p1 := Studnet6{Person6{"zhang","f",11},1,"shahe"}
    fmt.Println("方法调用前=",p1)
    (&p1).setInfoPointer()
    fmt.Println("方法调用后=",p1)


    p2 := Studnet6{Person6{"san","f",21},1,"shahe"}
    fmt.Println("方法调用前=",p2)
    p2.setInfoValue()
    fmt.Println("方法调用后=",p2)

    //方法调用前= {{zhang f 11} 1 shahe}
    //zhangsan f 22
    //方法调用后= {{zhangsan f 22} 1 shahe}
    //方法调用前= {{san f 21} 1 shahe}
    //zhangsan f 23
    //方法调用后= {{san f 21} 1 shahe}
}

16 test 有问题

面向对象 get 和set

// 结构体做为接收者
type Person9 struct {
    name string
    sex string
    age int
}

type Studnet9 struct {
    Person9
    id int
    addr string
}


// 引用语义
func (s *Person9)info(){

    fmt.Printf("Person:%s,%s,%d\n",s.name,s.sex,s.age)
}

func(p *Person9) setName(name string){
    p.name = name
}
func(p *Person9) getName()string{
    return p.name
}
func(p *Person9) sing() {
    fmt.Printf("%c, 在唱lallala",p.name)
}
func test01(){
    p2 := Person9{"zs","m",20}
    p2.setName("liu")
    p2.sing()
}
 //方法和字段
func main(){
    test01()
}

结构 (函数大写)

test
mytest.go
test2
ttt.go

mytest.go-->

package test

import "fmt"

// 结构体做为接收者
type Person9 struct {
    name string
    sex string
    age int
}

type Studnet9 struct {
    Person9
    id int
    addr string
}


// 引用语义
func (s *Person9)info(){

    fmt.Printf("Person:%s,%s,%d\n",s.name,s.sex,s.age)
}

func(p *Person9) setName(name string){
    p.name = name
}
func(p *Person9) getName()string{
    return p.name
}
func(p *Person9) sing() {
    fmt.Println("lallala")
}
func Test01(){
    p2 := Person9{"zs","m",20}
    p2.sing()
}

ttt.go

package main

import "d3/test"

func main(){
    test.Test01()
}

gin是web框架

Beego中国人的框架

http://www.javashuo.com/article/p-tinzmpvo-kk.html

接口

package main

import "fmt"

// 定义人的接口
type Humaner interface{
    Say()
}

// 结构体

type Student10 struct {
    name string
    score int
}

func (s *Student10)Say(){
    fmt.Printf("Studnet[%s,%d] 瞌睡不断\n",s.name,s.score)
}

type Teacher struct {
    name string
    group string
}
func (s *Teacher)Say(){
    fmt.Printf("Studnet[%s,%s] 不断\n",s.name,s.group)
}


// 多个对象实现接口
// 自定义类型
type Mystr string

func (s Mystr)Say(){
    fmt.Printf("咱们爱学习")
}

// 实现多态 谁进来谁say
func WhoSay(i Humaner){
    i.Say()
}

func main(){
    s := &Student10{"zs",90}
    t := &Teacher{"zs","GO"}
    var tmp Mystr = "学习"
    s.Say()
    t.Say()
    tmp.Say()
    //  Studnet[zs,90] 瞌睡不断
    //Studnet[zs,GO] 不断
    //咱们爱学习

    WhoSay(s)
    WhoSay(t)
    WhoSay(tmp)
    //咱们爱学习Studnet[zs,90] 瞌睡不断
    //Studnet[zs,GO] 不断
    //咱们爱学习
}

接口的继承

// 定义人的接口
type Humaner interface{
    Say()
}
// 接口的继承  
type Personer interface {
    Humaner
    //定义
}

多继承

// 定义人的接口
type Humaner interface{
    Say()
}
type Humaner1 interface{
    Say2()
}
// 接口的继承
type Personer interface {
    Humaner
    Humaner1
}

断言

package main

import "fmt"

// 空接口
type Elementer interface {

}

type Person10 struct {
    name string
    age int
}

func main(){
    list := make([]Elementer,3)  //接口类型的切片
    list[0]= 1
    list[1]= "zhangsan"
    list[2]= Person10{"zs",20}  //对象

    // 类型断言语法  : value, ok = element.(T)
    for index,element := range list{
        if value,ok := element.(int);ok{
            fmt.Printf("list[%d]是int类型,值是%d\n",index,value)
        }else if value,ok := element.(string);ok{
            fmt.Printf("list[%d]是string类型,值是%s\n",index,value)
        }else if value,ok := element.(Person10);ok{
            fmt.Printf("list[%d]是Person10类型,值是[%s,%d]\n",index,value.name,value.age)
        }else{
            fmt.Printf("list[%d]是其余类型\n",index)
        }
    }
}


// list[0]是int类型,值是1
//list[1]是string类型,值是zhangsan
//list[2]是Person10类型,值是[zs,20]
//能够改为switch

1. 抛异常和处理异常

系统抛

本身抛

package main

import "fmt"

// 系统抛
func test03(){
    a := [3]int{0,1,2}
    //a[8] = 3
    a[0] = 3
    index := 8
    a[index] = 4

}

// 本身抛

// 圆形的面积
func getArea(radius float32)(area float32){
    if radius<0{
        //预料到出错,本身抛
        panic("半径不能为负数")
    }
    return 3.14 * radius*radius
}

func Test03(){
    getArea(-1)
}

// 处理异常
func test02(){
    // 延迟函数? 延迟到何时? (1)程序正常结束 (2)出现异常
    defer func() {
        //recover() : 返回程序为何挂了
         if err := recover();err!=nil{
            fmt.Println(err)
         }
    }()
    getArea(-1)
    fmt.Println("这里有咩有执行")  // 没有
}
func test04(){
    test02()
    fmt.Println("test004有没有执行")
}

func main(){
    //test03()   // panic: runtime error: index out of range
    //Test03()  // panic: 半径不能为负数

    //test02()    //半径不能为负数
    test04()    //半径不能为负数  test004有没有执行

}

返回异常

package main

import (
    "errors"
    "fmt"
)

func getArea2(radius float32)(area float32, err error){
    if radius<0{
        //预料到出错,本身抛
        //panic("半径不能为负数")
        err = errors.New("半径不能为负数")
    }
    area =  3.14 * radius*radius
    return
}


func main(){
    area, err := getArea2(-1)
    //处理返回异常
    if err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println("area=",area)
    }
}

json

package main

import (
    "encoding/json"
    "fmt"
)

//结构体

type Person11 struct {
    //Name string
    //name string   // 字段若小写,编码json拿不到,还不报错
    //非要消息
    Name string `json:"name"`    // {"name":"zs","Hobby":"nv"}
    Hobby string
}
func main(){
    p := Person11{"zs","nv"}

    b, err := json.Marshal(p) //把什么均可以编程json
    if err != nil{
        fmt.Println("json:",err)
    }
    fmt.Println(b)   // [123 34 78 97 109 101 34 58 34 122 115 34 44 34 72 111 98 98 121 34 58 34 110 118 34 125]
    fmt.Println(string(b))   // {"Name":"zs","Hobby":"nv"}
    //改为小写的,不能识别//{"Hobby":"nv"}
}

mapjson

func main()  {
    m:=make(map[string]interface{})
    m["id"]=1
    m["name"]="zs"
    // map编码json
    mjson, err := json.Marshal(m)
    if err != nil{
        fmt.Println(err)
    }
    fmt.Println(string(mjson))
}

解析到结构体

type Person12 struct {
    Id int
    Name string
}

func main()  {
    b := []byte(`{"id":1,"name":"zs"}`)
    var p Person12
    err := json.Unmarshal(b,&p)
    if err!= nil{
        fmt.Println(err)
    }
    fmt.Println(p)
}

json解析到interface

func main()  {
    b := []byte(`{"id":1,"name":"zs"}`)
    var p interface{}
    err := json.Unmarshal(b,&p)
    if err!= nil{
        fmt.Println(err)
    }
    // json解析到interface , 默认json解析到map
    fmt.Println(p)
}

大数据: 综合的,什么都用到了

区块链: 技术,修改框架

人工智能:算法

比特币挖矿,有难度,就出一个

广播

每一个节点都有全部的数据,须要docker集群配置

⬆是b圈

链圈

去中心话,数据都在链上作,人越多越稳定,不然都要修改,

分红两个列的一种,很差的写法

shijian = pd.Series(shijian,index=list(range(1,len(time2)+1))) 
shijian
times = pd.Series(time2,index=list(range(1,len(time2)+1))) 
times
pdd = pd.concat((times,shijian),axis=1,join='inner')
 
pdd[1].value_counts()

把难的简化成简单的东西先尝试一下

计算多个重复值对应的数值相加

shi = ['a','b','c','a','c','b']
ti = [4,2,3,3,3,4]
b_zip = zip(shi,ti)
b_zip1 = dict(b_zip)
print(b_zip1)
 
for i in b_zip1:
    b_zip1[i]=0    //先都清空,为了加之后的值
# print(b_zip1)     
for j in b_zip1:   //须要的是这些被去重的值
#     print(j)
    for index,i in enumerate(shi): 
#         print(i)
        if i == j:   //重复的值等于被去重的值
            b_zip1[i]+=ti[index]  //,就+它对应的次数
print(b_zip1)

--->

{'a': 3, 'b': 4, 'c': 3}
{'a': 7, 'b': 6, 'c': 6}

print(shijian,time2)
a = zip(shijian,time2)
# print(dict(a))

shijian_dict = dict(a)
# print(shijian_dict)
for i in shijian_dict:
    shijian_dict[i]=0
for i in shijian_dict:
    for index,j in enumerate(shijian):
        if i == j:
            shijian_dict[i] += time2[index]
print(shijian_dict)

['08-18', '08-16', '08-17', '08-18', '08-15', '08-17', '08-19', '07-29', '08-08', '07-25', '08-12', '07-26', '07-25', '08-04', '07-25', '07-30', '07-28', '07-29', '07-22', '07-27', '08-03', '07-28', '08-12', '07-27', '07-29', '08-13', '08-12', '08-01', '08-08', '08-09', '07-24', '08-09', '08-02', '07-31', '07-25', '07-26', '08-13', '08-01', '07-30', '08-17', '07-23', '08-13', '07-22', '08-13', '07-30', '08-08', '08-05', '07-26', '08-07', '08-13', '08-10', '08-03', '08-05', '08-01', '07-26', '07-28', '07-13', '07-25', '08-06', '08-03', '07-30', '07-26', '08-17', '08-07', '08-15', '07-28', '07-26', '08-12', '07-25', '07-29', '08-07', '08-13', '07-24', '07-31', '07-25', '08-06', '07-28', '07-30', '07-24', '08-02', '07-23', '07-26', '07-31', '08-07', '07-31', '07-31', '07-23', '08-06', '08-12', '07-29', '07-31', '07-25', '07-29', '07-28', '08-15', '08-05', '07-28', '08-07', '07-31', '07-26', '08-13', '07-30', '07-22', '07-26', '07-22', '08-13', '8G 25', '08-10', '08-15', '07-24', '07-29', '07-31', '07-25', '07-29', '07-23', '07-26', '07-25', '07-29', '07-31', '08-02', '08-12', '07-24', '08-08', '07-24', '08-09', '07-29', '06-18', '07-25', '07-28', '08-05', '07-28', '07-23', '08-11', '07-27', '08-19', '08-03', '07-10', '07-06', '07-27', '07-07', 'i5/8G', '07-11', '06-22', '07-06', '07-14', '07-17', '06-18', '05-17', '08-11', '06-23', '07-12', '08-04', '07-12', '06-04', '06-11', '07-06', '07-12', '07-13', '08-09', '07-31', '04-03', '07-06', '06-19', '07-09', '07-14', '07-06', '08-11', '07-15', '06-07', '03-09', '06-18', '08-05', '07-17', '07-03', '03-31', '04-16', '07-13', '08-01', '07-21', '07-18', '08-12', '04-09', '04-06', '08-14', 'i5/8G', '02-24', '07-17', '06-24', '05-05', '08-03', '06-18', '07-17', '08-04', '07-11', '08-05', '07-20', '07-05', '06-06', '05-08', '07-14', '08-14', '07-19', '06-22', '07-06', '07-05', '07-15', '07-12', '07-09', '07-17', '04-16', '03-12', '02-25', '07-19', '04-03', '07-07', '08-20', '06-02', '07-05', '06-06', '07-01', '06-19', '05-30', '08-09', '08-14', '08-20', '08-11', '08-10', '07-17', '08-06', '05-22', '05-11', '06-19', '07-07', '06-16', '05-28', '07-07', '07-09', '07-19', '05-01', '06-05', '07-16', '07-14', '07-10', '07-22', '02-23', '06-14', '08-20', '08-14', '07-13', '07-05', '08-01', '07-18', '08-01', '07-10', '06-27', '07-10', '06-02', '06-18', '07-21', '07-18', '07-08', '06-10', '06-17', '06-12', '07-17', '02-21', '07-15', '07-11', '06-05', '07-30', '05-21', '07-16', '06-18', '08-10', '07-07', '06-18', '07-14', '06-18', '02-24', '08-05', '07-06', '04-04', '07-12', '07-16', '07-11', '07-08', '06-26', '07-26', '07-01', '06-27', '06-25', '07-21', '06-01', '06-04', '06-25', '07-28', '06-15', '08-04', '08-03', '07-11', '08-20', '04-09', '08-06', '07-09', '06-08', '07-18', '06-25', '06-20', '08-15', '07-10', '07-20', '06-06', '05-12', '03-20', '08-20', '07-20', '07-28', '08-20', '08-20', '07-07', '06-28', '07-09', '07-06', '07-10', '05-03', '08-04', '08-11', '07-15', '06-20', '04-27', '08-12', '03-26', '06-15', '07-21', '08-20', '07-24', '06-06', '07-18', '06-18', '08-20', '06-16', '04-16', '07-06', '08-01', '06-02', '06-26', '07-12', '07-22', '07-06', '06-20', '07-18', '07-02', '07-13', '07-14', '07-18', '07-27', '08-09', '04-11', '07-07', '06-17', '06-04', '07-06', '06-09', '07-12', '03-28', '07-20', '07-15', '07-07', '07-10', '07-18', '07-28', '07-21', '06-10', '07-24', '06-05', '07-09', '08-14', '07-06', '07-10', '06-27', '07-10', '07-09', '07-11', '06-21', '08-03', '08-09', '07-15', '07-21', '05-02', '04-29', '07-13', '07-15', '06-22', '07-19', '06-18', '03-01', '07-21', '8GB/2', '05-06', '04-17', '06-18', '07-28', '06-21', '07-20', '02-23', '08-11', '07-04', '07-12', '06-13', '07-16', '06-16', '06-26', '07-13', '08-06', '07-17', '07-11', '06-12', '07-15', '04-06', '06-27', '07-25', '07-13', '06-18', '07-11', '08-14', '07-06', '07-22', '07-15', '07-24', '07-23', '07-10', '07-09', '07-01', '07-05', '06-09', '07-06', '02-20', '06-21', '07-15', '06-29', '03-29', '05-06', '06-11', '04-04', '04-04', '06-01', '06-25', '07-06', '07-11', '03-27', '07-09', '07-17', '08-19', '05-19', '07-08', '06-09', '07-09', '02-25', '06-11'] [3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
{'08-18': 6, '08-16': 3, '08-17': 10, '08-15': 10, '08-19': 6, '07-29': 21, '08-08': 8, '07-25': 23, '08-12': 14, '07-26': 21, '08-04': 6, '07-30': 13, '07-28': 22, '07-22': 11, '07-27': 8, '08-03': 11, '08-13': 16, '08-01': 10, '08-09': 10, '07-24': 15, '08-02': 6, '07-31': 19, '07-23': 11, '08-05': 11, '08-07': 10, '08-10': 6, '07-13': 9, '08-06': 9, '8G 25': 2, '06-18': 13, '08-11': 7, '07-10': 10, '07-06': 15, '07-07': 8, 'i5/8G': 2, '07-11': 9, '06-22': 3, '07-14': 6, '07-17': 9, '05-17': 1, '06-23': 1, '07-12': 8, '06-04': 3, '06-11': 3, '04-03': 2, '06-19': 3, '07-09': 10, '07-15': 10, '06-07': 1, '03-09': 1, '07-03': 1, '03-31': 1, '04-16': 3, '07-21': 7, '07-18': 8, '04-09': 2, '04-06': 2, '08-14': 6, '02-24': 2, '06-24': 1, '05-05': 1, '07-20': 5, '07-05': 5, '06-06': 4, '05-08': 1, '07-19': 4, '03-12': 1, '02-25': 2, '08-20': 9, '06-02': 3, '07-01': 3, '05-30': 1, '05-22': 1, '05-11': 1, '06-16': 3, '05-28': 1, '05-01': 1, '06-05': 3, '07-16': 4, '02-23': 2, '06-14': 1, '06-27': 4, '07-08': 3, '06-10': 2, '06-17': 2, '06-12': 2, '02-21': 1, '05-21': 1, '04-04': 3, '06-26': 3, '06-25': 4, '06-01': 2, '06-15': 2, '06-08': 1, '06-20': 3, '05-12': 1, '03-20': 1, '06-28': 1, '05-03': 1, '04-27': 1, '03-26': 1, '07-02': 1, '04-11': 1, '06-09': 3, '03-28': 1, '06-21': 3, '05-02': 1, '04-29': 1, '03-01': 1, '8GB/2': 1, '05-06': 2, '04-17': 1, '07-04': 1, '06-13': 1, '02-20': 1, '06-29': 1, '03-29': 1, '03-27': 1, '05-19': 1}

还没排序呢>:排序

print(cishu_lists)
cishu_lists.sort(reverse=True)
print(cishu_lists)

将这些数值取出来,用pycharts显示,:很差显示,排序是分开的

能够直接用pd排序,而后显示,次数和日期是对齐的,一个改都改,不用费事改两个了

shijian_lists = []
cishu_lists = []
for shijian,cishu in shijian_dict.items():
    shijian_lists.append(shijian)
    cishu_lists.append(cishu)

加两列的方式

shijian = pd.Series(shijian_lists,index=shijian_lists) 
shijian
times = pd.Series(cishu_lists,index=shijian_lists) 
times
pdd = pd.concat((shijian,times),axis=1,join='inner')


pdd1 = pdd.sort_values(1, ascending = False)[:20]   
pdd1.plot.bar()

加一列的方法

print(cishu_lists)
shijian_time = pd.Series(data=cishu_lists,index=shijian_lists) 
# print(shijian_time)
shijian_time = shijian_time.sort_values(ascending = False)[:30] 
print(shijian_time)
shijian_time.plot.bar()

最后显示 , 能够发现 6.18 那天还挺多的,可是为何7月份这么多评论的,不是

今日份错误: 好多的没有赋值回去因此不对,要么为None,要么数据没效果

shijian_time = shijian_time.sort_values(ascending = False)[:30]

须要赋值的

python中不须要赋值.傻傻分不清楚,每次都错,不是正反两面有一面,不是对就是错吗?