首先模拟一个原生的http请求 因为有python的经验 学习Go起来比较容易上手 通过原生的http请求获得请求返回的值 并打印
package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    //生成client参数为默认
    client := &http.Client{}
    url := "https://www.zhijinyu.com"
    request, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println(err)
    }
    // 获取返回结果
    fmt.Println(request)
    response, _ := client.Do(request)
    // 将结果定位到标准输出 也可以直接打印出来 或者定位到其他地方进行相应的处理
    stdout := os.Stdout
    fmt.Println(response)
    // 将获取的内容复制到标准输出
    _, err = io.Copy(stdout, response.Body)

    // 返回的状态码
    status := response.StatusCode
    fmt.Println(status)
}
上面的代码已经实现了访问http请求的例子 感觉比较简单并且容易上手 但是我们一般不用这种方式 so 接下来我们使用http包来搭建一个服务器
package main

import (
    "fmt"
    "net/http"
    "strings"
)

func reqSite(w http.ResponseWriter, r *http.Request) {
    _ = r.ParseForm() // 解析参数
    fmt.Println(r.Form)
    fmt.Printf("url: %v\n", r.URL.Path)
    fmt.Printf("scheme: %v\n", r.URL.Scheme)
    for k, v := range r.Form {
        fmt.Println("传参的key: ", k)
        fmt.Printf("传参的val: %v\n", strings.Join(v, ""))
    }
    // 页面写入
    _, err := fmt.Fprintf(w, "Hello Webserver!")
    if err != nil {
        panic("数据写入过程异常!")
    }
}

func main() {
    http.HandleFunc("/", reqSite)                     // 设置访问路由
    err := http.ListenAndServe("localhost:8080", nil) //设置监听的ip和端口
    if err != nil {
        fmt.Println(nil)
    }
}
打开浏览器访问 http://localhost:8080 访问结果如下

由上实现的webserver真的是太简单了, 是不是对Go语言有更多的兴趣去学习了呢?
注册路由

提供url模式和handler函数的映射,并实例化一个server对象,并开启对客户端的监听。

自己动手试试吧!
使用python操作Elasticsearch
win安装请参考文章 https://www.zhijinyu.com/article/161/detail/
from elasticsearch import Elasticsearch
from elasticsearch.helpers import bulk
from elasticsearch import exceptions
from elasticsearch_dsl import Search
from elasticsearch_dsl.query import MultiMatch, Match

class ElasticObj:

    def __init__(self, index_name, doc_type, ip="127.0.0.1", port=9200):
        self.index_name = index_name  # 索引名字
        self.doc_type = doc_type  # 索引类型
        self.ip = ip  # ip 主机
        self.port = port  # 端口
        self.es = Elasticsearch([{'host': ip, 'port': port}])

    def create_index(self, index_name=None):
        """
        # 创建索引
        :param index_name:  索引名字
        :return:
        """
        if index_name is None:
            index_name = self.index_name

        # 创建映射
        index_mappings = {
            "settings": {
                "number_of_shards": 3,
                "number_of_replicas": 1
            },
            "mappings": {
                "properties": {
                    "title": {
                        "type": "text",
                        "index": True,
                        "analyzer": "english",
                        "search_analyzer": "english"
                    },
                    "date": {
                        "type": "text",
                        "index": True
                    },
                    "keyword": {
                        "type": "text",
                        "index": False
                    },
                    "source": {
                        "type": "text",
                        "index": False
                    },
                    "link": {
                        "type": "text",
                        "index": False
                    }
                }
            }
        }
        if self.es.indices.exists(index=index_name) is not True:
            res = self.es.indices.create(index=index_name, body=index_mappings)
            return res, True
        else:
            return "索引已经存在", False

    def create_single_data(self, data):
        """
        # 一次创建一条数据
        :param data:
        :return: error_num: 失败数量
        """
        error_num = 0
        for item in data:
            # 不知道id
            res = self.es.index(index=self.index_name, doc_type=self.doc_type, body=item)
            if res['_shards']['failed'] != 0:
                error_num += res['_shards']['failed']
            print(res)
        else:
            return error_num, True

    def create_bulk_data(self, data):
        """
        使用bulk批量插入数据
        :param data: 传入要插入的数据
        :return:  success成功条数  bool 值
        """
        li = []
        for item in data:
            action = {
                "_id": item['id'],  # 也可以不指定id
                "_index": self.index_name,
                "_type": self.doc_type,
                "_source": {
                    "date": item['date'],
                    "source": item['source'],
                    "link": item['link'],
                    "keyword": item['keyword'],
                    "title": item['title']}
            }
            li.append(action)
        success, _ = bulk(self.es, li, index=self.index_name, raise_on_error=True)
        print(success)
        return success, True

    def delete_index_data(self, id):
        """
        删除指定id的索引
        :param id:  传入删除的索引id
        :return:
        """
        try:
            res = self.es.delete(index=self.index_name, doc_type=self.doc_type, id=id)
            return res, True
        except exceptions.NotFoundError as e:
            print('当前id未找到!')
            return str(e), False

    def get_data_by_id(self, id):
        # res = self.es.get_source(index=self.index_name, doc_type=self.doc_type, id=id)  # 获取存储的内容
        res = self.es.get(index=self.index_name, doc_type=self.doc_type, id=id)  # 获取id、index、类型、版本、_source等等
        print(res)
        return res, True

    def get_data_by_body(self):
        # doc = {
        #     "query": {
        #         "match": {
        #             "id": 2   # 搜索条件
        #         }
        #     }
        # }
        # _searched = self.es.search(index=self.index_name, body=doc)
        # print(_searched)
        # print(len(_searched))
        # for k in _searched['hits']['hits']:
        #     print(k)
        # print(len( _searched['hits']['hits']))
        # return _searched

        # q 搜索内容 size 指定个数  from_ 指定起始位置 filter_path 可以指定需要显示的数据,如本例中显示在最后的结果中的只有 _id 和 _type。
        res_1 = self.es.search(index=self.index_name, q="中国文明网", size=12, from_=1, filter_path=['hits.hits._id',
                                                                                                'hits.hits._type'])
        for x in res_1['hits']['hits']:
            print(x)
        print(res_1)
        print(len(res_1['hits']['hits']))

    def get_index_all(self, index_name):
        # 获取指定索引的所有数据
        res = Search(using=self.es, index=index_name).execute()
        print(res.to_dict())
        print(len(res.to_dict()['hits']['hits']))
        return res.to_dict()

    def get_condition(self):
        # 单个字段查询
        s = Search(using=self.es, index=self.index_name).query("match", source="慧聪网")

        s = s.execute()
        return s.to_dict()

    def get_multi_condition(self):
        # 多条件查询
        multi_match = MultiMatch(query='慧聪网', fields=['title', 'source'])
        s = Search(using=self.es, index=self.index_name).query(multi_match)
        s = s.execute()
        return s.to_dict()


if __name__ == '__main__':
    list_ = [
        {
            "id": 1,
            "date": "2017-09-13",
            "source": "慧聪网",
            "link": "http://info.broadcast.hc360.com/2017/09/130859749974.shtml",
            "keyword": "电视",
            "title": "付费 电视 行业面临的转型和挑战"
        },
        {"id": 2,
            "date": "2017-09-13",
         "source": "中国文明2网",
         "link": "http://www.wenming.cn/xj_pd/yw/201709/t20170913_4421323.shtml",
         "keyword": "电视",
         "title": "电视 专题片《巡视利剑》广获好评:铁腕反腐凝聚党心民心"
         }
    ]
    es = ElasticObj("孙行12者", "孙行者_type")
    es.create_bulk_data(list_)

在Go语言的反射机制中,任何接口值都由是一个具体类型和具体类型的值两部分组成的。 在Go语言中反射的相关功能由内置的reflect包提供,任意接口值在反射中都可以理解为由reflect.Typereflect.Value两部分组成,并且reflect包提供了reflect.TypeOfreflect.ValueOf两个函数来获取任意对象的Value和Type。

Go语言的反射中像数组、切片、Map、指针等类型的变量,它们的.Name()都是返回空。
想要在函数中通过反射修改变量的值,需要注意函数参数传递的是值拷贝,必须传递变量地址才能修改变量值。而反射中使用专有的Elem()方法来获取指针对应的值。
package main

import (
    "fmt"
    "reflect"
)

// 获取当前x的类型  反射
func reflectType(x interface{}) interface{} {
    fmt.Println(reflect.TypeOf(x).Kind()) // 类型
    fmt.Println(reflect.TypeOf(x).Name()) // 名字
    return reflect.TypeOf(x)
}

// 通过反射获取值
func reflectValue(x interface{}) {
    v := reflect.ValueOf(x) // 获取值
    k := v.Kind()           // 获取值的类型
    fmt.Println(v)
    fmt.Printf("%T\n", v)
    switch k {
    case reflect.Float32:
        // 将反射之后的类型转化为原来用户的类型
        ret := float32(v.Float())
        fmt.Printf("%T\n", ret)
    case reflect.Int32:
        ret := int32(v.Int())
        fmt.Printf("%T\n", ret)
    }

}

// 通过反射设置值
func reflectSetValue(x interface{}) {
    v := reflect.ValueOf(x)
    k := v.Elem().Kind() // 通过反射指针获得值的类型
    switch k {
    case reflect.Float32:
        v.Elem().SetFloat(3.12) // 通过指针反向获取值并设置值
    case reflect.Int32:
        v.Elem().SetInt(64)
    }
    fmt.Println(v.Elem())
}

func main() {
    a := "大鱼"
    b := float32(12)
    c := int32(18)
    d := make(map[string]interface{}, 8)
    reflectSetValue(&a)
    reflectSetValue(&b)
    reflectSetValue(&c)
    reflectSetValue(&d)
}
文件的读写相关操作
package main

import (
    "bufio"
    "fmt"
    "io"
    "io/ioutil"
    "os"
)

func main() {
    // 打开当前文件夹下的 test.txt 相对路径 文件读取
    fileObj, err := os.Open("src/code.test.com/文件操作/test.txt")
    defer fileObj.Close()

    if err != nil {
        fmt.Println(err)
        return
    }
    reader := bufio.NewReader(fileObj)

    /* for {
        // 按行读取
        line, data, err := reader.ReadLine()
        if err == io.EOF {
            return
        }
        fmt.Println(string(line))
        fmt.Println(data)
    }  */
    for {
        // 按指定字节读取
        data, err := reader.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                break
            }
        }
        fmt.Printf(string(data))
    }

    write()
}

func write() {
    filename := "src/code.test.com/文件操作/test.txt"
    fileObj, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer fileObj.Close()
    /*  普通的写入
    strData := "我是你大哥兄弟!\n"
    data, err := fileObj.Write([]byte(strData)) // 字节类型
    fmt.Println(data)

    dataLen, err := fileObj.WriteString("说一段神话\n") // 字符串类型
    if err != nil {

    }
    fmt.Println(dataLen)
    */

    /*
        缓冲区写入  减少磁盘io次数
        strData1 := "话说这么一家"
        writer := bufio.NewWriter(fileObj)
        index, err := writer.WriteString(strData1)
        if err != nil {
            fmt.Println(index)
        }
        err = writer.Flush() // 写入到磁盘  如果不写则不会写入
        if err != nil {
            fmt.Println(err)
        }
    */

    // ioutil写入
    err = ioutil.WriteFile(filename, []byte("花果山水帘洞孙行者!"), 644)
    if err != nil {
        fmt.Println(err)
    }
}
Go语言获取 多长时间之前 或者之后的时间
时间的加减操作
package main

import (
    "fmt"
    "time"
)

func main() {

    now := time.Now()
    // 获取之后一个小时的时间  之前的话直接加符号
    fmt.Println(now)
    fmt.Println(now.Add(time.Hour))

    // 获取之前一天的时间
    fmt.Println(now)

    // 增加一年 二个月 一天的时间  3个参数年月日
    fmt.Println(now.AddDate(1, 2, 1))

    // 获取一年 二个月 一天之前的时间
    fmt.Println(now.AddDate(-1, -2, -1))
}