过去用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、打工是发不了财的、但是前期要积累工作经验和锻炼品质，竭尽全力把工作做好！再想办法开拓其他的赚钱方式！

• 股票：沪深交易所股票的基本信息以及日/分钟级别的股票行情。
•  
• 财务报表：沪深港上市公司披露的2007年会计准则变更以来的所有财务报表数据，包含三大报表和财报附注等细节。
•  
• 公司行为：沪深上市公司业绩预告，业绩快报，IPO，配股，分红，拆股，股改等信息。
•  
• 基金：场内外各类基金的基本信息，日/分钟级别的场内基金行情，日级别的场外基金净值，以及基金资产配置，收益情况，净值调整等信息。
•  
• 期货：国内四大期货交易所期货合约的基本信息，日/分钟的期货行情，以及国债期货的转换因子等信息。
•  
• 指数：国内外指数基本信息，日/分钟级别的指数行情，以及指数成分构成情况，指数成分股权重情况等信息。
•  
• 港股：香港交易所股票基本信息以及日级别的股票行情。
•  
• 大宗商品：国内各个品种（包括期货合约可交割品种）的大宗商品现货价格行情，以及产销量，库存等信息。
•  
• 债券：债券/回购基本信息，日级别的债券/回购行情，以及发行上市，付息，利率，评级和评级变动，债券发行人评级及变动，担保人评级及变动等信息。
•  
• 期权：上交所期权合约的基本信息，日/分钟级别的期权行情，以及每日盘前静态数据等信息。
•  
• 宏观产业：中国及全球各国宏观指标，行业经济指标等数据。

• 股票/指数等品种的量化因子库
•  
• 雪球、股吧等社交媒体数据
•  
• 主流媒体新闻文本和结构化数据
•  
• 主流渠道公告文本和结构化数据
•  
• 淘宝、天猫等电商数据

import datetime



start = '2018-01-01'                       # 回测起始时间

end = '2021-05-28'                         # 回测结束时间

benchmark = 'HS300'                        # 策略参考标准

freq = 'd'                                 # 策略类型，'d'表示日间策略使用日线回测，'m'表示日内策略使用分钟线回测            

refresh_rate = 5 # 调仓频率，表示执行handle_data的时间间隔，若freq = 'd' 时间间隔的单位为交易日，

hold_num = 10 # 持有转债的个数



    

def initialize(context):

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    MyPosition = {}  #持仓

    MyCash = 1000000  #现金

    Start_Cash= 1000000

    HighValue = MyCash  #最高市值

    Withdraw = 0  #最大回撤

    HoldRank = hold_num  #排名多少之后卖出

    HoldNum = hold_num  #持债支数

    

def bonds(beginDate=u"20170101",endDate=u"20201215",EB_ENABLE=False):

    code_set = set()

    df = DataAPI.MktConsBondPremiumGet(SecID=u"",

                                       tickerBond=u"",

                                       beginDate=beginDate,

                                       endDate=endDate,

                                       field=u"",

                                       pandas="1")



    cb_df = df.tickerBond.str.startswith(('12', '11'))

    df = df[cb_df]

    cb_df = df.tickerBond.str.startswith('117')

    df = df[~cb_df]

    if not EB_ENABLE:

        eb = df.secShortNameBond.str.match('\d\d.*?E[123B]')  # TODO 判断EB是否过滤

        df = df[~eb]



    ticker_list = 

    for _, row in df[['tickerBond', 'secShortNameBond', 'tickerEqu']].iterrows():

        if row['tickerBond'] not in code_set:

            ticker_list.append((row['tickerBond'], row['secShortNameBond'], row['tickerEqu']))

            code_set.add(row['tickerBond'])

    return list(code_set)





def handle_data(context):    

    global MyPosition, HighValue, MyCash, Withdraw, HoldRank, HoldNum,Start_Cash

    

    today_date = context.now.strftime('%Y%m%d')

    

    #每天重新计算双低排名

    ticker_list=bonds(today_date,today_date)

    data = DataAPI.MktConsBondPerfGet(beginDate=today_date,endDate=today_date,secID='',tickerBond=ticker_list,

                                      tickerEqu=u"",field=u"",pandas="1")

    data['secID']=data['tickerBond']

    data.set_index('secID',inplace=True)

    data['DoubleLow'] = data['closePriceBond'] + data['bondPremRatio']

    data = data.sort_values(by="DoubleLow" , ascending=True)

    PosValue = MyCash

    

    #抛出不在持有排名HoldRank的

    for stock in MyPosition.keys():

        try:

            CurPrice = data.loc[stock]['closePriceBond']

        except:

            last_date = (context.now + datetime.timedelta(days=-7)).strftime('%Y%m%d')

            CurPrice=get_last_price(stock,last_date,today_date)



        PosValue += MyPosition[stock] * CurPrice * 10 #计算当前市值

        

        if stock not in data.index[:HoldRank]:

            # 省略若干

                

            log.info('{} 卖出{},{},价格：{}'.format(today_date,stock,name,CurPrice))

  

            

    if PosValue > HighValue:HighValue = PosValue

    if (HighValue - PosValue) / HighValue > Withdraw:Withdraw = (HighValue - PosValue) / HighValue

    

    #买入排在HoldRank内的，总持有数量HoldNum

    min_hold = min(HoldRank,len(data.index))

    for i in range(min_hold):

        if len(MyPosition) >= HoldNum:break

        if data.index[i] not in MyPosition.keys():

            # 省略若干

            log.info('{} 买入{}, {}, 价格{}, 溢价率{}'.format(today_date,data.index[i],name,price,cb_ration))



    ratio = (PosValue-Start_Cash)/Start_Cash*100

    log.info(today_date + ': 最高市值 ' + str(HighValue) + ' , 当前市值 ' + str(PosValue) + '收益率 ： '

             +str(ratio)+'% , 最大回撤 ' + str(round(Withdraw*100,2))+'%') [/i][/i]

[i]欢迎讨论探索，星球里面有更多的完整策略与代码，回测数据，结论资源。
 

助记词就是私钥，你有助记词，管它倒闭不倒闭，跟你没有任何关系。

钱包公司只是给你提供服务，私钥在，财产永远是你的。

复制并分享你的链接，你和被邀请人同时奖励 10亿枚 ShiBZilla，每人最多可邀请 40人，奖励最高可获得 400亿枚 ShiBZilla。

hexo 网站图床图片不显示

最近搭建了一个七牛云图床，外链不用 HTTPS 的话是免费的，搭配 PicGo 和 Typora 使用，在 Markdown 中插入图片非常方便，只需要复制图片，粘贴到 Typora 中，就可以自动调用 PicGo 上传并且获取链接了，但是在使用中遇到一个问题，本站在本地运行 hexo server 的情况下访问，所有图片显示正常，但是上传到服务器之后再访问，就会出现图片不显示的情况，复制图片 URL 访问也可以访问到。最终在 hexo 的 github 页面问到了可能是 Mixed Content 的问题。

具体来说，在调试工具中发现，显示存在 HTTP 和 HTTPS 资源混用的情况，导致不会读取资源。先后尝试了在 hexo\themes\...\layout\_partial\head.ejs 中添加

1 2
<meta name="referrer" content="no-referrer" /> <meta http-equiv="Content-Security-Policy" ontent="upgrade-insecure-requests">

都不起作用，而升级七牛云为 HTTPS 流量又要收费，遂干脆把网站改回到了 HTTP，因为是静态页面其实也没什么关系，而且每 3 个月重新注册一个证书有时候懒的搞，反而导致页面不能正常访问。

 * CPU          AMD EPYC 7K62 48-Core Processor (1) 64-bit AES VM

                L2:8.0 MB L3:16.0 MB 2C/2T NUMA:1

 * MEMORY       3.6/3.7 GB (96%)

                DIMM 0: 4 GB RAM @ 0 MHz DIMM 0

 * MOTHERBOARD  Tencent Cloud - CVM

 * DONATE       0%

 * ASSEMBLY     auto:ryzen

 * POOL #1      mine.c3pool.com:17777 algo auto

 * COMMANDS     'h' hashrate, 'p' pause, 'r' resume, 's' results, 'c' connection

[2021-11-28 00:08:00.267]  net      mine.c3pool.com:17777 connect error: "operation canceled"

[2021-11-28 00:08:25.292]  net      mine.c3pool.com:17777 connect error: "operation canceled"

[2021-11-28 00:08:50.317]  net      mine.c3pool.com:17777 connect error: "operation canceled"

1.  安装docker镜像：docker pull v2fly/v2fly-core ， 这里懒得用bash安装逐个脚本了，免得出现一堆依赖关系，直接docker一行命令搞定。