UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe4 in position 1: invalid continuation byte

c=b'\x1e\xe4\xd5\x97\x9a#\x99kC\xadD\x7f\x9a\xc2G\x92'

b.decode('utf8',errors='replace')

无影云桌面 (Elastic Desktop Service），是一种易用、安全、高效的云上桌面服务。它支持快速便捷的桌面环境创建、部署、统一管控与运维。无需前期传统硬件投资，帮您快速构建安全、高性能、低成本的企业桌面办公体系。可广泛应用于具有高数据安全管控、高性能计算等要求的安全办公、金融、设计、影视、教育等领域。

from flask import Flask



app = Flask(__name__)



@app.route('/')

def hello_world():

    return 'Hello, World!'



if __name__ == '__main__':

    app.run(host='0.0.0.0')

async def app(scope, receive, send):

    await send({

        'type': 'http.response.start',

        'status': 200,

        'headers': [

            [b'content-type', b'text/html']

        ]

    })



    await  send({

        'type': 'http.response.body',

        'body': b'Hello This is server running',

        'more_body': False

    })

from tornado import  ioloop

from tornado import web

class Homepage(web.RequestHandler):



    def get(self):

        print('get method')

        self.write("This is tornado server")



if __name__ == '__main__':

    app = web.Application([

        ("/",Homepage),



    ])



    app.listen(8888)

    ioloop.IOLoop.current().start()

 package main

   

  import "github.com/gin-gonic/gin"

   

  // 测试专用

   

func main() {                                                               

      r := gin.Default()

      r.GET("/index", func(c *gin.Context) {

          c.JSON(200, gin.H{"message": "Working"})

      })  

      r.GET("/", func(c *gin.Context) {

          c.JSON(200, gin.H{"message": "Working"})

      })  

      r.Run()

  }

yum -y install sudo

$ go get -u github.com/lestrrat-go/libxml2                     

# pkg-config --cflags -- libxml-2.0 Package libxml-2.0 was not found in the pkg-config search path. 

Perhaps you should add the directory containing `libxml-2.0.pc' to the PKG_CONFIG_PATH environment variable 

No package 'libxml-2.0' found pkg-config: exit status 1 ​ ​

sudo apt install libxml2-dev

yum install libxml2

yum install libxml2-devel

去年高三帮好朋友给实验班的男孩子写一封信 只有“山有木兮木有枝”七个字 想让他领会后半句心悦君兮君不知的含义 第二天男孩子主动来班里送信 还是昨天那封 他在后面补充到“心悦君兮君已知 奈何十二寒窗苦 待到金榜题名时” 后来这段故事无疾而终 愿你们遇到的每段感情都能有处安放

func NewNotSafeCounter() *NotSafeCounter {

	return &NotSafeCounter{0}

}

 ngrok config add-authtoken <token>

 ngrok http 80

import hashlib

import web



class Handle(object):

    def GET(self):

        try:

            data = web.input()

            if len(data) == 0:

                return "hello, this is handle view"

            signature = data.signature

            timestamp = data.timestamp

            nonce = data.nonce

            echostr = data.echostr

            token = "xxxx" #请按照公众平台官网\基本配置中信息填写



            list = [token, timestamp, nonce]

            list.sort()

            sha1 = hashlib.sha1()

            map(sha1.update, list)

            hashcode = sha1.hexdigest()

            print "handle/GET func: hashcode, signature: ", hashcode, signature

            if hashcode == signature:

                return echostr

            else:

                return ""

        except Exception, Argument:

            return Argument

# -*- coding: utf-8 -*-



# -*- coding: utf-8 -*-

# filename: handle.py



import hashlib

import web



class Handle(object):



    def POST(self):

        pass



    # get方法，验证token

    def GET(self):

        try:

            data = web.input()

            if len(data) == 0:

                return "token success!"

            signature = data.signature

            timestamp = data.timestamp

            nonce = data.nonce

            echostr = data.echostr

            token = "123456abcdefg"  # 请按照公众平台官网\基本配置中信息填写,两个token保持一致



            list = [token, timestamp, nonce]

            list.sort()

            sha1 = hashlib.sha1()

            sha1.update(list[0].encode("utf-8"))

            sha1.update(list[1].encode("utf-8"))

            sha1.update(list[2].encode("utf-8"))

            hashcode = sha1.hexdigest()  # 获取加密串



            # 验证

            print("handle/GET func: hashcode, signature: ", hashcode, signature)

            if hashcode == signature:

                return echostr

            else:

                return ""



        except Exception as Argument:

            return Argument

过去用java，python,php,等语言，将一个时间格式化成一个字符串都是用“yyy-MM-dd hh:mm:ss”之类的方法，golang 的格式化方法真令我大开眼界



先看官方文档说明：



func (Time) Format

func (t Time) Format(layout string) string

Format returns a textual representation of the time value formatted according to layout, which defines the format by showing how the reference time, defined to be



Mon Jan 2 15:04:05 -0700 MST 2006

would be displayed if it were the value; it serves as an example of the desired output. The same display rules will then be applied to the time value. Predefined layouts ANSIC, UnixDate, RFC3339 and others describe standard and convenient representations of the reference time. For more information about the formats and the definition of the reference time, see the documentation for ANSIC and the other constants defined by this package.





下面给个代码：



fmt.Println(time.Now().Format("2006-01-02 150405"))



要注意那时间，只能是2006-01-02 15:04:05分，其它的时间都不行，真是够绝。

{ "username": "root", "password": "123456", "host": "1.1.1.1.", "port": 3306, "db": "admin" }

type T struct { 



username string `json:"username"` 

password string `json:"password"` 

host string `json:"host"` 

port int `json:"port"` 

db string `json:"db"` 



}

var t T

	data, err := ioutil.ReadFile(filename)

	fmt.Println("read from file")

	//fmt.Println(string(data))

	if err != nil {

		fmt.Println("in error")

		fmt.Println(err)

		return err

	}

	err = json.Unmarshal(data, &t)

	if err != nil {

		fmt.Println("error ")

		fmt.Println(err)

		return err

	}

	fmt.Println("outpout ")

	fmt.Printf("%v\n", t)

	fmt.Println(t)

type T struct {

	Username string `json:"username"`

	Password string `json:"password"`

	Host     string `json:"host"`

	Port     int    `json:"port"`

	Db       string `json:"db"`

}

// 数据源

{"type":"a_number", "data":{"somenumber":1234}}

{"type":"b_string", "data":{"somestring":"a string", "anotherstring": "a second string"}}`

type Head struct {

    Type  string `json:"type"`

    Data json.RawMessage `json:"data"`

}





var msg Head



json.Unmarshal([]byte(jsonString), &msg)



switch msg.Type {

    case "a_number":

        var detail A

        json.Unmarshal([]byte(msg.Data),&detail)

        fmt.Println(detail.SomeNumber)

    case "b_string":

        var detail B

        json.Unmarshal([]byte(msg.Data),&detail)

        fmt.Println(detail.SomeString)

    default:

        fmt.Printf("I don't know about type %s!\n",  msg.Type)

}

failed to start INotebook in kernel, UI Disabled = false s [Error]: Unable to start Kernel 'base (Python 3.8.3)' due to connection timeout.  View Jupyter [log](command:jupyter.viewOutput) for further detail

pip install traitlets==4.3.3

#coding:gbk



'''

回测模型示例（非实盘交易策略）



本策略每隔1个月定时触发计算1000能源（399381.SZ）、1000材料（399382.SZ）、1000工业（399383.SZ）、

1000可选（399384.SZ）、1000消费（399385.SZ）、1000医药（399386.SZ）这几个行业指数过去

20个交易日的收益率并选取了收益率最高的指数的成份股并获取了他们的市值数据

随后把仓位调整至市值最大的5只股票上

该策略在股票指数日线下运行

'''

import numpy as np

import math

def init(ContextInfo):

    MarketPosition ={}

    ContextInfo.MarketPosition = MarketPosition #初始化持仓

    index_universe = ['399381.SZ','399382.SZ','399383.SZ','399384.SZ','399385.SZ','399386.SZ'] 

    index_stocks = []

    for index in index_universe:

        for stock in ContextInfo.get_sector(index): # 获取指数的成分股

            index_stocks.append(stock)

    ContextInfo.set_universe(index_universe+index_stocks)   #设定股票池,

    ContextInfo.day = 20

    ContextInfo.ratio = 0.8

    ContextInfo.holding_amount = 5

    ContextInfo.accountID='testS'



def handlebar(ContextInfo):

    buy_condition = False

    sell_condition = False

    d = ContextInfo.barpos

    print(d)

    lastdate = timetag_to_datetime(ContextInfo.get_bar_timetag(d - 1), '%Y%m%d')

    date = timetag_to_datetime(ContextInfo.get_bar_timetag(d), '%Y%m%d')

    print(date)

    index_list = ['399381.SZ','399382.SZ','399383.SZ','399384.SZ','399385.SZ','399386.SZ']

    return_index = []

    weight = ContextInfo.ratio/ContextInfo.holding_amount

    size_dict = {}

    if  (float(date[-4:-2]) != float(lastdate[-4:-2])):

        #print '---------------------------------------------------------------------------------'

        #print '当前交易日',date,date[-4:-2] 20210101 获取到的月份不一样，这样在每个月初会执行一次这个函数

        

        # 获取的是股票池的

        his = ContextInfo.get_history_data(21,'1d','close')

        

        #print "his",his,timetag_to_datetime(ContextInfo.get_bar_timetag(d),"%Y%m%d")

        for k in list(his.keys()):

            if len(his[k]) == 0:

                del his[k]

        for index in index_list:

            ratio = 0

            try:

                ratio = (his[index][-2] - his[index][0])/his[index][0]

            except KeyError:

                print('key error:' + index)

            except IndexError:

                print('list index out of range:' + index)

            return_index.append(ratio)

        # 获取指定数内收益率表现最好的行业

        best_index = index_list[np.argmax(return_index)]

        #print '当前最佳行业是：', ContextInfo.get_stock_name(best_index)[3:]+'行业'

        # 获取当天有交易的股票

        index_stock = ContextInfo.get_sector(best_index)

        stock_available = []

        for stock in index_stock:

            if ContextInfo.is_suspended_stock(stock) == False: # 是否停牌

                stock_available.append(stock)

                

        for stock in stock_available:

            if stock in list(his.keys()):

                #目前历史流通股本取不到，暂用总股本

                if len(his[stock]) >= 2:

                    stocksize =his[stock][-2] * float(ContextInfo.get_financial_data(['CAPITALSTRUCTURE.total_capital'],[stock],lastdate,date).iloc[0,-1])

                    size_dict[stock] = stocksize

                elif len(his[stock]) == 1:

                    stocksize =his[stock][-1] * float(ContextInfo.get_financial_data(['CAPITALSTRUCTURE.total_capital'],[stock],lastdate,date).iloc[0,-1])

                    size_dict[stock] = stocksize

                else:

                    return

        size_sorted = sorted(list(size_dict.items()), key = lambda item:item[1]) # 根据股本顺序排序

        pre_holding = []

        

        for tuple in size_sorted[-ContextInfo.holding_amount:]: # 最好不要占用关键词

            pre_holding.append(tuple[0])

        #print '买入备选',pre_holding

        #函数下单

        if len(pre_holding) > 0:

            sellshort_list = []

            for stock in list(ContextInfo.MarketPosition.keys()): # 遍历持仓，如果不在当前条件范围内，卖出

                if stock not in pre_holding and (stock in list(his.keys())):

                    order_shares(stock,-ContextInfo.MarketPosition[stock],'lastest',his[stock][-1],ContextInfo,ContextInfo.accountID)

                    print('sell',stock)

                    sell_condition = True

                    sellshort_list.append(stock)

            if len(sellshort_list) >0: # 这句多余

                for stock in sellshort_list:

                    del ContextInfo.MarketPosition[stock]

            

            for stock in pre_holding:

                if stock not in list(ContextInfo.MarketPosition.keys()): # 买入

                    Lots = math.floor(ContextInfo.ratio * (1.0/len(pre_holding)) * ContextInfo.capital / (his[stock][-1] * 100))

                    order_shares(stock,Lots *100,'lastest',his[stock][-1],ContextInfo,ContextInfo.accountID)

                    print('buy',stock)

                    buy_condition = True

                    ContextInfo.MarketPosition[stock] = Lots *100

问一个基础

func main() {

	v := [...]int{1: 2, 3: 4}

	fmt.Println( len(v))

}



这个为什么长度是 4?

v数组分配内存[0,2,0,4]，所以长度为4。

1、有时候选择大于努力（投资炒股->炒美股）

2、不努力就没有选择的机会（名校本科+研究生+充分准备面试技巧+争取工作调动）

3、关键点很重要，在最关键的时候，必须全力一击！

4、富贵险中求，适当冒一点险（风控能力）

5、越早开始存钱，越好

6、打工是发不了财的、但是前期要积累工作经验和锻炼品质，竭尽全力把工作做好！再想办法开拓其他的赚钱方式！