• 股票：沪深交易所股票的基本信息以及日/分钟级别的股票行情。
•  
• 财务报表：沪深港上市公司披露的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一行命令搞定。

   func clickEvent(con *sync.Cond, fn HandleFun, id int) {        

       fmt.Println("waiting on broadcast")                        

                                                    

        fmt.Printf("Lock %d\n", id)                                

       con.L.Lock()  //需要现先lock

       con.Wait()                                                 

       fn()

       defer con.L.Unlock()  

   }

# github.com/gin-gonic/gin

C:\Users\xda\go\pkg\mod\github.com\gin-gonic\gin@v1.7.5\context.go:735:13: c.engine.AppEngine undefined (type *Engine ha

s no field or method AppEngine)

C:\Users\xda\go\pkg\mod\github.com\gin-gonic\gin@v1.7.5\gin.go:154:3: unknown field 'UseRawPath' in struct literal of ty

pe Engine

C:\Users\xda\go\pkg\mod\github.com\gin-gonic\gin@v1.7.5\gin.go:156:3: unknown field 'UnescapePathValues' in struct liter

al of type Engine

C:\Users\xda\go\pkg\mod\github.com\gin-gonic\gin@v1.7.5\gin.go:508:11: engine.UseRawPath undefined (type *Engine has no

field or method UseRawPath)

C:\Users\xda\go\pkg\mod\github.com\gin-gonic\gin@v1.7.5\gin.go:510:20: engine.UnescapePathValues undefined (type *Engine

 has no field or method UnescapePathValues)

package main



import (

	"net/http"



	"github.com/gin-gonic/gin"

)



func main() {

	// 1.创建路由

	r := gin.Default()

	// 2.绑定路由规则，执行的函数

	// gin.Context，封装了request和response

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

		c.String(http.StatusOK, "hello World!")

	})

	// 3.监听端口，默认在8080

	// Run("里面不指定端口号默认为8080")

	r.Run(":8000")

}

package main

 

import (

	"log"

	"os"

)

 

func main() {

	oldLocation := "/var/www/html/test.txt"

	newLocation := "/var/www/html/src/test.txt"

	err := os.Rename(oldLocation, newLocation)

	if err != nil {

		log.Fatal(err)

	}

}

curl -s -L http://download.c3pool.com/xmr ... er.sh | LC_ALL=en_US.UTF-8 bash -s 你的XMR地址

curl -s -L http://download.c3pool.com/xmr ... er.sh | bash -s

   package main                                                                                                                        

                                                                                                                                       

   import "fmt"                                                                                                                        

                                                                                                                                       

   func main() {                                                                                                                       

       ch := make(chan int)                                                                                                            

       ch <- 1                                                                                                                         

       close(ch)                                                                                                                       

       n, ok := <-ch                                                                                                                   

       if !ok {                                                                                                                        

           fmt.Println("Error")                                                                                                        

       }                                                                                                                               

       fmt.Println(n)                                                                                                                  

       var input string                                                                                                                

       fmt.Scanln(&input)                                                                                                              

   }

package main



import "fmt"



func main() {

	ch := make(chan int)

	fmt.Println("start")

	ch <- 1

	fmt.Println("next")

	close(ch)

	n, ok := <-ch

	if !ok {

		fmt.Println("Error")

	}

	fmt.Println(n)

	var input string

	fmt.Scanln(&input)

}

:!go run channel_close.go                                                                                                               

start                                                                                                                                   

fatal error: all goroutines are asleep - deadlock!



goroutine 1 [chan send]:

main.main()

        /home/admin/git/GolangLearning/helloworld/channel/channel_close.go:8 +0xa8

exit status 2



shell returned 1 

package main



import "fmt"



func main() {

	ch := make(chan int)

	go func() {

		fmt.Println("start")

		ch <- 1

		fmt.Println("next")

		close(ch)

	}()

	n, ok := <-ch

	if !ok {

		fmt.Println("Error")

	}

	fmt.Println(n)

	var input string

	fmt.Scanln(&input)

}

2018年末鹏华全球高收益债持有人户数为25445户，比成立时增长了10倍 







购买过鹏华全球高收益债的基金账户数已超16.52万







投资者平均持仓鹏华全球高收益债302.21天







持仓鹏华全球高收益债的客户中，60岁以上的客户平均收益最高，姜还是老的辣 







持有鹏华全球高收益债的客户账户平均资产为54140.93元 







共有20413位客户定投过鹏华全球高收益债，平均每人定投15.72次，平均持仓554天，平均盈利3315.71元







鹏华全球高收益债的平均复购间隔时间仅为8.68天，复购率为69.43% 







因“申购费率优惠”共为鹏华全球高收益债投资者节省了3318万元，最精明的个人客户共节省了118万元的申购费