python量化交易

python量化交易

python量化分析: 股票涨停后该不该卖, 怕砸板还是怕卖飞 ?

量化交易李魔佛 发表了文章 • 0 个评论 • 877 次浏览 • 2018-06-14 19:34 • 来自相关话题

相信大家都有过这样的经验,某个股票忽然直线拉升打到涨停板,然后就会纠结当天要不要卖掉,如果股票没封住,注定会回落,这样会失去部分的利润。 但是又怕卖了后,封死涨停板,然后当天再也买不回来,然后第二天呢,高开就不想去追,或者去追高使得持有该股的成本变高了。
 
那么触及涨停板的个股我们应该继续持有,还是卖掉,还是卖掉做T接回来呢?
接下来用数据说话。【数据使用通联实验室的数据源】
 
首先获取当前市场上所有股票all_stocks = DataAPI.SecTypeRegionRelGet(secID=u"",ticker=u"",typeID=u"",field=u"",pandas="1")
然后获取每一个股票的日k线数据,可以设定一个时间段,我抓取了2012年到今天(2018-06-14)的所有数据,如果是次新股,那么数据就是上市当天到今天的数据。
抓取到的数据包含以下的字段:




点击查看大图 

但是实际用到的字段只有几个, 开盘价,最高价,涨幅,昨天收盘价。
这里我排除了一字板开盘的个股,因为里面含有新股,会导致数据不精确,【后续我会统计,一字板开盘盘中被砸开的概率】,而且数据也排除了ST的个股,因为本人从来不买ST股,所以不会对ST进行统计。fbl =

for code in all_stocks['secID']:
df = DataAPI.MktEqudGet(secID=code,ticker=u"",tradeDate=u"",beginDate=u"20120101",endDate=u"",isOpen="",field=u"",pandas="1")
df['ztj']=map(lambda x:round(x,2),df['preClosePrice']*1.1)
df['chgPct']=df['chgPct']*100

# 非一字板
zt = df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])]
fz= df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])&(df['closePrice']==df['highestPrice'])]
try:
f = len(fz)*1.00/len(zt)*100
fbl.append((code,f))
except Exception,e:
print e
print code
fbl就是封板率的一个列表,包含了每只股票的触及涨停价后封板的概率。 然后对整体的数据取平均值:dx= dict(fbl)
x = np.array(dx.values())
print x.mean()
最后得到的结果是:
64.0866513726

所以保持住涨停的概率还是大一些。所以站在概率大的一边上,触及涨停的时候应该继续持有,会有62.5%会到收盘保持涨停价。
 
(待续)
 
原创文章,转载请注明出处: 
http://30daydo.com/article/331 
  查看全部
相信大家都有过这样的经验,某个股票忽然直线拉升打到涨停板,然后就会纠结当天要不要卖掉,如果股票没封住,注定会回落,这样会失去部分的利润。 但是又怕卖了后,封死涨停板,然后当天再也买不回来,然后第二天呢,高开就不想去追,或者去追高使得持有该股的成本变高了。
 
那么触及涨停板的个股我们应该继续持有,还是卖掉,还是卖掉做T接回来呢?
接下来用数据说话。【数据使用通联实验室的数据源】
 
首先获取当前市场上所有股票
all_stocks = DataAPI.SecTypeRegionRelGet(secID=u"",ticker=u"",typeID=u"",field=u"",pandas="1")

然后获取每一个股票的日k线数据,可以设定一个时间段,我抓取了2012年到今天(2018-06-14)的所有数据,如果是次新股,那么数据就是上市当天到今天的数据。
抓取到的数据包含以下的字段:
cd11.PNG

点击查看大图 

但是实际用到的字段只有几个, 开盘价,最高价,涨幅,昨天收盘价。
这里我排除了一字板开盘的个股,因为里面含有新股,会导致数据不精确,【后续我会统计,一字板开盘盘中被砸开的概率】,而且数据也排除了ST的个股,因为本人从来不买ST股,所以不会对ST进行统计。
fbl = 

for code in all_stocks['secID']:
df = DataAPI.MktEqudGet(secID=code,ticker=u"",tradeDate=u"",beginDate=u"20120101",endDate=u"",isOpen="",field=u"",pandas="1")
df['ztj']=map(lambda x:round(x,2),df['preClosePrice']*1.1)
df['chgPct']=df['chgPct']*100

# 非一字板
zt = df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])]
fz= df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])&(df['closePrice']==df['highestPrice'])]
try:
f = len(fz)*1.00/len(zt)*100
fbl.append((code,f))
except Exception,e:
print e
print code

fbl就是封板率的一个列表,包含了每只股票的触及涨停价后封板的概率。 然后对整体的数据取平均值:
dx= dict(fbl)
x = np.array(dx.values())
print x.mean()

最后得到的结果是:
64.0866513726

所以保持住涨停的概率还是大一些。所以站在概率大的一边上,触及涨停的时候应该继续持有,会有62.5%会到收盘保持涨停价。
 
(待续)
 
原创文章,转载请注明出处: 
http://30daydo.com/article/331 
 

求港股数据获取PYTHON代码

股票李魔佛 回复了问题 • 3 人关注 • 1 个回复 • 1519 次浏览 • 2018-06-07 16:09 • 来自相关话题

python获取每天的涨停个股数据 和昨天涨停的今天表现

量化交易李魔佛 发表了文章 • 2 个评论 • 1466 次浏览 • 2018-06-02 10:47 • 来自相关话题

python获取每天的涨停个股数据 和昨天涨停的今天表现
 




今日的涨停信息





昨日涨停的今天信息
 
原创文章
转载请注明出处:http://30daydo.com/article/316
  查看全部
python获取每天的涨停个股数据 和昨天涨停的今天表现
 
ztb2_副本_副本_副本.jpg

今日的涨停信息

zrzt1_副本.jpg

昨日涨停的今天信息
 
原创文章
转载请注明出处:http://30daydo.com/article/316
 

正常退出tushare

量化交易李魔佛 发表了文章 • 1 个评论 • 696 次浏览 • 2018-05-07 21:31 • 来自相关话题

tushare最新的api中,很多函数的调用像这样,ts.bar(code,conn=conn), 其中conn=ts.get_api()
查看源码知道ts.get_api() 里面使用了多线程,程序一直在循环等待。 如果按ctrl + c,是无法正常终止tushare在后台的调用,需要使用ts.close_api(conn), 才能终止掉后台的多线程,这个时候程序才能正常退出,释放系统资源。
原创文章
转载请注明出处:http://30daydo.com/article/308
  查看全部
tushare最新的api中,很多函数的调用像这样,ts.bar(code,conn=conn), 其中conn=ts.get_api()
查看源码知道ts.get_api() 里面使用了多线程,程序一直在循环等待。 如果按ctrl + c,是无法正常终止tushare在后台的调用,需要使用ts.close_api(conn), 才能终止掉后台的多线程,这个时候程序才能正常退出,释放系统资源。
原创文章
转载请注明出处:http://30daydo.com/article/308
 

使用优矿获取股市的基本数据 实例操作

量化交易李魔佛 发表了文章 • 1 个评论 • 532 次浏览 • 2018-05-06 22:44 • 来自相关话题

1. 每日行业个股换手率排名
DataAPI.MktRANKInstTrGet

 行业名称,如:传媒,电气设备等,可多值输入,以下为申万28个行业名称:休闲服务,房地产,商业贸易,综合,钢铁,农林牧渔,食品饮料,采掘,电子,国防军工,通信,公用事业,交通运输,轻工制造,计算机,电气设备,家用电器,医药生物,传媒,非银金融,汽车,有色金属,机械设备,建筑材料,化工,纺织服装,银行,建筑装饰,可以是列表,可空
 
实例
 
原创文章
转载请注明出处:http://30daydo.com/article/306
  查看全部
1. 每日行业个股换手率排名
DataAPI.MktRANKInstTrGet

 行业名称,如:传媒,电气设备等,可多值输入,以下为申万28个行业名称:休闲服务,房地产,商业贸易,综合,钢铁,农林牧渔,食品饮料,采掘,电子,国防军工,通信,公用事业,交通运输,轻工制造,计算机,电气设备,家用电器,医药生物,传媒,非银金融,汽车,有色金属,机械设备,建筑材料,化工,纺织服装,银行,建筑装饰,可以是列表,可空
 
实例
 
原创文章
转载请注明出处:http://30daydo.com/article/306
 

为什么使用talib查找K线形态和优矿上查到的不一样?

回复

股票李魔佛 发起了问题 • 1 人关注 • 0 个回复 • 605 次浏览 • 2018-04-09 18:09 • 来自相关话题

原来这样的历史日线数据也可以拿来卖的呀

股票李魔佛 发表了文章 • 3 个评论 • 699 次浏览 • 2018-04-08 22:58 • 来自相关话题

  
原来这样的数据都可以拿去卖的。 确切的体验到知识就是金钱哈。

Screenshot_from_2018-04-08_22-47-21_thunbnail.png

  
原来这样的数据都可以拿去卖的。 确切的体验到知识就是金钱哈。

pandas中resample的how参数“ohlc”

量化交易李魔佛 发表了文章 • 2 个评论 • 1796 次浏览 • 2018-03-25 23:42 • 来自相关话题

这个ohlc对应的是股市中的open,high,low,close这几个价格。专门用于股票市场的分析。
比如我获取得到了一个股票从14年到现在的开盘,收盘,最高,最低等价格,然后我想对数据中的收盘价重新采样,转换成月数据。可以使用resample函数,参数中的how配合 ohlc。
 
获取原始数据:





 
提取收盘价





 
 
重新采样:





 
重新采样后获得的新数据:





 
可以看到现在的index是每个月的结束,而多了几列,close,open,high,low,这4列就是根据每个月的close价格而提取出来的,比如统计一月份的时候,一月份的收盘价会有一个最低和最高,最开始open1月1号和结束close的1月31号的价格。
 
 
原创文章
转载请注明出处:http://30daydo.com/article/288
  查看全部
这个ohlc对应的是股市中的open,high,low,close这几个价格。专门用于股票市场的分析。
比如我获取得到了一个股票从14年到现在的开盘,收盘,最高,最低等价格,然后我想对数据中的收盘价重新采样,转换成月数据。可以使用resample函数,参数中的how配合 ohlc。
 
获取原始数据:

Screenshot_from_2018-03-25_23-28-30.png

 
提取收盘价

Screenshot_from_2018-03-25_23-34-21.png

 
 
重新采样:

Screenshot_from_2018-03-25_23-34-55.png

 
重新采样后获得的新数据:

Screenshot_from_2018-03-25_23-35-25.png

 
可以看到现在的index是每个月的结束,而多了几列,close,open,high,low,这4列就是根据每个月的close价格而提取出来的,比如统计一月份的时候,一月份的收盘价会有一个最低和最高,最开始open1月1号和结束close的1月31号的价格。
 
 
原创文章
转载请注明出处:http://30daydo.com/article/288
 

可转债套利【一】 python找出折价可转债个股

量化交易李魔佛 发表了文章 • 2 个评论 • 3282 次浏览 • 2018-03-16 17:17 • 来自相关话题

关于可转债的定义,可以到https://xueqiu.com/6832369826/103042836 这里科普一下。
 
下面的内容默认你对可转债已经有一定的了解。
 
可转债的价值=正股价格/转股价格 + 利息,忽略可转债的利息,直接用公式 可转债的价值=正股价格/转股价格 计算可转债的价值。
 
如果当前可转债的交易价格(在交易软件上显示的价格)如:




所以万信转债的价格是121.5元,然后万信转债的价值呢? 按照上面的公式,万信转债的正股是万达信息,今天万达信息  (2018-03-16)的股价是





以收盘价为例,17.25。
 
而万信转债的股转价格呢? 这个可以到万信转债F10页面的公告中找到,为13.11元。 所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100, 所以万信转债的内在价值是1.315*100=131.5, 而当前的交易价格为 121.5





 
 
也就是你用121.5元买到一个价值 131.5的商品, 所以相当于打折买到了一个超值的商品,所以当前的万信转债是折价状态。
 
所以本次任务就是要找出可交易的可转债中折价状态的可转债。
 
然后直接上干货。上python代码。#-*-coding=utf-8
'''
可转债监控
'''
import tushare as ts
from setting import get_engine
engine = get_engine('db_bond')
import pandas as pd
import datetime
class ConvertBond():

def __init__(self):
self.conn=ts.get_apis()
self.allBonds=ts.new_cbonds(pause=2)
self.onSellBond=self.allBonds.dropna(subset=['marketprice'])
self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')

def stockPrice(self,code):
stock_df = ts.get_realtime_quotes(code)
price = float(stock_df['price'].values[0])
return price

def dataframe(self):
price_list=[]
for code in self.onSellBond['scode']:
price_list.append(self.stockPrice(code))
self.onSellBond['stock_price']=price_list
self.onSellBond['ratio'] = (
self.onSellBond['marketprice']
/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100
self.onSellBond['Updated']=self.today
self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')

def closed(self):
ts.close_apis(self.conn)

def main():
bond=ConvertBond()
bond.dataframe()
bond.closed()
if __name__=='__main__':
main()







 上面的setting库,把下面的*** 替换成你自己的Mysql用户和密码即可。import os
import MySQLdb
MYSQL_USER = *********
MYSQL_PASSWORD = ********
MYSQL_HOST = *********
MYSQL_PORT = *****

def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine 
上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示:







点击放大
  2018-03-16 可转债表格
 
其中折价率是ratio列。按照ratio列进行排列,只有2个是正,也就是当前市场是只有2只可转债是处于折价状态的,其余的都是溢价状态(价格比内在价值要贵,忽略利息的前提下,如果把4~5%的利息也算进去的话,-3~4%的折价率其实也算小折价吧)
 
目前万信转债折价10个点,宝信转债折价5.8个点。 所以适合低风险投资者建仓。 因为可转债有兜底价格,所以出现亏损的概率很低(除非遇到黑天鹅,公司破产了,像遇到乐视这种PPT独角兽公司,欠债不还的。 但是A股上能够有资格发行可转债的,本身对公司的盈利,分红都有硬性要求)。
 
所以可以保存上面的代码,可以每天运行一次,可以很方便地找出折价的个股,当然也可以在盘中一直监测,因为可转债的价格是实时变化的,一旦遇到大跌,跌到折价状态,你也可以择时入手标的。

原文链接:
http://30daydo.com/article/286
转载请注明出处 查看全部
关于可转债的定义,可以到https://xueqiu.com/6832369826/103042836 这里科普一下。
 
下面的内容默认你对可转债已经有一定的了解。
 
可转债的价值=正股价格/转股价格 + 利息,忽略可转债的利息,直接用公式 可转债的价值=正股价格/转股价格 计算可转债的价值。
 
如果当前可转债的交易价格(在交易软件上显示的价格)如:
wxzz.GIF

所以万信转债的价格是121.5元,然后万信转债的价值呢? 按照上面的公式,万信转债的正股是万达信息,今天万达信息  (2018-03-16)的股价是

万达信息.GIF

以收盘价为例,17.25。
 
而万信转债的股转价格呢? 这个可以到万信转债F10页面的公告中找到,为13.11元。 所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100, 所以万信转债的内在价值是1.315*100=131.5, 而当前的交易价格为 121.5

wxzz.GIF

 
 
也就是你用121.5元买到一个价值 131.5的商品, 所以相当于打折买到了一个超值的商品,所以当前的万信转债是折价状态。
 
所以本次任务就是要找出可交易的可转债中折价状态的可转债。
 
然后直接上干货。上python代码。
#-*-coding=utf-8
'''
可转债监控
'''
import tushare as ts
from setting import get_engine
engine = get_engine('db_bond')
import pandas as pd
import datetime
class ConvertBond():

def __init__(self):
self.conn=ts.get_apis()
self.allBonds=ts.new_cbonds(pause=2)
self.onSellBond=self.allBonds.dropna(subset=['marketprice'])
self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')

def stockPrice(self,code):
stock_df = ts.get_realtime_quotes(code)
price = float(stock_df['price'].values[0])
return price

def dataframe(self):
price_list=[]
for code in self.onSellBond['scode']:
price_list.append(self.stockPrice(code))
self.onSellBond['stock_price']=price_list
self.onSellBond['ratio'] = (
self.onSellBond['marketprice']
/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100
self.onSellBond['Updated']=self.today
self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')

def closed(self):
ts.close_apis(self.conn)

def main():
bond=ConvertBond()
bond.dataframe()
bond.closed()
if __name__=='__main__':
main()







 上面的setting库,把下面的*** 替换成你自己的Mysql用户和密码即可。
import os
import MySQLdb
MYSQL_USER = *********
MYSQL_PASSWORD = ********
MYSQL_HOST = *********
MYSQL_PORT = *****

def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine
 
上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示:


Screenshot_from_2018-03-28_09-14-35.png


点击放大
  2018-03-16 可转债表格
 
其中折价率是ratio列。按照ratio列进行排列,只有2个是正,也就是当前市场是只有2只可转债是处于折价状态的,其余的都是溢价状态(价格比内在价值要贵,忽略利息的前提下,如果把4~5%的利息也算进去的话,-3~4%的折价率其实也算小折价吧)
 
目前万信转债折价10个点,宝信转债折价5.8个点。 所以适合低风险投资者建仓。 因为可转债有兜底价格,所以出现亏损的概率很低(除非遇到黑天鹅,公司破产了,像遇到乐视这种PPT独角兽公司,欠债不还的。 但是A股上能够有资格发行可转债的,本身对公司的盈利,分红都有硬性要求)。
 
所以可以保存上面的代码,可以每天运行一次,可以很方便地找出折价的个股,当然也可以在盘中一直监测,因为可转债的价格是实时变化的,一旦遇到大跌,跌到折价状态,你也可以择时入手标的。

原文链接:
http://30daydo.com/article/286
转载请注明出处

tushare 调用ts.get_apis() 后一直在运行无法退出

量化交易李魔佛 发表了文章 • 0 个评论 • 804 次浏览 • 2018-03-16 00:47 • 来自相关话题

旧版本中运行ts.get_apis()后会一直在后台监听,但是在1.0.5的后续版本中,你可以手工中断这个后台监听,从而让你的程序可以正常退出。
 
conn=ts.get_apis()
......
 
在你的程序退出前,运行
ts.close_apis(conn)
 
这样你的程序就能够正常退出。 查看全部
旧版本中运行ts.get_apis()后会一直在后台监听,但是在1.0.5的后续版本中,你可以手工中断这个后台监听,从而让你的程序可以正常退出。
 
conn=ts.get_apis()
......
 
在你的程序退出前,运行
ts.close_apis(conn)
 
这样你的程序就能够正常退出。

python监测股票出现的规律大单

股票李魔佛 发表了文章 • 2 个评论 • 1162 次浏览 • 2018-02-27 12:03 • 来自相关话题

日期:2018-02-27 11:30
 
首先获取当日的历史分笔数据
code='300527'
df = ts.get_today_ticks(code)
 然后根据成交量进行排序:
df.sort_values(by='volume',ascending=False).head(100)显示前100的成交量。




 
 
从上面的表格可以看到,不断有1500手的卖盘,而且卖出价格比正常的药低3个点,所谓的砸盘。
但是每次砸完了价格又会正常的回来原来的地方。 从分时走势上也可以看到一个个凸起的大单成交量。





 
每次打压完,股价还会正常回到原来的位置。 个人觉得这个是有人在出货,但是不断有人在接货。是不同的两伙人。  查看全部
日期:2018-02-27 11:30
 
首先获取当日的历史分笔数据
code='300527'
df = ts.get_today_ticks(code)

 然后根据成交量进行排序:
df.sort_values(by='volume',ascending=False).head(100)
显示前100的成交量。
华舟应急.GIF

 
 
从上面的表格可以看到,不断有1500手的卖盘,而且卖出价格比正常的药低3个点,所谓的砸盘。
但是每次砸完了价格又会正常的回来原来的地方。 从分时走势上也可以看到一个个凸起的大单成交量。

华舟应急分时.GIF

 
每次打压完,股价还会正常回到原来的位置。 个人觉得这个是有人在出货,但是不断有人在接货。是不同的两伙人。 

python获取股权质押数据

股票李魔佛 发表了文章 • 2 个评论 • 704 次浏览 • 2018-02-09 15:58 • 来自相关话题

<占位,今晚回来更新>
<占位,今晚回来更新>

【量化选股】A股上有哪些东北股(排雷)?

量化交易李魔佛 发表了文章 • 0 个评论 • 738 次浏览 • 2018-01-31 01:09 • 来自相关话题

上一篇文章中写道,东北企业由于本地特色,会存在一定的造假风险,所以需要在选股的时候排除东北的A股上市企业。
 
打开jupyter notebook。然后输入下面的代码:





 
上面可以获得A股上市公司所有区域的分布。果然刘士余上台后,浙江地区的企业一下子超越广东,成为A股最多公司的省份(当然,这里的广东是把深圳给单独分离出去了),浙江有418个上市公司。
 
然后根据条件筛选列area,选出辽宁,吉林,黑龙江的企业。





共有152家上市公司。截止2018-01-30日。
列表太长没有显示完整,贴在附件里面供大家参考(排雷)。
 
原文地址:http://30daydo.com/article/271
转载请注明出处 查看全部
上一篇文章中写道,东北企业由于本地特色,会存在一定的造假风险,所以需要在选股的时候排除东北的A股上市企业。
 
打开jupyter notebook。然后输入下面的代码:

area.GIF

 
上面可以获得A股上市公司所有区域的分布。果然刘士余上台后,浙江地区的企业一下子超越广东,成为A股最多公司的省份(当然,这里的广东是把深圳给单独分离出去了),浙江有418个上市公司。
 
然后根据条件筛选列area,选出辽宁,吉林,黑龙江的企业。

area1.GIF

共有152家上市公司。截止2018-01-30日。
列表太长没有显示完整,贴在附件里面供大家参考(排雷)。
 
原文地址:http://30daydo.com/article/271
转载请注明出处

【量化分析】到底谁在买乐视网?2018年1月26日

股票李魔佛 发表了文章 • 2 个评论 • 937 次浏览 • 2018-01-26 17:02 • 来自相关话题

这是乐视复牌的第三天,连续3个跌停。





 
本来没有持有这一只股票,不过雪球上不时地出现一些文章,根据龙虎榜推测到底谁在接盘。 于是今天收盘,打开jupyter notebook来简单地分析一下。 大家也可以跟着学习一些分析的思路。因为今天的龙虎榜还没出来,等待会龙虎榜出来了可以再比较一下。
 
首先导入今天的分时数据





 
volume列就是我们感兴趣的成交量。单位是手(100股)
 
先计算一下今天的总成交量:






1021800股,额,比不少中小创的小股的成交量还大呢,瘦死的骆驼比马大。
 
去对比一下雪球或者东财的数据,看看数据是否准确。






 
嗯,1.02万手,数据一致。
 
接着我们来看看排序,按照成交量的大小排序,可以看到最大和最小的差别:





 
大单都集中在开盘和收盘阶段(其实开盘和收盘严格来说不算大单,因为同一时刻太多人一起买,所以掺杂在一起,如果把收盘和开盘的数据拿掉,其实真的没多少大单。。。)
 




 
然后剩下的都是些零零散散的1手的成交:

可以统计一下每个单数出现的频率:





 
出现最多的是1手,2手。这个很正常,如果出现较多的是超过100手的大单,那么也说明跌停很快被打开(后续如果有打算冒风险去撸一把乐视翘班的,可以自己写一个检测程序)
 
接着做一些统计:
定义大于100手的为大单。
然后计算100手大单占成交的比例:





 
嗯,有28%的比例呢。
 
然后计算一下小于10手的占成交比例。





有30%的比例。
 
再统计一下中位数和各分位数:





 
中位数是3,说明整个交易中,一半的成交是在等于或小于3手的,而分位数看到,1手的可以排到25%的位置,而8手则排到了75%的位置。
 
结论:
其实在买的都是小散,不知道是乐粉还是赌徒了。
原文地址:
http://30daydo.com/article/267
源码:https://github.com/Rockyzsu/stock/blob/master/levt_notebook.ipynb
  查看全部
这是乐视复牌的第三天,连续3个跌停。

letv.png

 
本来没有持有这一只股票,不过雪球上不时地出现一些文章,根据龙虎榜推测到底谁在接盘。 于是今天收盘,打开jupyter notebook来简单地分析一下。 大家也可以跟着学习一些分析的思路。因为今天的龙虎榜还没出来,等待会龙虎榜出来了可以再比较一下。
 
首先导入今天的分时数据

df.png

 
volume列就是我们感兴趣的成交量。单位是手(100股)
 
先计算一下今天的总成交量:

Snap3.png


1021800股,额,比不少中小创的小股的成交量还大呢,瘦死的骆驼比马大。
 
去对比一下雪球或者东财的数据,看看数据是否准确。


Snap4.png

 
嗯,1.02万手,数据一致。
 
接着我们来看看排序,按照成交量的大小排序,可以看到最大和最小的差别:

Snap5.png

 
大单都集中在开盘和收盘阶段(其实开盘和收盘严格来说不算大单,因为同一时刻太多人一起买,所以掺杂在一起,如果把收盘和开盘的数据拿掉,其实真的没多少大单。。。)
 
Snap6.png

 
然后剩下的都是些零零散散的1手的成交:

可以统计一下每个单数出现的频率:

Snap7.png

 
出现最多的是1手,2手。这个很正常,如果出现较多的是超过100手的大单,那么也说明跌停很快被打开(后续如果有打算冒风险去撸一把乐视翘班的,可以自己写一个检测程序)
 
接着做一些统计:
定义大于100手的为大单。
然后计算100手大单占成交的比例:

Snap8.png

 
嗯,有28%的比例呢。
 
然后计算一下小于10手的占成交比例。

Snap9.png

有30%的比例。
 
再统计一下中位数和各分位数:

Snap11.png

 
中位数是3,说明整个交易中,一半的成交是在等于或小于3手的,而分位数看到,1手的可以排到25%的位置,而8手则排到了75%的位置。
 
结论:
其实在买的都是小散,不知道是乐粉还是赌徒了。
原文地址:
http://30daydo.com/article/267
源码:https://github.com/Rockyzsu/stock/blob/master/levt_notebook.ipynb
 

python获取A股上市公司的盈利能力

量化交易李魔佛 发表了文章 • 0 个评论 • 1136 次浏览 • 2018-01-04 16:09 • 来自相关话题

利用tushare库,可以很方便的获取A股上市公司的基本面信息。
比如企业的盈利能力。
 import tushare as ts
#获取2017年第3季度的盈利能力数据
ts.get_profit_data(2017,3)返回的结果:
 
按年度、季度获取盈利能力数据,结果返回的数据属性说明如下:
code,代码 
name,名称 
roe,净资产收益率(%)
 net_profit_ratio,净利率(%) 
gross_profit_rate,毛利率(%) 
net_profits,净利润(百万元)  #这里的官网信息有误,单位应该是百万
esp,每股收益 
business_income,营业收入(百万元) 
bips,每股主营业务收入(元)
 
例如返回如下结果:
 
    code   name    roe  net_profit_ratio  gross_profit_rate  net_profits  \
  000717   韶钢松山  79.22              9.44            14.1042    1750.2624
  600793   宜宾纸业  65.40             13.31             7.9084     100.6484
  600306    商业城  63.19             18.55            17.8601     114.9175
  000526  *ST紫学  61.03              2.78            31.1212      63.6477
  600768   宁波富邦  57.83             14.95             2.7349      88.3171
 
原创,转载请注明:
http://30daydo.com/article/260
  查看全部
利用tushare库,可以很方便的获取A股上市公司的基本面信息。
比如企业的盈利能力。
 
import tushare as ts
#获取2017年第3季度的盈利能力数据
ts.get_profit_data(2017,3)
返回的结果:
 
按年度、季度获取盈利能力数据,结果返回的数据属性说明如下:
code,代码 
name,名称 
roe,净资产收益率(%)
 net_profit_ratio,净利率(%) 
gross_profit_rate,毛利率(%) 
net_profits,净利润(百万元)  #这里的官网信息有误,单位应该是百万
esp,每股收益 
business_income,营业收入(百万元) 
bips,每股主营业务收入(元)
 
例如返回如下结果:
 
    code   name    roe  net_profit_ratio  gross_profit_rate  net_profits  \
  000717   韶钢松山  79.22              9.44            14.1042    1750.2624
  600793   宜宾纸业  65.40             13.31             7.9084     100.6484
  600306    商业城  63.19             18.55            17.8601     114.9175
  000526  *ST紫学  61.03              2.78            31.1212      63.6477
  600768   宁波富邦  57.83             14.95             2.7349      88.3171
 
原创,转载请注明:
http://30daydo.com/article/260
 

python获取股票年涨跌幅排名

量化交易李魔佛 发表了文章 • 4 个评论 • 1679 次浏览 • 2017-12-30 23:11 • 来自相关话题

2017还剩一天就结束了,而A股在昨天已经收官了。 对于大部分投资者来说,这一年能跑赢指数已经很厉害的了,因为指数被权重股拉的失真了,上证指数的分时白线和黄线经常出现张开的大口,白线在上,黄线在下。
 
作为年终回顾,首先看看A股市场2017的总体涨跌幅排名。
 
下面函数是用来获取个股某个时间段的涨跌幅。code是股票代码,start为开始时间段,end为结束时间段。def profit(code,start,end):
try:
df=ts.get_k_data(code,start=start,end=end)
except Exception,e:
print e
return None
try:
p=(df['close'].iloc[-1]-df['close'].iloc[0])/df['close'].iloc[0]*100.00
except Exception,e:
print e
return None
return round(p,2)
如果要获取华大基因的2017年涨幅,可以使用profit('300678','2016-12-31','2017-12-31')
需要注意的是,需要添加一个except的异常处理,因为部分个股停牌时间超过一年,所以该股的收盘价都是空的,这种情况就返回一个None值,在dataframe里就是NaN。
 
剩下了的就是枚举所有A股的个股代码了,然后把遍历所有代码,调用profit函数即可。def price_change():
basic=ts.get_stock_basics()
pro=

for code in basic.index.values:
print code
p=profit(code,'2016-12-31','2017-12-31')
pro.append(p)
basic['price_change']=pro
basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')
结果保存到2017_all_price_change.xls中,里面有个股的基本信息,还追加了一列2017年的涨跌幅,price_change
 
最后我们把price_change按照从高到低进行排序。 看看哪些个股排名靠前。def analysis():
df=pd.read_excel('2017_all_price_change.xls',encoding='gbk')
df=df.sort_values(by='price_change',ascending=False)
df.to_excel('2017-year.xls',encoding='gbk')
最终保存的文件为2017-year.xls,当然你也可以保存到mysql的数据库当中。engine=get_engine('stock')
df.to_sql('2017years',engine)

其中get_engine() 函数如下定义:def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine
只需要把你的mysql数据库的用户名密码等变量加上去就可以了。
 
最终的结果如下:






点击查看大图 

附件是导出来的excel格式的数据,你们可以拿去参考。

下一篇我们来学习统计个股的信息,比如哪类股涨得好,哪类股具有相关性,哪类股和大盘走向类似等等。
 
原文链接:http://30daydo.com/article/258
转载请注明出处
 
附件

2017-year.zip


  查看全部
2017还剩一天就结束了,而A股在昨天已经收官了。 对于大部分投资者来说,这一年能跑赢指数已经很厉害的了,因为指数被权重股拉的失真了,上证指数的分时白线和黄线经常出现张开的大口,白线在上,黄线在下。
 
作为年终回顾,首先看看A股市场2017的总体涨跌幅排名。
 
下面函数是用来获取个股某个时间段的涨跌幅。code是股票代码,start为开始时间段,end为结束时间段。
def profit(code,start,end):
try:
df=ts.get_k_data(code,start=start,end=end)
except Exception,e:
print e
return None
try:
p=(df['close'].iloc[-1]-df['close'].iloc[0])/df['close'].iloc[0]*100.00
except Exception,e:
print e
return None
return round(p,2)

如果要获取华大基因的2017年涨幅,可以使用
profit('300678','2016-12-31','2017-12-31')

需要注意的是,需要添加一个except的异常处理,因为部分个股停牌时间超过一年,所以该股的收盘价都是空的,这种情况就返回一个None值,在dataframe里就是NaN。
 
剩下了的就是枚举所有A股的个股代码了,然后把遍历所有代码,调用profit函数即可。
def price_change():
basic=ts.get_stock_basics()
pro=

for code in basic.index.values:
print code
p=profit(code,'2016-12-31','2017-12-31')
pro.append(p)
basic['price_change']=pro
basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')

结果保存到2017_all_price_change.xls中,里面有个股的基本信息,还追加了一列2017年的涨跌幅,price_change
 
最后我们把price_change按照从高到低进行排序。 看看哪些个股排名靠前。
def analysis():
df=pd.read_excel('2017_all_price_change.xls',encoding='gbk')
df=df.sort_values(by='price_change',ascending=False)
df.to_excel('2017-year.xls',encoding='gbk')

最终保存的文件为2017-year.xls,当然你也可以保存到mysql的数据库当中。
engine=get_engine('stock')
df.to_sql('2017years',engine)

其中get_engine() 函数如下定义:
def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine

只需要把你的mysql数据库的用户名密码等变量加上去就可以了。
 
最终的结果如下:


2017-stock_副本.png

点击查看大图 

附件是导出来的excel格式的数据,你们可以拿去参考。

下一篇我们来学习统计个股的信息,比如哪类股涨得好,哪类股具有相关性,哪类股和大盘走向类似等等。
 
原文链接:http://30daydo.com/article/258
转载请注明出处
 
附件

 

dataframe reindex和reset_index区别

量化交易李魔佛 发表了文章 • 0 个评论 • 5511 次浏览 • 2017-12-30 15:58 • 来自相关话题

reset_index的作用是重新设置dataframe的index,范围为0~len(df)。 df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2

df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result 
上面代码把df和df2合并为一个result,但是result的index是乱的。





 
那么执行result2= result.reset_index()
得到如下的result2: (默认只是返回一个copy,原来的result没有发生改变,所以需要副本赋值给result2)





可以看到,原来的一列index现在变成了columns之一,新的index为[0,1,2,3,4,5]
如果添加参数 reset_index(drop=True) 那么原index会被丢弃,不会显示为一个新列。result2 = result.reset_index(drop=True)



 
reindex的作用是按照原有的列进行重新生成一个新的df。
 
还是使用上面的代码
result目前是df和df2的合并序列。
如下:




 
可以看到index为[0,1,2,3,4,0]
执行 
result3 = result.reindex(columns=['A','C'])




 
可以看到,原index并没有发生改变,而类变成了A和C,因为C是不存在的,所以使用了NaB填充,这个值的内容可以自己填充,可以改为默认填充0或者任意你想要的数据。

原文链接:http://30daydo.com/article/257 
欢迎转载,注明出处
  查看全部
reset_index的作用是重新设置dataframe的index,范围为0~len(df)。
    df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2

df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result
 
上面代码把df和df2合并为一个result,但是result的index是乱的。

df4.PNG

 
那么执行
result2= result.reset_index()

得到如下的result2: (默认只是返回一个copy,原来的result没有发生改变,所以需要副本赋值给result2)

df5.PNG

可以看到,原来的一列index现在变成了columns之一,新的index为[0,1,2,3,4,5]
如果添加参数 reset_index(drop=True) 那么原index会被丢弃,不会显示为一个新列。
result2 = result.reset_index(drop=True)
df6.PNG

 
reindex的作用是按照原有的列进行重新生成一个新的df。
 
还是使用上面的代码
result目前是df和df2的合并序列。
如下:
df7.PNG

 
可以看到index为[0,1,2,3,4,0]
执行 
result3 = result.reindex(columns=['A','C'])

df8.PNG

 
可以看到,原index并没有发生改变,而类变成了A和C,因为C是不存在的,所以使用了NaB填充,这个值的内容可以自己填充,可以改为默认填充0或者任意你想要的数据。

原文链接:http://30daydo.com/article/257 
欢迎转载,注明出处
 

dataframe的index索引是否可以重复

量化交易李魔佛 发表了文章 • 0 个评论 • 1512 次浏览 • 2017-12-30 15:10 • 来自相关话题

答案是肯定的。
  df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2输出如下:
df1





df2




 
然后进行合并: df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result
合并后的结果:





 
合并后的index是[0,1,2,3,4,0] 所以index集合是一个类似list的结构,而非set结构,允许重复数据的存在。
 
原文链接:http://30daydo.com/article/256 
转载请注明
 
  查看全部
答案是肯定的。
 
    df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2
输出如下:
df1
df.PNG


df2
df2.PNG

 
然后进行合并:
    df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result

合并后的结果:

dfx.PNG

 
合并后的index是[0,1,2,3,4,0] 所以index集合是一个类似list的结构,而非set结构,允许重复数据的存在。
 
原文链接:http://30daydo.com/article/256 
转载请注明
 
 

tushare使用get_stock_basic()保存为excel会因为乱码出错而无法保存

量化交易李魔佛 发表了文章 • 0 个评论 • 932 次浏览 • 2017-12-30 13:11 • 来自相关话题

代码如下:
basic=ts.get_stock_basics()

print basic.info()
print basic.head(10)

basic.to_excel('basic2017.xls',encoding='gbk')
运行后会出错:

'ascii' codec can't decode byte 0xe4 in position 0: ordinal not in range(128)
 
很明显的是编问题。 
 
然后尝试使用解决编码的步骤。
1. reload(sys) 设置default为utf-8: 失败
2. to_excel('stock.xls',encoding='gbk') : 失败,encoding参数换了几个都是失败,utf-8,gb2312,cp1252
 
最后解决的办法是,先把df保存为csv,然后再从csv从读取出来,然后再存储为excel。 整个过程的encoding参数都是用'gbk'.
basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')
  查看全部
代码如下:
    basic=ts.get_stock_basics()

print basic.info()
print basic.head(10)

basic.to_excel('basic2017.xls',encoding='gbk')

运行后会出错:

'ascii' codec can't decode byte 0xe4 in position 0: ordinal not in range(128)
 
很明显的是编问题。 
 
然后尝试使用解决编码的步骤。
1. reload(sys) 设置default为utf-8: 失败
2. to_excel('stock.xls',encoding='gbk') : 失败,encoding参数换了几个都是失败,utf-8,gb2312,cp1252
 
最后解决的办法是,先把df保存为csv,然后再从csv从读取出来,然后再存储为excel。 整个过程的encoding参数都是用'gbk'.
    basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')

 

数字货币量化揭秘-简单暴力但高效的高频交易机器人

量化交易littleDream 发表了文章 • 1 个评论 • 1295 次浏览 • 2017-12-05 16:23 • 来自相关话题

策略分享地址:https://www.botvs.com/strategy/1088

这个策略是我做虚拟货币以来的主要策略,后面经过不断完善和修改,复杂了很多,但主要思想并没有改变,分享的这个版本是无明显bug的 最初版本,最为简单清晰,没有仓位管理,每次交易都是满仓,没有卡死后重启等等,但也足够说明问题。

 策略从2014年8月运行,直到今年年初交易所收手续费。期间运行的还算很好,亏损的时间很少。资金从最初的200元跑到了80比特币。具体的过程可以看[小草的新浪博客](小草_新浪博客)里[虚拟货币自动化交易之路](虚拟货币自动化交易之路(五)_小草_新浪博客)系列文章。
 


下图是总资产折合币的曲线:



为什么分享这个策略

1.交易所收取手续费后,几乎杀死了所有的高频策略,我的也不例外。但策略改改也许还能用,大家可以研究一下。

2.好久没有分享东西了,这篇文章早就想写了。

3.和大家共同交流学习。




策略的原理

这个策略原理极为简单,可以理解为准高频的做市策略,各位看了之后可能想打人,这都能赚钱,当时几乎谁都能写出来。我开始也没预料到它能这么有效,可见心中有想法要赶紧付出实践,说不一定有意外之喜。在比特币机器人初兴的2014年,写出赚钱的策略太容易了。

和所有的高频策略一样,本策略也是基于orderbook,下图就是一个典型的比特币交易所的订单分布,



可以看到左侧是买单,显示了不同价格的挂单数量,右侧是卖单。可以想象如果一个人要买入比特币,如果不想挂单等待的话,只能选择吃单,如果他的单子比较多,会使得卖单挂单大量成交,对价格造成冲击,但是这种冲击一般不会一直持续,还有人想吃单卖出,价格在极短时间很可能还会恢复,反过来理解有人要卖币也类似。

以图中的挂单为例,如果要直接买入5个币,那么价格会达到10377,在这时如果有人要直接卖出5个币,价格会达到10348,这个空间就是利润空间.策略会在稍低于10377的价格挂单,如10376.99,同时会以稍高于10348的价格买入,如10348.01,这是如果刚才的情况发生了,显然就会赚到其中的差价。虽然不会每次都如此完美,但在概率的作用下,赚钱的几率实际高得惊人。

以现在策略的参数讲解一下具体操作,这个参数当然无法使用了,仅作一个说明。它会向上寻找累计卖挂单量为8个币的价格,这里是10377,那么此时的卖价就是这个价格减去0.01(减去多少可以是随机的),同理向下寻找累计买挂单为8个币,这里是10348,那么此时的卖价就是10348.01,此时买卖价的差价是10376.99-10348.01=28.98,大于策略预设的差价1.5,就以这两个价格挂单等待成交,如果价差小于1.5,也会找一个价格进行挂单,如盘口价格加减10,等待捡漏(更合适的应该是继续往下找跟多的深度)。




进一步的说明

1. 没有钱或币了怎么办?

这种情况在我的钱较少是十分普遍,大多数时候只挂一边的单子,但不是大问题。其实可以加入币钱平衡的逻辑,但在平衡的过程难免产生损失,毕竟每一次的成交都是概率的垂青,我选择保持单边等待成交,当然这样也浪费了另一边的成交机会。

2. 仓位是如何管理的?

刚开始都是满仓买入卖出,后来根据不同的参数分为不同的组,不会一次完全成交。

3. 没有止损吗?

策略有完整的买卖挂单的逻辑,我认为不需要止损(可以讨论),还有就是概率的垂青,成交就是机会,止损可惜了。

4. 如何调整为赚币的策略?

此时的参数是对称的,即向上8个币的累计卖单,向下8个币的累计买单,稍微不平衡一下,比如向上改为15个币的累计卖单,使得卖币机会更难得,有更大的几率会以更低的价格接回来,这样就会赚币,反过来就赚钱。实际上前期策略如此有效,币和钱都是增加的。




代码讲解

完整的代码可以见我在http://www.botvs.com得策略分享,这里只讲解核心逻辑函数。在没有改动的情况下,在botvs自带的模拟盘竟然运转完全正常,这是一个3年多前的策略,平台还支持到现在,太让人感动了。

首先是获取买卖价函数GetPrice(),需要获取订单深度信息,注意不同平台的订单深度信息长度不同,以及即使遍历了所有订单仍然没有所需要的量的情况(在后期许多0.01的网格挂单会导致这种情况),调用是GetPrice('Buy')就是获取买价。
 
function GetPrice(Type) {
//_C()是平台的容错函数
var depth=_C(exchange.GetDepth);
var amountBids=0;
var amountAsks=0;
//计算买价,获取累计深度达到预设的价格
if(Type=="Buy"){
for(var i=0;i<20;i++){
amountBids+=depth.Bids[i].Amount;
//参数floatamountbuy是预设的累计深度
if (amountBids>floatamountbuy){
//稍微加0.01,使得订单排在前面
return depth.Bids[i].Price+0.01;}
}
}
//同理计算卖价
if(Type=="Sell"){
for(var j=0; j<20; j++){
amountAsks+=depth.Asks[j].Amount;
if (amountAsks>floatamountsell){
return depth.Asks[j].Price-0.01;}
}
}
//遍历了全部深度仍未满足需求,就返回一个价格,以免出现bug
return depth.Asks[0].Price
}

// 每个循环的主函数onTick(),这里定的循环时间3.5s,每次循环都会把原来的单子撤销,重新挂单,越简单越不会遇到bug.

function onTick() {
var buyPrice = GetPrice("Buy");
var sellPrice= GetPrice("Sell");
//diffprice是预设差价,买卖价差如果小于预设差价,就会挂一个相对更深的价格
if ((sellPrice - buyPrice) <= diffprice){
buyPrice-=10;
sellPrice+=10;}
//把原有的单子全部撤销,实际上经常出现新的价格和已挂单价格相同的情况,此时不需要撤销
CancelPendingOrders()
//获取账户信息,确定目前账户存在多少钱和多少币
var account=_C(exchange.GetAccount);
//可买的比特币量,_N()是平台的精度函数
var amountBuy = _N((account.Balance / buyPrice-0.1),2);
//可卖的比特币量,注意到没有仓位的限制,有多少就买卖多少,因为我当时的钱很少
var amountSell = _N((account.Stocks),2);
if (amountSell > 0.02) {
exchange.Sell(sellPrice,amountSell);}
if (amountBuy > 0.02) {
exchange.Buy(buyPrice, amountBuy);}
//休眠,进入下一轮循环
Sleep(sleeptime);
}


尾巴

整个程序也就40多行,看上去十分简单,但当时也花了我一个多星期,这还是在botvs平台上情况下。最大的优势还是起步早,在2014年,市场上以搬砖为主,网格和抢盘口的高频也不多,使得策略如鱼得水,后来竞争不可避免越来越激烈,我的钱也越来越多,面临的挑战很多,每隔一段时间都要进行较大的改动来应对,但总体还算顺利。在交易平台不收取手续费的情况下,是程序化交易的天堂,散户因为不收手续费跟倾向于操作,为高频和套利提供了空间,这一切也基本随着动辄0.1-0.2%的双向手续费终结了,不仅是自己被收费的问题,而是整个市场活跃度下降。

但不需要高频的量化策略任然有很大的空间。

作者 小草 查看全部
策略分享地址:https://www.botvs.com/strategy/1088


这个策略是我做虚拟货币以来的主要策略,后面经过不断完善和修改,复杂了很多,但主要思想并没有改变,分享的这个版本是无明显bug的 最初版本,最为简单清晰,没有仓位管理,每次交易都是满仓,没有卡死后重启等等,但也足够说明问题。


 策略从2014年8月运行,直到今年年初交易所收手续费。期间运行的还算很好,亏损的时间很少。资金从最初的200元跑到了80比特币。具体的过程可以看[小草的新浪博客](小草_新浪博客)里[虚拟货币自动化交易之路](虚拟货币自动化交易之路(五)_小草_新浪博客)系列文章。
 


下图是总资产折合币的曲线:



为什么分享这个策略

1.交易所收取手续费后,几乎杀死了所有的高频策略,我的也不例外。但策略改改也许还能用,大家可以研究一下。

2.好久没有分享东西了,这篇文章早就想写了。

3.和大家共同交流学习。




策略的原理

这个策略原理极为简单,可以理解为准高频的做市策略,各位看了之后可能想打人,这都能赚钱,当时几乎谁都能写出来。我开始也没预料到它能这么有效,可见心中有想法要赶紧付出实践,说不一定有意外之喜。在比特币机器人初兴的2014年,写出赚钱的策略太容易了。

和所有的高频策略一样,本策略也是基于orderbook,下图就是一个典型的比特币交易所的订单分布,



可以看到左侧是买单,显示了不同价格的挂单数量,右侧是卖单。可以想象如果一个人要买入比特币,如果不想挂单等待的话,只能选择吃单,如果他的单子比较多,会使得卖单挂单大量成交,对价格造成冲击,但是这种冲击一般不会一直持续,还有人想吃单卖出,价格在极短时间很可能还会恢复,反过来理解有人要卖币也类似。

以图中的挂单为例,如果要直接买入5个币,那么价格会达到10377,在这时如果有人要直接卖出5个币,价格会达到10348,这个空间就是利润空间.策略会在稍低于10377的价格挂单,如10376.99,同时会以稍高于10348的价格买入,如10348.01,这是如果刚才的情况发生了,显然就会赚到其中的差价。虽然不会每次都如此完美,但在概率的作用下,赚钱的几率实际高得惊人。

以现在策略的参数讲解一下具体操作,这个参数当然无法使用了,仅作一个说明。它会向上寻找累计卖挂单量为8个币的价格,这里是10377,那么此时的卖价就是这个价格减去0.01(减去多少可以是随机的),同理向下寻找累计买挂单为8个币,这里是10348,那么此时的卖价就是10348.01,此时买卖价的差价是10376.99-10348.01=28.98,大于策略预设的差价1.5,就以这两个价格挂单等待成交,如果价差小于1.5,也会找一个价格进行挂单,如盘口价格加减10,等待捡漏(更合适的应该是继续往下找跟多的深度)。




进一步的说明

1. 没有钱或币了怎么办?

这种情况在我的钱较少是十分普遍,大多数时候只挂一边的单子,但不是大问题。其实可以加入币钱平衡的逻辑,但在平衡的过程难免产生损失,毕竟每一次的成交都是概率的垂青,我选择保持单边等待成交,当然这样也浪费了另一边的成交机会。

2. 仓位是如何管理的?

刚开始都是满仓买入卖出,后来根据不同的参数分为不同的组,不会一次完全成交。

3. 没有止损吗?

策略有完整的买卖挂单的逻辑,我认为不需要止损(可以讨论),还有就是概率的垂青,成交就是机会,止损可惜了。

4. 如何调整为赚币的策略?

此时的参数是对称的,即向上8个币的累计卖单,向下8个币的累计买单,稍微不平衡一下,比如向上改为15个币的累计卖单,使得卖币机会更难得,有更大的几率会以更低的价格接回来,这样就会赚币,反过来就赚钱。实际上前期策略如此有效,币和钱都是增加的。




代码讲解

完整的代码可以见我在http://www.botvs.com得策略分享,这里只讲解核心逻辑函数。在没有改动的情况下,在botvs自带的模拟盘竟然运转完全正常,这是一个3年多前的策略,平台还支持到现在,太让人感动了。

首先是获取买卖价函数GetPrice(),需要获取订单深度信息,注意不同平台的订单深度信息长度不同,以及即使遍历了所有订单仍然没有所需要的量的情况(在后期许多0.01的网格挂单会导致这种情况),调用是GetPrice('Buy')就是获取买价。
 
function GetPrice(Type) {
//_C()是平台的容错函数
var depth=_C(exchange.GetDepth);
var amountBids=0;
var amountAsks=0;
//计算买价,获取累计深度达到预设的价格
if(Type=="Buy"){
for(var i=0;i<20;i++){
amountBids+=depth.Bids[i].Amount;
//参数floatamountbuy是预设的累计深度
if (amountBids>floatamountbuy){
//稍微加0.01,使得订单排在前面
return depth.Bids[i].Price+0.01;}
}
}
//同理计算卖价
if(Type=="Sell"){
for(var j=0; j<20; j++){
amountAsks+=depth.Asks[j].Amount;
if (amountAsks>floatamountsell){
return depth.Asks[j].Price-0.01;}
}
}
//遍历了全部深度仍未满足需求,就返回一个价格,以免出现bug
return depth.Asks[0].Price
}

// 每个循环的主函数onTick(),这里定的循环时间3.5s,每次循环都会把原来的单子撤销,重新挂单,越简单越不会遇到bug.

function onTick() {
var buyPrice = GetPrice("Buy");
var sellPrice= GetPrice("Sell");
//diffprice是预设差价,买卖价差如果小于预设差价,就会挂一个相对更深的价格
if ((sellPrice - buyPrice) <= diffprice){
buyPrice-=10;
sellPrice+=10;}
//把原有的单子全部撤销,实际上经常出现新的价格和已挂单价格相同的情况,此时不需要撤销
CancelPendingOrders()
//获取账户信息,确定目前账户存在多少钱和多少币
var account=_C(exchange.GetAccount);
//可买的比特币量,_N()是平台的精度函数
var amountBuy = _N((account.Balance / buyPrice-0.1),2);
//可卖的比特币量,注意到没有仓位的限制,有多少就买卖多少,因为我当时的钱很少
var amountSell = _N((account.Stocks),2);
if (amountSell > 0.02) {
exchange.Sell(sellPrice,amountSell);}
if (amountBuy > 0.02) {
exchange.Buy(buyPrice, amountBuy);}
//休眠,进入下一轮循环
Sleep(sleeptime);
}



尾巴

整个程序也就40多行,看上去十分简单,但当时也花了我一个多星期,这还是在botvs平台上情况下。最大的优势还是起步早,在2014年,市场上以搬砖为主,网格和抢盘口的高频也不多,使得策略如鱼得水,后来竞争不可避免越来越激烈,我的钱也越来越多,面临的挑战很多,每隔一段时间都要进行较大的改动来应对,但总体还算顺利。在交易平台不收取手续费的情况下,是程序化交易的天堂,散户因为不收手续费跟倾向于操作,为高频和套利提供了空间,这一切也基本随着动辄0.1-0.2%的双向手续费终结了,不仅是自己被收费的问题,而是整个市场活跃度下降。

但不需要高频的量化策略任然有很大的空间。

作者 小草

TypeError: reduction operation 'argmin' not allowed for this dtype

量化交易李魔佛 发表了文章 • 0 个评论 • 3002 次浏览 • 2017-11-19 18:48 • 来自相关话题

使用pd.read_sql() 方法把Mysql的数据库转为dataframe后,使用 df['low'].idxmin() 或者df['low'].argmin() 方法是会出现这个错误。
 
date = date + '-01-01'
cmd = 'select * from `{}` where datetime > \'{}\''.format(code, date)

try:
df = pd.read_sql(cmd, history_engine,index_col='index')
except Exception,e:
print e
return None

# 不知道为啥,这里的类型发生改变
idx= df['low'].idxmin() 
 
TypeError: reduction operation 'argmin' not allowed for this dtype
 
把df的每列数据类型打印出来看看。
 
print df.dtypes
 
datetime datetime64[ns]
code object
name object
open object
close object
high object
low object
vol float64
amount float64
dtype: object
晕,居然把low这些float类型全部转为了object,所以解决办法就是把这些列的数据转为float64.
 
df['low']=df['low'].astype('float64')
这样之后,问题就解决了。
  查看全部
使用pd.read_sql() 方法把Mysql的数据库转为dataframe后,使用 df['low'].idxmin() 或者df['low'].argmin() 方法是会出现这个错误。
 
date = date + '-01-01'
cmd = 'select * from `{}` where datetime > \'{}\''.format(code, date)

try:
df = pd.read_sql(cmd, history_engine,index_col='index')
except Exception,e:
print e
return None

# 不知道为啥,这里的类型发生改变
idx= df['low'].idxmin()
 
 
TypeError: reduction operation 'argmin' not allowed for this dtype
 
把df的每列数据类型打印出来看看。
 
print df.dtypes
 
datetime    datetime64[ns]
code object
name object
open object
close object
high object
low object
vol float64
amount float64
dtype: object

晕,居然把low这些float类型全部转为了object,所以解决办法就是把这些列的数据转为float64.
 
df['low']=df['low'].astype('float64')

这样之后,问题就解决了。
 

监控聚币网行情 并实时发送到微信

量化交易李魔佛 发表了文章 • 1 个评论 • 3812 次浏览 • 2017-05-29 17:38 • 来自相关话题

最近由于好友推荐我入坑了国内的山寨币,所以顺便研究了下聚币网的API。 不过网页版的聚币网和手机版的做的不好,而且因为是7x24 小时交易,自己没有那么多的精力盯盘,所以写了python代码进行监控。




# -*-coding=utf-8-*-
__author__ = 'Rocky'
'''
http://30daydo.com
Contact: weigesysu@qq.com
'''
import random
import hashlib
import hmac,time
import smtplib
from email.mime.text import MIMEText
from email import Utils
import threading
import requests,datetime,itchat

from toolkit import Toolkit


class Jubi_web():
def __init__(self, send=None):
cfg = Toolkit.getUserData('data.cfg')
self.public_key = cfg['public_key']
self.private_key = cfg['private_key']
self.send=send
from_mail = cfg['from_mail']
password = cfg['password']
to_mail = cfg['to_mail']
smtp_server = 'smtp.qq.com'

self.server = smtp_server
self.username = from_mail.split("@")[0]
self.from_mail = from_mail
self.password = password
self.to_mail = to_mail
self.coin_list=['IFC','DOGE','EAC','DNC','MET','ZET','SKT','YTC','PLC','LKC',
'JBC','MRYC','GOOC','QEC','PEB','XRP','NXT','WDC','MAX','ZCC',
'HLB','RSS','PGC','RIO','XAS','TFC','BLK','FZ','ANS','XPM','VTC',
'KTC','VRC','XSGS','LSK','PPC','ETC','GAME','LTC','ETH','BTC']
# 初始化邮箱设置读取需要股票信息
# 这样子只登陆一次
if self.send == 'msn':

try:
self.smtp = smtplib.SMTP_SSL(port=465)
self.smtp.connect(self.server)
self.smtp.login(self.username, self.password)
except smtplib.SMTPException, e:
print e
return 0

if send=='wechat':
self.w_name=u'xxxxx'

itchat.auto_login(hotReload=True)
account=itchat.get_friends(self.w_name)


def send_wechat(self,name,content):
w_content=name+' '+content
itchat.send(w_content,toUserName=self.toName)
time.sleep(1)
itchat.send(w_content,toUserName='filehelper')


def send_text(self, name, content):

subject = '%s' % name
self.msg = MIMEText(content, 'plain', 'utf-8')
self.msg['to'] = self.to_mail
self.msg['from'] = self.from_mail
self.msg['Subject'] = subject
self.msg['Date'] = Utils.formatdate(localtime=1)
try:
self.smtp.sendmail(self.msg['from'], self.msg['to'], self.msg.as_string())
self.smtp.quit()
print "sent"
except smtplib.SMTPException, e:
print e
return 0

def warming(self, coin, up_price, down_price):
url = 'https://www.jubi.com/api/v1/ticker/'
while 1:
time.sleep(5)
try:
data = requests.post(url, data={'coin': coin}).json()
except Exception,e:
print e
print "time out. Retry"
time.sleep(15)
continue

current = float(data['last'])
if current >= up_price:
print "Up to ", up_price
print "current price ",current

if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))

time.sleep(1200)
if current <= down_price:
print "Down to ", down_price
print "current price ",current
if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))
time.sleep(1200)
#上面的内容尽量不用修改。


def getContent(self):
url = 'https://www.jubi.com/api/v1/trade_list'
params_data = {'key': 'x', 'signature': 'x'}
s = requests.get(url=url, params=params_data)

def getHash(self, s):
m = hashlib.md5()
m.update(s)
return m.hexdigest()

def sha_convert(self, s):
return hashlib.sha256(self.getHash(s)).hexdigest()

def get_nonce(self):
lens = 12
return ''.join([str(random.randint(0, 9)) for i in range(lens)])

def get_signiture(self):
url = 'xxxxxxxxx'
coin = 'zet'
nonce = self.get_nonce()

# sha=self.sha_convert(private_key)
md5 = self.getHash(self.private_key)
message = 'nonce=' + nonce + '&' + 'key=' + self.public_key
# print message
signature = hmac.new(md5, message, digestmod=hashlib.sha256).digest()
# print signature

# req=requests.post(url,data={'signature':signature,'key':public_key,'nonce':nonce,'coin':'zet'})
req = requests.post(url, data={'coin': coin})
print req.status_code
print req.text

def real_time_ticker(self, coin):
url = 'xxxxxxxx'
try:
data = requests.post(url, data={'coin': coin}).json()
#print data
except Exception ,e:
print e
return data


def real_time_depth(self, coin):
url = 'xxxxxxxxx'
data = requests.post(url, data={'coin': coin}).json()
print data
data_bids = data['bids']
data_asks = data['asks']
print "bids"
for i in data_bids:
print i[0],
print ' ',
print i[1]
print "asks"
for j in data_asks:
print j[0],
print ' ',
print j[1]

def list_all_price(self):
for i in self.coin_list:
print i,
print " price: ",
p=self.real_time_ticker(i.lower())
if p is not None:
print p[u'last']

def getOrder(self,coin):
url='https://www.jubi.com/api/v1/orders/'
try:
req=requests.get(url,params={'coin':coin})
except Exception,e:
print e

data=req.json()
return data
# recent 100 trade turn over
def turnover(self,coin):
i=coin.lower()
coins=Toolkit.getUserData('coins.csv')
total=long(coins[i])
[i] [/i]p=self.getOrder(i)
print p
amount=0.00
for j in p:
t= j[u'amount']
amount=float(t)+amount
#current=float(self.real_time_ticker(i)[u'last'])
turn_over=amount*1.00/total*100
print turn_over

def multi_thread(self,coin_list,price_list):
thread_num=len(coin_list)
thread_list=
for i in range(thread_num):
t=threading.Thread(target=self.warming, args=(coin_list,price_list[0],price_list[1]),)
thread_list.append(t)
for j in thread_list:
j.start()
for k in thread_list:
k.join()

if __name__ == '__main__':

obj = Jubi_web(send='wechat')
coin_list=['zet','doge']
price_list=[[0.2,0.13],[0.03,0.024]]
obj.multi_thread(coin_list,price_list)

[/i]
程序运行后,使用扫一扫登录。 

coin_list=['zet','doge'] price_list=[[0.2,0.13],[0.03,0.024]]
 
通过这个参数,设置你想要监控的币种和目标价格。
同时程序支持发送给多个用户。
 

 http://30daydo.com/article/205
转载请注明出处 查看全部
最近由于好友推荐我入坑了国内的山寨币,所以顺便研究了下聚币网的API。 不过网页版的聚币网和手机版的做的不好,而且因为是7x24 小时交易,自己没有那么多的精力盯盘,所以写了python代码进行监控。

Screenshot_2017-05-29-23-02-13-420_微信_副本_副本.png
# -*-coding=utf-8-*-
__author__ = 'Rocky'
'''
http://30daydo.com
Contact: weigesysu@qq.com
'''
import random
import hashlib
import hmac,time
import smtplib
from email.mime.text import MIMEText
from email import Utils
import threading
import requests,datetime,itchat

from toolkit import Toolkit


class Jubi_web():
def __init__(self, send=None):
cfg = Toolkit.getUserData('data.cfg')
self.public_key = cfg['public_key']
self.private_key = cfg['private_key']
self.send=send
from_mail = cfg['from_mail']
password = cfg['password']
to_mail = cfg['to_mail']
smtp_server = 'smtp.qq.com'

self.server = smtp_server
self.username = from_mail.split("@")[0]
self.from_mail = from_mail
self.password = password
self.to_mail = to_mail
self.coin_list=['IFC','DOGE','EAC','DNC','MET','ZET','SKT','YTC','PLC','LKC',
'JBC','MRYC','GOOC','QEC','PEB','XRP','NXT','WDC','MAX','ZCC',
'HLB','RSS','PGC','RIO','XAS','TFC','BLK','FZ','ANS','XPM','VTC',
'KTC','VRC','XSGS','LSK','PPC','ETC','GAME','LTC','ETH','BTC']
# 初始化邮箱设置读取需要股票信息
# 这样子只登陆一次
if self.send == 'msn':

try:
self.smtp = smtplib.SMTP_SSL(port=465)
self.smtp.connect(self.server)
self.smtp.login(self.username, self.password)
except smtplib.SMTPException, e:
print e
return 0

if send=='wechat':
self.w_name=u'xxxxx'

itchat.auto_login(hotReload=True)
account=itchat.get_friends(self.w_name)


def send_wechat(self,name,content):
w_content=name+' '+content
itchat.send(w_content,toUserName=self.toName)
time.sleep(1)
itchat.send(w_content,toUserName='filehelper')


def send_text(self, name, content):

subject = '%s' % name
self.msg = MIMEText(content, 'plain', 'utf-8')
self.msg['to'] = self.to_mail
self.msg['from'] = self.from_mail
self.msg['Subject'] = subject
self.msg['Date'] = Utils.formatdate(localtime=1)
try:
self.smtp.sendmail(self.msg['from'], self.msg['to'], self.msg.as_string())
self.smtp.quit()
print "sent"
except smtplib.SMTPException, e:
print e
return 0

def warming(self, coin, up_price, down_price):
url = 'https://www.jubi.com/api/v1/ticker/'
while 1:
time.sleep(5)
try:
data = requests.post(url, data={'coin': coin}).json()
except Exception,e:
print e
print "time out. Retry"
time.sleep(15)
continue

current = float(data['last'])
if current >= up_price:
print "Up to ", up_price
print "current price ",current

if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))

time.sleep(1200)
if current <= down_price:
print "Down to ", down_price
print "current price ",current
if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))
time.sleep(1200)
#上面的内容尽量不用修改。


def getContent(self):
url = 'https://www.jubi.com/api/v1/trade_list'
params_data = {'key': 'x', 'signature': 'x'}
s = requests.get(url=url, params=params_data)

def getHash(self, s):
m = hashlib.md5()
m.update(s)
return m.hexdigest()

def sha_convert(self, s):
return hashlib.sha256(self.getHash(s)).hexdigest()

def get_nonce(self):
lens = 12
return ''.join([str(random.randint(0, 9)) for i in range(lens)])

def get_signiture(self):
url = 'xxxxxxxxx'
coin = 'zet'
nonce = self.get_nonce()

# sha=self.sha_convert(private_key)
md5 = self.getHash(self.private_key)
message = 'nonce=' + nonce + '&' + 'key=' + self.public_key
# print message
signature = hmac.new(md5, message, digestmod=hashlib.sha256).digest()
# print signature

# req=requests.post(url,data={'signature':signature,'key':public_key,'nonce':nonce,'coin':'zet'})
req = requests.post(url, data={'coin': coin})
print req.status_code
print req.text

def real_time_ticker(self, coin):
url = 'xxxxxxxx'
try:
data = requests.post(url, data={'coin': coin}).json()
#print data
except Exception ,e:
print e
return data


def real_time_depth(self, coin):
url = 'xxxxxxxxx'
data = requests.post(url, data={'coin': coin}).json()
print data
data_bids = data['bids']
data_asks = data['asks']
print "bids"
for i in data_bids:
print i[0],
print ' ',
print i[1]
print "asks"
for j in data_asks:
print j[0],
print ' ',
print j[1]

def list_all_price(self):
for i in self.coin_list:
print i,
print " price: ",
p=self.real_time_ticker(i.lower())
if p is not None:
print p[u'last']

def getOrder(self,coin):
url='https://www.jubi.com/api/v1/orders/'
try:
req=requests.get(url,params={'coin':coin})
except Exception,e:
print e

data=req.json()
return data
# recent 100 trade turn over
def turnover(self,coin):
i=coin.lower()
coins=Toolkit.getUserData('coins.csv')
total=long(coins[i])
[i] [/i]p=self.getOrder(i)
print p
amount=0.00
for j in p:
t= j[u'amount']
amount=float(t)+amount
#current=float(self.real_time_ticker(i)[u'last'])
turn_over=amount*1.00/total*100
print turn_over

def multi_thread(self,coin_list,price_list):
thread_num=len(coin_list)
thread_list=
for i in range(thread_num):
t=threading.Thread(target=self.warming, args=(coin_list,price_list[0],price_list[1]),)
thread_list.append(t)
for j in thread_list:
j.start()
for k in thread_list:
k.join()

if __name__ == '__main__':

obj = Jubi_web(send='wechat')
coin_list=['zet','doge']
price_list=[[0.2,0.13],[0.03,0.024]]
obj.multi_thread(coin_list,price_list)

[/i]

程序运行后,使用扫一扫登录。 

coin_list=['zet','doge'] price_list=[[0.2,0.13],[0.03,0.024]]
 
通过这个参数,设置你想要监控的币种和目标价格。
同时程序支持发送给多个用户。
 

 http://30daydo.com/article/205
转载请注明出处

TA-Lib中MOM的计算公式

量化交易李魔佛 发表了文章 • 0 个评论 • 1018 次浏览 • 2017-05-29 01:38 • 来自相关话题

MOM是价格动能。
 TA-Lib中MOM的参数有
ouput=talib.MOM(closed,timeperiod=5)
 
closed是你传入的价格list,可以是每天的收盘价,开盘价,或者你想要计算的所有价格。
timeperiod是你要计算的时间周期。
 
假如timeperiod=5,那么,这个计算的输出值就是 p5-p0, 如果今天是1月6日,股价为14块,而1月1日的股价为12块,那么这里通过MOM运算,得出来的就是14-12=2 这个值了。 然后如此类推,如果今天是1月7日,股价为15块,而1月2日股价为11块,那么MOM得出的是4,这样子获取到所有的值,绘制成曲线,就是MOM的曲线了。 查看全部
MOM是价格动能。
 TA-Lib中MOM的参数有
ouput=talib.MOM(closed,timeperiod=5)
 
closed是你传入的价格list,可以是每天的收盘价,开盘价,或者你想要计算的所有价格。
timeperiod是你要计算的时间周期。
 
假如timeperiod=5,那么,这个计算的输出值就是 p5-p0, 如果今天是1月6日,股价为14块,而1月1日的股价为12块,那么这里通过MOM运算,得出来的就是14-12=2 这个值了。 然后如此类推,如果今天是1月7日,股价为15块,而1月2日股价为11块,那么MOM得出的是4,这样子获取到所有的值,绘制成曲线,就是MOM的曲线了。

Price Momentum

股票李魔佛 发表了文章 • 0 个评论 • 793 次浏览 • 2017-05-29 01:20 • 来自相关话题

Understanding Price Momentum

Today's stock market is more than just a place to buy and hold securities. Many investors prefer to move quickly in and out of the market. That's just one reason technical strategies, such as price momentum, have grown in popularity.

In this article, we're going to provide some insights into the investment strategy known as price momentum.  We'll explain why some theorists believe this model offers investors a short-term profit opportunity.  We'll also talk about the pros and cons of this approach, including the long-term opportunity that price momentum provides the market.

What is Price Momentum?

Additional Resources

Calculating Stock Prices
Capital Asset Pricing Model
Arbitrage Pricing Theory
Stock Beta and Volatility
Random Walk Theory Explained

The theory behind price momentum is relatively simple.  Generally, we can talk about it in two ways; the first has to do with buying stocks:

Stocks that had relatively high returns over the past three to twelve months should return to investors above average returns over the next three to twelve months.

The theory also provides guidance on the right time to sell stocks:

Stocks that had relatively poor returns over the past three to twelve months should return to investors below average returns over the next three to twelve months.

This investment strategy was first theorized by Narasimhan Jegadeesh and Sheridan Titman in their publication "Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency," which was published in The Journal of Finance back in March 1993.

Price Momentum Model

The model is based on the assumption the stock market is not completely efficient. This is something that most economists believe to be true.  The two most practical explanations for the performance of this model include:

Investors are taking advantage of human behavior, including a "herding" mentality and / or an overreaction to news.
Investors employing a price momentum strategy are taking on additional risk; therefore, higher returns are required to compensate these investors for the risk they're assuming.

Within their study, Jegadeesh and Titman examined a large number of trading strategies.  One of the conclusions from that study is stated below:

Buying past winners, and selling past losers, allowed investors to achieve above average returns over the period 1956 to 1989.  In particular, stocks that were classified based on their prior 6-month performance, and held for 6 months realized an excess return of over 12% per year on average.

The Momentum Formula

Technical stock analysts understand the value this particular technique provides.  They're constantly crunching numbers to see if patterns emerge.  The actual formula for calculating price momentum is really quite simple, and takes the form:

M = CP - CPn

Where:

M = Momentum
CP = Closing price in the current period
CPn = Closing price N periods ago

For example, if a stock was trading at $35 per share six months ago, and is currently trading at $40 per share, then its six-month price momentum would be 40 minus 35 or 5.

Unfortunately, this formula is not normalized, and this makes it difficult to compare stocks selling at different price points.  A stock experiencing a 1% price movement from $300 to $303 would have a momentum value of three.  A second stock experiencing a 100% increase in price from $3 to $6 also has a momentum value of three.

Rate of Change Formula

One of the ways technical stock analysts can work around this problem is by calculating a rate of change value, which normalizes momentum:

RoC = (CP - CPn) / CPn

Where:

RoC = Rate of Change
CP = Closing price in the current period
CPn = Closing price N periods ago

Using the example above, the stock selling at $303 per share that was trading at $300 six months ago would have a Rate of Change of 3 / 300 or 1%, while the second stock would have a Rate of Change of 3 / 3 or 100%.

Momentum and Moving Averages

A second way that stock analysts use price momentum is in conjunction with moving averages.  Here the technical analyst makes a series of price momentum calculations and plots these along with a moving average of the momentum.

For example, the plot might contain 28-day moving averages along with daily price momentum figures.  Buy signals can be triggered when price momentum travels above its moving averages, and stays there for several trading days.  Sell signals can be triggered when momentum travels below its moving average.

Contrarian Investing

As mentioned in the beginning of this article, this model tells investors they should buy past winners and sell past losers.  Because this theory is based on past price performance, or historical market information, price momentum is a trading model that technical analysts would follow.  Fundamental analysts believe that a stock is bought and sold based on its intrinsic value, including the company's potential to produce profits for its shareholders in the future.

Fortunately, fundamental analysts can also use price momentum to their advantage by adopting what is termed a contrarian investing strategy.  Contrarian investors take the opposite approach that a theory advocates.  For example, a fundamental analyst might conclude:

A stock that has been rising may now be overvalued, while a stock that has been falling may be undervalued.

One could argue the further a stock moves from its true market value, the greater the opportunity for profits.  By tracking price momentum, and using this as a screening tool, fundamental analysts can then assess if a stock is truly undervalued or overvalued by studying the company's long-term financial health and earnings power.

About the Author - Understanding Price Momentum (Last Reviewed on November 22, 2016)
 
http://30daydo.com/article/203
  查看全部
Understanding Price Momentum

Today's stock market is more than just a place to buy and hold securities. Many investors prefer to move quickly in and out of the market. That's just one reason technical strategies, such as price momentum, have grown in popularity.

In this article, we're going to provide some insights into the investment strategy known as price momentum.  We'll explain why some theorists believe this model offers investors a short-term profit opportunity.  We'll also talk about the pros and cons of this approach, including the long-term opportunity that price momentum provides the market.

What is Price Momentum?

Additional Resources

Calculating Stock Prices
Capital Asset Pricing Model
Arbitrage Pricing Theory
Stock Beta and Volatility
Random Walk Theory Explained

The theory behind price momentum is relatively simple.  Generally, we can talk about it in two ways; the first has to do with buying stocks:

Stocks that had relatively high returns over the past three to twelve months should return to investors above average returns over the next three to twelve months.

The theory also provides guidance on the right time to sell stocks:

Stocks that had relatively poor returns over the past three to twelve months should return to investors below average returns over the next three to twelve months.

This investment strategy was first theorized by Narasimhan Jegadeesh and Sheridan Titman in their publication "Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency," which was published in The Journal of Finance back in March 1993.

Price Momentum Model

The model is based on the assumption the stock market is not completely efficient. This is something that most economists believe to be true.  The two most practical explanations for the performance of this model include:

Investors are taking advantage of human behavior, including a "herding" mentality and / or an overreaction to news.
Investors employing a price momentum strategy are taking on additional risk; therefore, higher returns are required to compensate these investors for the risk they're assuming.

Within their study, Jegadeesh and Titman examined a large number of trading strategies.  One of the conclusions from that study is stated below:

Buying past winners, and selling past losers, allowed investors to achieve above average returns over the period 1956 to 1989.  In particular, stocks that were classified based on their prior 6-month performance, and held for 6 months realized an excess return of over 12% per year on average.

The Momentum Formula

Technical stock analysts understand the value this particular technique provides.  They're constantly crunching numbers to see if patterns emerge.  The actual formula for calculating price momentum is really quite simple, and takes the form:

M = CP - CPn

Where:

M = Momentum
CP = Closing price in the current period
CPn = Closing price N periods ago

For example, if a stock was trading at $35 per share six months ago, and is currently trading at $40 per share, then its six-month price momentum would be 40 minus 35 or 5.

Unfortunately, this formula is not normalized, and this makes it difficult to compare stocks selling at different price points.  A stock experiencing a 1% price movement from $300 to $303 would have a momentum value of three.  A second stock experiencing a 100% increase in price from $3 to $6 also has a momentum value of three.

Rate of Change Formula

One of the ways technical stock analysts can work around this problem is by calculating a rate of change value, which normalizes momentum:

RoC = (CP - CPn) / CPn

Where:

RoC = Rate of Change
CP = Closing price in the current period
CPn = Closing price N periods ago

Using the example above, the stock selling at $303 per share that was trading at $300 six months ago would have a Rate of Change of 3 / 300 or 1%, while the second stock would have a Rate of Change of 3 / 3 or 100%.

Momentum and Moving Averages

A second way that stock analysts use price momentum is in conjunction with moving averages.  Here the technical analyst makes a series of price momentum calculations and plots these along with a moving average of the momentum.

For example, the plot might contain 28-day moving averages along with daily price momentum figures.  Buy signals can be triggered when price momentum travels above its moving averages, and stays there for several trading days.  Sell signals can be triggered when momentum travels below its moving average.

Contrarian Investing

As mentioned in the beginning of this article, this model tells investors they should buy past winners and sell past losers.  Because this theory is based on past price performance, or historical market information, price momentum is a trading model that technical analysts would follow.  Fundamental analysts believe that a stock is bought and sold based on its intrinsic value, including the company's potential to produce profits for its shareholders in the future.

Fortunately, fundamental analysts can also use price momentum to their advantage by adopting what is termed a contrarian investing strategy.  Contrarian investors take the opposite approach that a theory advocates.  For example, a fundamental analyst might conclude:

A stock that has been rising may now be overvalued, while a stock that has been falling may be undervalued.

One could argue the further a stock moves from its true market value, the greater the opportunity for profits.  By tracking price momentum, and using this as a screening tool, fundamental analysts can then assess if a stock is truly undervalued or overvalued by studying the company's long-term financial health and earnings power.

About the Author - Understanding Price Momentum (Last Reviewed on November 22, 2016)
 
http://30daydo.com/article/203
 

TA-Lib MA_Type

股票李魔佛 发表了文章 • 0 个评论 • 2511 次浏览 • 2017-05-29 00:43 • 来自相关话题

在TA-Lib中有一个参数的类型是MA_Type, 谷歌了一下,把内容贴出来。 
 
主要就是使用不一样的加权方式对数据进行处理。import talib
from talib import MA_Type

MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)
 
移动平均(英语:moving average,MA),又称“移动平均线”简称均线,是技术分析中一种分析时间序列数据的工具。最常见的是利用股价、回报或交易量等变数计算出移动平均。
移动平均可抚平短期波动,反映出长期趋势或周期。数学上,移动平均可视为一种卷积。
 

简单移动平均(英语:simple moving average,SMA)是某变数之前n个数值的未作加权算术平均。例如,收市价的10日简单移动平均指之前10日收市价的平均数。:

当计算连续的数值,一个新的数值加入,同时一个旧数值剔出,所以无需每次都重新逐个数值加起来。
在技术分析中,不同的市场对常用天数(n值)有不同的需求,例如:某些市场普遍的n值为10日、40日、200日;有些则是5日、10日、20日、60日、120日、240日,视乎分析时期长短而定。投资者冀从移动平均线的图表中分辨出支持位或阻力位。
 
 
 
加权移动平均(英语:weighted moving average,WMA)指计算平均值时将个别数据乘以不同数值,在技术分析中,n日WMA的最近期一个数值乘以n、次近的乘以n-1,如此类推,一直到0:
 
指数移动平均(英语:exponential moving average,EMA或EWMA)是以指数式递减加权的移动平均。各数值的加权影响力随时间而指数式递减,越近期的数据加权影响力越重,但较旧的数据也给予一定的加权值
 
     
     WMA                                             EMA
 
 
使用下面的代码实现不一样的MA
  #MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)
df=ts.get_k_data('300580',start='2017-01-12',end='2017-05-26')
closed=df['close'].values
sma=talib.MA(closed,timeperiod=10,matype=0)
ema=talib.MA(closed,timeperiod=10,matype=1)
wma=talib.MA(closed,timeperiod=10,matype=2)
dema=talib.MA(closed,timeperiod=10,matype=3)
tema=talib.MA(closed,timeperiod=10,matype=4)
trima=talib.MA(closed,timeperiod=10,matype=5)
kma=talib.MA(closed,timeperiod=10,matype=6)
mama=talib.MA(closed,timeperiod=10,matype=7)
t3=talib.MA(closed,timeperiod=10,matype=8)
#ouput=talib.MA(closed,timeperiod=5,matype=0)
print closed
plt.ylim([0,40])
plt.plot(sma)
plt.plot(ema)
plt.plot(wma)
plt.plot(dema)
plt.plot(tema)
plt.plot(trima)
plt.plot(kma)
plt.plot(mama)
plt.plot(t3)
plt.grid()
plt.show()
生成的图像如下:





 
http://30daydo.com/article/201
转载请注明出处 查看全部
在TA-Lib中有一个参数的类型是MA_Type, 谷歌了一下,把内容贴出来。 
 
主要就是使用不一样的加权方式对数据进行处理。
import talib
from talib import MA_Type

MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)

 
移动平均(英语:moving average,MA),又称“移动平均线”简称均线,是技术分析中一种分析时间序列数据的工具。最常见的是利用股价、回报或交易量等变数计算出移动平均。
移动平均可抚平短期波动,反映出长期趋势或周期。数学上,移动平均可视为一种卷积。
 

简单移动平均(英语:simple moving average,SMA)是某变数之前n个数值的未作加权算术平均。例如,收市价的10日简单移动平均指之前10日收市价的平均数。:

当计算连续的数值,一个新的数值加入,同时一个旧数值剔出,所以无需每次都重新逐个数值加起来。
在技术分析中,不同的市场对常用天数(n值)有不同的需求,例如:某些市场普遍的n值为10日、40日、200日;有些则是5日、10日、20日、60日、120日、240日,视乎分析时期长短而定。投资者冀从移动平均线的图表中分辨出支持位或阻力位。
 
 
 
加权移动平均(英语:weighted moving average,WMA)指计算平均值时将个别数据乘以不同数值,在技术分析中,n日WMA的最近期一个数值乘以n、次近的乘以n-1,如此类推,一直到0:
 
指数移动平均(英语:exponential moving average,EMA或EWMA)是以指数式递减加权的移动平均。各数值的加权影响力随时间而指数式递减,越近期的数据加权影响力越重,但较旧的数据也给予一定的加权值
 
     
     WMA                                             EMA
 
 
使用下面的代码实现不一样的MA
 
    #MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)
df=ts.get_k_data('300580',start='2017-01-12',end='2017-05-26')
closed=df['close'].values
sma=talib.MA(closed,timeperiod=10,matype=0)
ema=talib.MA(closed,timeperiod=10,matype=1)
wma=talib.MA(closed,timeperiod=10,matype=2)
dema=talib.MA(closed,timeperiod=10,matype=3)
tema=talib.MA(closed,timeperiod=10,matype=4)
trima=talib.MA(closed,timeperiod=10,matype=5)
kma=talib.MA(closed,timeperiod=10,matype=6)
mama=talib.MA(closed,timeperiod=10,matype=7)
t3=talib.MA(closed,timeperiod=10,matype=8)
#ouput=talib.MA(closed,timeperiod=5,matype=0)
print closed
plt.ylim([0,40])
plt.plot(sma)
plt.plot(ema)
plt.plot(wma)
plt.plot(dema)
plt.plot(tema)
plt.plot(trima)
plt.plot(kma)
plt.plot(mama)
plt.plot(t3)
plt.grid()
plt.show()

生成的图像如下:

diff_ma.PNG

 
http://30daydo.com/article/201
转载请注明出处

可转债套利【一】 python找出折价可转债个股

量化交易李魔佛 发表了文章 • 2 个评论 • 3282 次浏览 • 2018-03-16 17:17 • 来自相关话题

关于可转债的定义,可以到https://xueqiu.com/6832369826/103042836 这里科普一下。
 
下面的内容默认你对可转债已经有一定的了解。
 
可转债的价值=正股价格/转股价格 + 利息,忽略可转债的利息,直接用公式 可转债的价值=正股价格/转股价格 计算可转债的价值。
 
如果当前可转债的交易价格(在交易软件上显示的价格)如:




所以万信转债的价格是121.5元,然后万信转债的价值呢? 按照上面的公式,万信转债的正股是万达信息,今天万达信息  (2018-03-16)的股价是





以收盘价为例,17.25。
 
而万信转债的股转价格呢? 这个可以到万信转债F10页面的公告中找到,为13.11元。 所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100, 所以万信转债的内在价值是1.315*100=131.5, 而当前的交易价格为 121.5





 
 
也就是你用121.5元买到一个价值 131.5的商品, 所以相当于打折买到了一个超值的商品,所以当前的万信转债是折价状态。
 
所以本次任务就是要找出可交易的可转债中折价状态的可转债。
 
然后直接上干货。上python代码。#-*-coding=utf-8
'''
可转债监控
'''
import tushare as ts
from setting import get_engine
engine = get_engine('db_bond')
import pandas as pd
import datetime
class ConvertBond():

def __init__(self):
self.conn=ts.get_apis()
self.allBonds=ts.new_cbonds(pause=2)
self.onSellBond=self.allBonds.dropna(subset=['marketprice'])
self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')

def stockPrice(self,code):
stock_df = ts.get_realtime_quotes(code)
price = float(stock_df['price'].values[0])
return price

def dataframe(self):
price_list=[]
for code in self.onSellBond['scode']:
price_list.append(self.stockPrice(code))
self.onSellBond['stock_price']=price_list
self.onSellBond['ratio'] = (
self.onSellBond['marketprice']
/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100
self.onSellBond['Updated']=self.today
self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')

def closed(self):
ts.close_apis(self.conn)

def main():
bond=ConvertBond()
bond.dataframe()
bond.closed()
if __name__=='__main__':
main()







 上面的setting库,把下面的*** 替换成你自己的Mysql用户和密码即可。import os
import MySQLdb
MYSQL_USER = *********
MYSQL_PASSWORD = ********
MYSQL_HOST = *********
MYSQL_PORT = *****

def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine 
上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示:







点击放大
  2018-03-16 可转债表格
 
其中折价率是ratio列。按照ratio列进行排列,只有2个是正,也就是当前市场是只有2只可转债是处于折价状态的,其余的都是溢价状态(价格比内在价值要贵,忽略利息的前提下,如果把4~5%的利息也算进去的话,-3~4%的折价率其实也算小折价吧)
 
目前万信转债折价10个点,宝信转债折价5.8个点。 所以适合低风险投资者建仓。 因为可转债有兜底价格,所以出现亏损的概率很低(除非遇到黑天鹅,公司破产了,像遇到乐视这种PPT独角兽公司,欠债不还的。 但是A股上能够有资格发行可转债的,本身对公司的盈利,分红都有硬性要求)。
 
所以可以保存上面的代码,可以每天运行一次,可以很方便地找出折价的个股,当然也可以在盘中一直监测,因为可转债的价格是实时变化的,一旦遇到大跌,跌到折价状态,你也可以择时入手标的。

原文链接:
http://30daydo.com/article/286
转载请注明出处 查看全部
关于可转债的定义,可以到https://xueqiu.com/6832369826/103042836 这里科普一下。
 
下面的内容默认你对可转债已经有一定的了解。
 
可转债的价值=正股价格/转股价格 + 利息,忽略可转债的利息,直接用公式 可转债的价值=正股价格/转股价格 计算可转债的价值。
 
如果当前可转债的交易价格(在交易软件上显示的价格)如:
wxzz.GIF

所以万信转债的价格是121.5元,然后万信转债的价值呢? 按照上面的公式,万信转债的正股是万达信息,今天万达信息  (2018-03-16)的股价是

万达信息.GIF

以收盘价为例,17.25。
 
而万信转债的股转价格呢? 这个可以到万信转债F10页面的公告中找到,为13.11元。 所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100, 所以万信转债的内在价值是1.315*100=131.5, 而当前的交易价格为 121.5

wxzz.GIF

 
 
也就是你用121.5元买到一个价值 131.5的商品, 所以相当于打折买到了一个超值的商品,所以当前的万信转债是折价状态。
 
所以本次任务就是要找出可交易的可转债中折价状态的可转债。
 
然后直接上干货。上python代码。
#-*-coding=utf-8
'''
可转债监控
'''
import tushare as ts
from setting import get_engine
engine = get_engine('db_bond')
import pandas as pd
import datetime
class ConvertBond():

def __init__(self):
self.conn=ts.get_apis()
self.allBonds=ts.new_cbonds(pause=2)
self.onSellBond=self.allBonds.dropna(subset=['marketprice'])
self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')

def stockPrice(self,code):
stock_df = ts.get_realtime_quotes(code)
price = float(stock_df['price'].values[0])
return price

def dataframe(self):
price_list=[]
for code in self.onSellBond['scode']:
price_list.append(self.stockPrice(code))
self.onSellBond['stock_price']=price_list
self.onSellBond['ratio'] = (
self.onSellBond['marketprice']
/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100
self.onSellBond['Updated']=self.today
self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')

def closed(self):
ts.close_apis(self.conn)

def main():
bond=ConvertBond()
bond.dataframe()
bond.closed()
if __name__=='__main__':
main()







 上面的setting库,把下面的*** 替换成你自己的Mysql用户和密码即可。
import os
import MySQLdb
MYSQL_USER = *********
MYSQL_PASSWORD = ********
MYSQL_HOST = *********
MYSQL_PORT = *****

def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine
 
上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示:


Screenshot_from_2018-03-28_09-14-35.png


点击放大
  2018-03-16 可转债表格
 
其中折价率是ratio列。按照ratio列进行排列,只有2个是正,也就是当前市场是只有2只可转债是处于折价状态的,其余的都是溢价状态(价格比内在价值要贵,忽略利息的前提下,如果把4~5%的利息也算进去的话,-3~4%的折价率其实也算小折价吧)
 
目前万信转债折价10个点,宝信转债折价5.8个点。 所以适合低风险投资者建仓。 因为可转债有兜底价格,所以出现亏损的概率很低(除非遇到黑天鹅,公司破产了,像遇到乐视这种PPT独角兽公司,欠债不还的。 但是A股上能够有资格发行可转债的,本身对公司的盈利,分红都有硬性要求)。
 
所以可以保存上面的代码,可以每天运行一次,可以很方便地找出折价的个股,当然也可以在盘中一直监测,因为可转债的价格是实时变化的,一旦遇到大跌,跌到折价状态,你也可以择时入手标的。

原文链接:
http://30daydo.com/article/286
转载请注明出处

聚币网/coinegg API使用教程 附demo代码

量化交易李魔佛 发表了文章 • 56 个评论 • 11333 次浏览 • 2017-05-11 09:05 • 来自相关话题

******* 2018.14 更新 ***********
现在聚币网已经被关闭了,但是所有的币都可以转移到CoinEgg网了,币种和以前一模一样,只是用户参与度减少了很多,市场不是一个有效的市场,但是这对于操盘手来说,更加是一个收益大的地方。
使用下面链接注册后,用户可以返30%的佣金。 其实也无所谓,佣金不会很多,一次也就几分钱到几毛钱,自己去官网注册也可以。看个人心情啦。
 
http://www.coinegg.com/user/register?inv=7d91a
 
 后续会就coinegg写一个自动交易的系统出来
 

******* 8.28 更新 ***********
不少人反应签名不通过,经过调试,发现是加密前的字符拼接的顺序问题,这个拼接顺序要和你post上去的顺序要一致,才能通过。如果出现104的返回代码,说明是你的顺序问题,说明你的签名没有成功。
 
贴代码说明下: 使用字典循环,就可以知道正确的拼接顺序。 下面的代码是获取成交订单的。 def Trade_list(self, coin):
'''
Trade_list(挂单查询)
您指定时间后的挂单,可以根据类型查询,比如查看正在挂单和全部挂单
Path:/api/v1/trade_list/
Request类型:POST
参数
key - API key
signature - signature
nonce - nonce
since - unix timestamp(utc timezone) default == 0, i.e. 返回所有
coin - 币种简称,例如btc、ltc、xas
type - 挂单类型[open:正在挂单, all:所有挂单]

返回JSON dictionary
id - 挂单ID
datetime - date and time
type - "buy" or "sell"
price - price
amount_original - 下单时数量
amount_outstanding - 当前剩余数量
'''
url = self.host + '/api/v1/trade_list/'
time.sleep(random.random())
nonce = self.get_nonce_time()
types = 'all'
since = 0
parameters = {'key': self.public_key, 'nonce': str(nonce), 'type': types, 'coin': coin, 'signature': ''}
# print parameters
post_data = ''
for k, v in parameters.items():
if not isinstance(v, str):
#if type(v) is not types.StringType:
v = str(v)
post_data = post_data + k
post_data = post_data + '=' + v + '&'

#print 'post-data:\n',post_data
post_data = post_data[:-1]
post_data = post_data.replace('&signature=', '')
#print post_data

signature = hmac.new(self.md5, post_data, digestmod=hashlib.sha256).digest()
sig = self.toHex(signature)
parameters['signature'] = sig
#print parameters
r = requests.post(url=url, data=parameters)
s = r.json()
#print s
return s
 
如果还是没有解决的话就网站内私信我看看问题所在。

******************************************* 原文内容 ***************************************************
 

 官方有API的文档,可是这个文档就像一个草稿一样,两个基本例子都没有。 所以自己摸索一下,自己写一个现成的例子给大家,可以有个参考。 下面的例子亲测成功。 
 
首先看一下官方的API文档:

一、API使用说明

1、请求过程说明

1.1 构造请求数据,用户数据按照Jubi提供的接口规则,通过程序生成签名和要传输给Jubi的数据集合;

1.2 发送请求数据,把构造完成的数据集合通过POST/GET提交的方式传递给Jubi;

1.3 Jubi对请求数据进行处理,服务器在接收到请求后,会首先进行安全校验,验证通过后便会处理该次发送过来的请求;

1.4 返回响应结果数据,Jubi把响应结果以JSON的格式反馈给用户,具体的响应格式,错误代码参见接口部分;

1.5 对获取的返回结果数据进行处理;

2、安全认证

所有的private API都需要经过认证

Api的申请可以到财务中心 -> API,申请得到私钥和公钥,私钥Jubi将不做储存,一旦丢失将无法找回

注意:请勿向任何人泄露这两个参数,这像您的密码一样重要

2.签名机制

每次请求private api 都需要验证签名,发送的参数示例:

$param = array(

amount => 1,

price => 10000,

type => 'buy',

nonce => 141377098123

key => 5zi7w-4mnes-swmc4-egg9b-f2iqw-396z4-g541b

signature => 459c69d25c496765191582d9611028b9974830e9dfafd762854669809290ed82

);

nonce 可以理解为一个递增的整数:http://zh.wikipedia.org/wiki/Nonce

key 是申请到的公钥

signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.

 

 
 
  
首先聚币的行情是使用网络爬虫获取的,而说明中给出了一系列的参数,你需要做的就是把这些参数填充上去。
 
如果你只是想要获取行情,那么事情容易很多。 def real_time_ticker(coin):
url = 'https://www.jubi.com/api/v1/ticker/'
try:
data = requests.post(url, data={'coin': coin}).json()

except Exception ,e:
print e
return data
上面代码展示的时候获取实时的行情。委一和买一的价格,数量,和当前成交的数量,价格。
 按照上面的格式,把参数coin填上去,比如要获取泽塔币, real_time_ticker('zet') 就会返回获取的数据。{u'sell': u'0.179000', u'volume': 21828245.102822, u'buy': u'0.175010', u'last': u'0.179000', u'vol': 108290769.9171, u'high': u'0.289000', u'low': u'0.119141'}
 
 
所有的private API都需要经过认证, 就是说如果你要进行交易,委托,下单,你就需要使用私钥和公钥,并进行一系列的加密。

每次请求private api 都需要验证签名,发送的参数示例:

$param = array(

amount => 1,

price => 10000,

type => 'buy',

nonce => 141377098123

key => 5zi7w-4mnes-swmc4-egg9b-f2iqw-396z4-g541b

signature => 459c69d25c496765191582d9611028b9974830e9dfafd762854669809290ed82

);

nonce 可以理解为一个递增的整数:http://zh.wikipedia.org/wiki/Nonce

key 是申请到的公钥

signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.

 
 
比如下单:

Trade_add(下单)
Path:/api/v1/trade_add/
Request类型:POST
 
参数
key - API key
signature - signature
nonce - nonce
amount - 购买数量
price - 购买价格
type - 买单或者卖单
coin - 币种简称,例如btc、ltc、xas
id - 挂单ID
result - true(成功), false(失败)
{"result":true, "id":"11"}
 
返回JSON dictionary
id - 挂单ID
result - true(成功), false(失败)
 
返回结果示例:
{"result":true, "id":"11"}
 


首先解决nonce。
 
在维基百科中
在安全工程中,Nonce是一个在加密通信只能使用一次的数字。在认证协议中,它往往是一个随机或伪随机数,以避免重放攻击。Nonce也用于流密码以确保安全。如果需要使用相同的密钥加密一个以上的消息,就需要Nonce来确保不同的消息与该密钥加密的密钥流不同。
 
结合stackoverflow, nonce只是一个12位的随机数。
可以用以下方法获得这个随机数 def get_nonce(self):
lens=12
return ''.join([str(random.randint(0, 9)) for i in range(lens)])
 聚币中的nonce的位数是12位,所以lens定义为12
 
或者可以直接用时间函数生成: def get_nonce_time(self):
lens = 12
curr_stamp = time.time()*100
nonece=int(curr_stamp)
return nonece
 
然后是signature。
signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.

先把私钥进行md5处理 def getHash(self,s):
m=hashlib.md5()
m.update(s)
return m.hexdigest()
只要把私钥传入函数getHash就可以得到一个md5处理过的字符串。
 
私钥是聚币网给每个用户分配的字符串,是唯一的,这里假设为private_key=123456789吧,具体是多少,在你的聚币网设置里面可以找到。
sha_256key=self.getHash(private_key)
 
按照要求吧 你要post的数据字符串连起来nonce=self.get_nonce_time
type='buy'
amount='10000'
key='xxxxxxxxxxx‘ #这个是聚币网给你的公钥,同样在设置里头可以找到
price='10' #你要设置的价格为10
coin='zet'
message = "amount=“+amount+”&nonce="+str(nonce)+"&type="+type+"&key="+key+'&price="+price+"&coin"+coin

signature = hmac.new(sha_256key, message, digestmod=hashlib.sha256).digest()

这样获得signature之后,就可以通过签名来进行post操作。

data_wrap={'nonce':nonce,'key':key_value,'signature':signature}

js=requests.post(url,data=data_wrap).json()
 
如果直接按照上面的代码去获取账户相关信息或者去挂单的话,会返回104的签名错误。 经过不断的排查,发现是signature的字符格式的问题。
 
构造一个str转换格式的函数: def toHex(self,str):
lst =
for ch in str:
hv = hex(ord(ch)).replace('0x', '')
if len(hv) == 1:
hv = '0' + hv
lst.append(hv)
return reduce(lambda x, y: x + y, lst)这个函数的作用就是把原来十六进制格式的字符完全转化成十六进制,把前面的0x去掉,不足2位的补全为2位。
把经过处理的signature进行格式转换后,几次提交,终于发现可以获取到用户的账户信息,进行下单,撤单,等操作。
 
 
 
下面是一个获取账户信息的代码段: def getAccount(self):
url='https://www.jubi.com/api/v1/balance/'

nonce_value=self.get_nonce_time()
print nonce_value
key_value=self.public_key
private_key=self.private_key

s='nonce='+str(nonce_value)+'&'+'key='+key_value

print s

#signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.
md5=self.getHash(private_key)
print md5
print type(md5)

msg=bytes(s).encode('utf-8')
key=bytes(md5).encode('utf-8')
signature =hmac.new(key,msg,digestmod=hashlib.sha256).digest()
print signature
print type(signature)
sig=self.toHex(signature)

print sig
data_wrap={'nonce':nonce_value,'key':key_value,'signature':sig}

print data_wrap

data_en=urllib.urlencode(data_wrap)
req=urllib2.Request(url,data=data_en)
resp=urllib2.urlopen(req).read()
print resp


def toHex(self,str):
lst =
for ch in str:
hv = hex(ord(ch)).replace('0x', '')
if len(hv) == 1:
hv = '0' + hv
lst.append(hv)
return reduce(lambda x, y: x + y, lst)
 
以上的代码运行后返回一下账户信息:{"uid":123456,"nameauth":1,"moflag":1,"asset":,"btc_balance":0,"btc_lock":0,"drk_balance":0,"drk_lock":0,"blk_balance":0,"blk_lock":0,"vrc_balance":0,"vrc_lock":0,"tfc_balance":0,"tfc_lock":0,"jbc_balance":0,"jbc_lock":0,"ltc_balance":0,"ltc_lock":0,"doge_balance":0,"doge_lock":0,"xpm_balance":0,"xpm_lock":0,"ppc_balance":0,"ppc_lock":0,"wdc_balance":0,"wdc_lock":0,"vtc_balance":0,"vtc_lock":0,"max_balance":0,"max_lock":0,"ifc_balance":0,"ifc_lock":0,"zcc_balance":0,"zcc_lock":0,"zet_balance":0,"zet_lock":0,"eac_balance":0,"eac_lock":0,"fz_balance":0,"fz_lock":0,"skt_balance":0,"skt_lock":0,"plc_balance":0,"plc_lock":0,"mtc_balance":0,"mtc_lock":0,"qec_balance":0,"qec_lock":0,"lkc_balance":10,"lkc_lock":0,"met_balance":0,"met_lock":0,"ytc_balance":0,"ytc_lock":0,"hlb_balance":0,"hlb_lock":0,"game_balance":0,"game_lock":0,"rss_balance":0,"rss_lock":0,"rio_balance":0,"rio_lock":0,"ktc_balance":0,"ktc_lock":0,"pgc_balance":0,"pgc_lock":0,"mryc_balance":0,"mryc_lock":0,"eth_balance":0,"eth_lock":0,"etc_balance":0,"etc_lock":0,"dnc_balance":0,"dnc_lock":0,"gooc_balance":0,"gooc_lock":0,"xrp_balance":0,"xrp_lock":0,"nxt_balance":0,"nxt_lock":0,"lsk_balance":0,"lsk_lock":0,"xas_balance":0,"xas_lock":0,"peb_balance":0,"peb_lock":0,"nhgh_balance":0,"nhgh_lock":0,"xsgs_balance":0,"xsgs_lock":0,"ans_balance":0,"ans_lock":0,"bts_balance":0,"bts_lock":0,"cny_balance":0,"cny_lock":0}











 
聚币网个人邀请码:
514330
 
还没注册可以拿去用,对于我而言可以拿到你们交易费用的50%,不过一般交易费除非是超级大户,一般散户都很少。千分之一的交易手续费。
 
欢迎一起讨论:
Email:weigesysu@qq.com

 原创内容,转载请注明出处
http://30daydo.com/article/181 
  查看全部
******* 2018.14 更新 ***********
现在聚币网已经被关闭了,但是所有的币都可以转移到CoinEgg网了,币种和以前一模一样,只是用户参与度减少了很多,市场不是一个有效的市场,但是这对于操盘手来说,更加是一个收益大的地方。
使用下面链接注册后,用户可以返30%的佣金。 其实也无所谓,佣金不会很多,一次也就几分钱到几毛钱,自己去官网注册也可以。看个人心情啦。
 
http://www.coinegg.com/user/register?inv=7d91a
 
 后续会就coinegg写一个自动交易的系统出来
 

******* 8.28 更新 ***********
不少人反应签名不通过,经过调试,发现是加密前的字符拼接的顺序问题,这个拼接顺序要和你post上去的顺序要一致,才能通过。如果出现104的返回代码,说明是你的顺序问题,说明你的签名没有成功。
 
贴代码说明下: 使用字典循环,就可以知道正确的拼接顺序。 下面的代码是获取成交订单的。
    def Trade_list(self, coin):
'''
Trade_list(挂单查询)
您指定时间后的挂单,可以根据类型查询,比如查看正在挂单和全部挂单
Path:/api/v1/trade_list/
Request类型:POST
参数
key - API key
signature - signature
nonce - nonce
since - unix timestamp(utc timezone) default == 0, i.e. 返回所有
coin - 币种简称,例如btc、ltc、xas
type - 挂单类型[open:正在挂单, all:所有挂单]

返回JSON dictionary
id - 挂单ID
datetime - date and time
type - "buy" or "sell"
price - price
amount_original - 下单时数量
amount_outstanding - 当前剩余数量
'''
url = self.host + '/api/v1/trade_list/'
time.sleep(random.random())
nonce = self.get_nonce_time()
types = 'all'
since = 0
parameters = {'key': self.public_key, 'nonce': str(nonce), 'type': types, 'coin': coin, 'signature': ''}
# print parameters
post_data = ''
for k, v in parameters.items():
if not isinstance(v, str):
#if type(v) is not types.StringType:
v = str(v)
post_data = post_data + k
post_data = post_data + '=' + v + '&'

#print 'post-data:\n',post_data
post_data = post_data[:-1]
post_data = post_data.replace('&signature=', '')
#print post_data

signature = hmac.new(self.md5, post_data, digestmod=hashlib.sha256).digest()
sig = self.toHex(signature)
parameters['signature'] = sig
#print parameters
r = requests.post(url=url, data=parameters)
s = r.json()
#print s
return s

 
如果还是没有解决的话就网站内私信我看看问题所在。

******************************************* 原文内容 ***************************************************
 

 官方有API的文档,可是这个文档就像一个草稿一样,两个基本例子都没有。 所以自己摸索一下,自己写一个现成的例子给大家,可以有个参考。 下面的例子亲测成功。 
 
首先看一下官方的API文档:


一、API使用说明

1、请求过程说明

1.1 构造请求数据,用户数据按照Jubi提供的接口规则,通过程序生成签名和要传输给Jubi的数据集合;

1.2 发送请求数据,把构造完成的数据集合通过POST/GET提交的方式传递给Jubi;

1.3 Jubi对请求数据进行处理,服务器在接收到请求后,会首先进行安全校验,验证通过后便会处理该次发送过来的请求;

1.4 返回响应结果数据,Jubi把响应结果以JSON的格式反馈给用户,具体的响应格式,错误代码参见接口部分;

1.5 对获取的返回结果数据进行处理;

2、安全认证

所有的private API都需要经过认证

Api的申请可以到财务中心 -> API,申请得到私钥和公钥,私钥Jubi将不做储存,一旦丢失将无法找回

注意:请勿向任何人泄露这两个参数,这像您的密码一样重要

2.签名机制

每次请求private api 都需要验证签名,发送的参数示例:

$param = array(

amount => 1,

price => 10000,

type => 'buy',

nonce => 141377098123

key => 5zi7w-4mnes-swmc4-egg9b-f2iqw-396z4-g541b

signature => 459c69d25c496765191582d9611028b9974830e9dfafd762854669809290ed82

);

nonce 可以理解为一个递增的整数:http://zh.wikipedia.org/wiki/Nonce

key 是申请到的公钥

signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.

 


 
 
  
首先聚币的行情是使用网络爬虫获取的,而说明中给出了一系列的参数,你需要做的就是把这些参数填充上去。
 
如果你只是想要获取行情,那么事情容易很多。
    def real_time_ticker(coin):
url = 'https://www.jubi.com/api/v1/ticker/'
try:
data = requests.post(url, data={'coin': coin}).json()

except Exception ,e:
print e
return data

上面代码展示的时候获取实时的行情。委一和买一的价格,数量,和当前成交的数量,价格。
 按照上面的格式,把参数coin填上去,比如要获取泽塔币, real_time_ticker('zet') 就会返回获取的数据。
{u'sell': u'0.179000', u'volume': 21828245.102822, u'buy': u'0.175010', u'last': u'0.179000', u'vol': 108290769.9171, u'high': u'0.289000', u'low': u'0.119141'}

 
 
所有的private API都需要经过认证, 就是说如果你要进行交易,委托,下单,你就需要使用私钥和公钥,并进行一系列的加密。


每次请求private api 都需要验证签名,发送的参数示例:

$param = array(

amount => 1,

price => 10000,

type => 'buy',

nonce => 141377098123

key => 5zi7w-4mnes-swmc4-egg9b-f2iqw-396z4-g541b

signature => 459c69d25c496765191582d9611028b9974830e9dfafd762854669809290ed82

);

nonce 可以理解为一个递增的整数:http://zh.wikipedia.org/wiki/Nonce

key 是申请到的公钥

signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.


 
 
比如下单:


Trade_add(下单)
Path:/api/v1/trade_add/
Request类型:POST
 
参数
key - API key
signature - signature
nonce - nonce
amount - 购买数量
price - 购买价格
type - 买单或者卖单
coin - 币种简称,例如btc、ltc、xas
id - 挂单ID
result - true(成功), false(失败)
{"result":true, "id":"11"}
 
返回JSON dictionary
id - 挂单ID
result - true(成功), false(失败)
 
返回结果示例:
{"result":true, "id":"11"}
 



首先解决nonce。
 
在维基百科中
在安全工程中,Nonce是一个在加密通信只能使用一次的数字。在认证协议中,它往往是一个随机或伪随机数,以避免重放攻击。Nonce也用于流密码以确保安全。如果需要使用相同的密钥加密一个以上的消息,就需要Nonce来确保不同的消息与该密钥加密的密钥流不同。
 
结合stackoverflow, nonce只是一个12位的随机数。
可以用以下方法获得这个随机数
    def get_nonce(self):
lens=12
return ''.join([str(random.randint(0, 9)) for i in range(lens)])

 聚币中的nonce的位数是12位,所以lens定义为12
 
或者可以直接用时间函数生成:
    def get_nonce_time(self):
lens = 12
curr_stamp = time.time()*100
nonece=int(curr_stamp)
return nonece

 
然后是signature。
signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.

先把私钥进行md5处理
    def getHash(self,s):
m=hashlib.md5()
m.update(s)
return m.hexdigest()

只要把私钥传入函数getHash就可以得到一个md5处理过的字符串。
 
私钥是聚币网给每个用户分配的字符串,是唯一的,这里假设为private_key=123456789吧,具体是多少,在你的聚币网设置里面可以找到。
sha_256key=self.getHash(private_key)
 
按照要求吧 你要post的数据字符串连起来
nonce=self.get_nonce_time
type='buy'
amount='10000'
key='xxxxxxxxxxx‘ #这个是聚币网给你的公钥,同样在设置里头可以找到
price='10' #你要设置的价格为10
coin='zet'
message = "amount=“+amount+”&nonce="+str(nonce)+"&type="+type+"&key="+key+'&price="+price+"&coin"+coin

signature = hmac.new(sha_256key, message, digestmod=hashlib.sha256).digest()

这样获得signature之后,就可以通过签名来进行post操作。

data_wrap={'nonce':nonce,'key':key_value,'signature':signature}

js=requests.post(url,data=data_wrap).json()

 
如果直接按照上面的代码去获取账户相关信息或者去挂单的话,会返回104的签名错误。 经过不断的排查,发现是signature的字符格式的问题。
 
构造一个str转换格式的函数:
    def toHex(self,str):
lst =
for ch in str:
hv = hex(ord(ch)).replace('0x', '')
if len(hv) == 1:
hv = '0' + hv
lst.append(hv)
return reduce(lambda x, y: x + y, lst)
这个函数的作用就是把原来十六进制格式的字符完全转化成十六进制,把前面的0x去掉,不足2位的补全为2位。
把经过处理的signature进行格式转换后,几次提交,终于发现可以获取到用户的账户信息,进行下单,撤单,等操作。
 
 
 
下面是一个获取账户信息的代码段:
    def getAccount(self):
url='https://www.jubi.com/api/v1/balance/'

nonce_value=self.get_nonce_time()
print nonce_value
key_value=self.public_key
private_key=self.private_key

s='nonce='+str(nonce_value)+'&'+'key='+key_value

print s

#signature是签名,是将amount price type nonce key等参数通过'&'字符连接起来通过md5(私钥)为key进行sha256算法加密得到的值.
md5=self.getHash(private_key)
print md5
print type(md5)

msg=bytes(s).encode('utf-8')
key=bytes(md5).encode('utf-8')
signature =hmac.new(key,msg,digestmod=hashlib.sha256).digest()
print signature
print type(signature)
sig=self.toHex(signature)

print sig
data_wrap={'nonce':nonce_value,'key':key_value,'signature':sig}

print data_wrap

data_en=urllib.urlencode(data_wrap)
req=urllib2.Request(url,data=data_en)
resp=urllib2.urlopen(req).read()
print resp


def toHex(self,str):
lst =
for ch in str:
hv = hex(ord(ch)).replace('0x', '')
if len(hv) == 1:
hv = '0' + hv
lst.append(hv)
return reduce(lambda x, y: x + y, lst)

 
以上的代码运行后返回一下账户信息:
{"uid":123456,"nameauth":1,"moflag":1,"asset":,"btc_balance":0,"btc_lock":0,"drk_balance":0,"drk_lock":0,"blk_balance":0,"blk_lock":0,"vrc_balance":0,"vrc_lock":0,"tfc_balance":0,"tfc_lock":0,"jbc_balance":0,"jbc_lock":0,"ltc_balance":0,"ltc_lock":0,"doge_balance":0,"doge_lock":0,"xpm_balance":0,"xpm_lock":0,"ppc_balance":0,"ppc_lock":0,"wdc_balance":0,"wdc_lock":0,"vtc_balance":0,"vtc_lock":0,"max_balance":0,"max_lock":0,"ifc_balance":0,"ifc_lock":0,"zcc_balance":0,"zcc_lock":0,"zet_balance":0,"zet_lock":0,"eac_balance":0,"eac_lock":0,"fz_balance":0,"fz_lock":0,"skt_balance":0,"skt_lock":0,"plc_balance":0,"plc_lock":0,"mtc_balance":0,"mtc_lock":0,"qec_balance":0,"qec_lock":0,"lkc_balance":10,"lkc_lock":0,"met_balance":0,"met_lock":0,"ytc_balance":0,"ytc_lock":0,"hlb_balance":0,"hlb_lock":0,"game_balance":0,"game_lock":0,"rss_balance":0,"rss_lock":0,"rio_balance":0,"rio_lock":0,"ktc_balance":0,"ktc_lock":0,"pgc_balance":0,"pgc_lock":0,"mryc_balance":0,"mryc_lock":0,"eth_balance":0,"eth_lock":0,"etc_balance":0,"etc_lock":0,"dnc_balance":0,"dnc_lock":0,"gooc_balance":0,"gooc_lock":0,"xrp_balance":0,"xrp_lock":0,"nxt_balance":0,"nxt_lock":0,"lsk_balance":0,"lsk_lock":0,"xas_balance":0,"xas_lock":0,"peb_balance":0,"peb_lock":0,"nhgh_balance":0,"nhgh_lock":0,"xsgs_balance":0,"xsgs_lock":0,"ans_balance":0,"ans_lock":0,"bts_balance":0,"bts_lock":0,"cny_balance":0,"cny_lock":0}











 
聚币网个人邀请码:
514330
 
还没注册可以拿去用,对于我而言可以拿到你们交易费用的50%,不过一般交易费除非是超级大户,一般散户都很少。千分之一的交易手续费。
 
欢迎一起讨论:
Email:weigesysu@qq.com

 原创内容,转载请注明出处
http://30daydo.com/article/181 
 

求港股数据获取PYTHON代码

回复

股票李魔佛 回复了问题 • 3 人关注 • 1 个回复 • 1519 次浏览 • 2018-06-07 16:09 • 来自相关话题

为什么使用talib查找K线形态和优矿上查到的不一样?

回复

股票李魔佛 发起了问题 • 1 人关注 • 0 个回复 • 605 次浏览 • 2018-04-09 18:09 • 来自相关话题

如何使用pandas把某些行的数据进行算术处理?

回复

量化交易李魔佛 发起了问题 • 1 人关注 • 0 个回复 • 1349 次浏览 • 2016-07-28 15:35 • 来自相关话题

python量化分析: 股票涨停后该不该卖, 怕砸板还是怕卖飞 ?

量化交易李魔佛 发表了文章 • 0 个评论 • 877 次浏览 • 2018-06-14 19:34 • 来自相关话题

相信大家都有过这样的经验,某个股票忽然直线拉升打到涨停板,然后就会纠结当天要不要卖掉,如果股票没封住,注定会回落,这样会失去部分的利润。 但是又怕卖了后,封死涨停板,然后当天再也买不回来,然后第二天呢,高开就不想去追,或者去追高使得持有该股的成本变高了。
 
那么触及涨停板的个股我们应该继续持有,还是卖掉,还是卖掉做T接回来呢?
接下来用数据说话。【数据使用通联实验室的数据源】
 
首先获取当前市场上所有股票all_stocks = DataAPI.SecTypeRegionRelGet(secID=u"",ticker=u"",typeID=u"",field=u"",pandas="1")
然后获取每一个股票的日k线数据,可以设定一个时间段,我抓取了2012年到今天(2018-06-14)的所有数据,如果是次新股,那么数据就是上市当天到今天的数据。
抓取到的数据包含以下的字段:




点击查看大图 

但是实际用到的字段只有几个, 开盘价,最高价,涨幅,昨天收盘价。
这里我排除了一字板开盘的个股,因为里面含有新股,会导致数据不精确,【后续我会统计,一字板开盘盘中被砸开的概率】,而且数据也排除了ST的个股,因为本人从来不买ST股,所以不会对ST进行统计。fbl =

for code in all_stocks['secID']:
df = DataAPI.MktEqudGet(secID=code,ticker=u"",tradeDate=u"",beginDate=u"20120101",endDate=u"",isOpen="",field=u"",pandas="1")
df['ztj']=map(lambda x:round(x,2),df['preClosePrice']*1.1)
df['chgPct']=df['chgPct']*100

# 非一字板
zt = df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])]
fz= df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])&(df['closePrice']==df['highestPrice'])]
try:
f = len(fz)*1.00/len(zt)*100
fbl.append((code,f))
except Exception,e:
print e
print code
fbl就是封板率的一个列表,包含了每只股票的触及涨停价后封板的概率。 然后对整体的数据取平均值:dx= dict(fbl)
x = np.array(dx.values())
print x.mean()
最后得到的结果是:
64.0866513726

所以保持住涨停的概率还是大一些。所以站在概率大的一边上,触及涨停的时候应该继续持有,会有62.5%会到收盘保持涨停价。
 
(待续)
 
原创文章,转载请注明出处: 
http://30daydo.com/article/331 
  查看全部
相信大家都有过这样的经验,某个股票忽然直线拉升打到涨停板,然后就会纠结当天要不要卖掉,如果股票没封住,注定会回落,这样会失去部分的利润。 但是又怕卖了后,封死涨停板,然后当天再也买不回来,然后第二天呢,高开就不想去追,或者去追高使得持有该股的成本变高了。
 
那么触及涨停板的个股我们应该继续持有,还是卖掉,还是卖掉做T接回来呢?
接下来用数据说话。【数据使用通联实验室的数据源】
 
首先获取当前市场上所有股票
all_stocks = DataAPI.SecTypeRegionRelGet(secID=u"",ticker=u"",typeID=u"",field=u"",pandas="1")

然后获取每一个股票的日k线数据,可以设定一个时间段,我抓取了2012年到今天(2018-06-14)的所有数据,如果是次新股,那么数据就是上市当天到今天的数据。
抓取到的数据包含以下的字段:
cd11.PNG

点击查看大图 

但是实际用到的字段只有几个, 开盘价,最高价,涨幅,昨天收盘价。
这里我排除了一字板开盘的个股,因为里面含有新股,会导致数据不精确,【后续我会统计,一字板开盘盘中被砸开的概率】,而且数据也排除了ST的个股,因为本人从来不买ST股,所以不会对ST进行统计。
fbl = 

for code in all_stocks['secID']:
df = DataAPI.MktEqudGet(secID=code,ticker=u"",tradeDate=u"",beginDate=u"20120101",endDate=u"",isOpen="",field=u"",pandas="1")
df['ztj']=map(lambda x:round(x,2),df['preClosePrice']*1.1)
df['chgPct']=df['chgPct']*100

# 非一字板
zt = df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])]
fz= df[(df['ztj']==df['highestPrice']) & (df['openPrice']!=df['highestPrice'])&(df['closePrice']==df['highestPrice'])]
try:
f = len(fz)*1.00/len(zt)*100
fbl.append((code,f))
except Exception,e:
print e
print code

fbl就是封板率的一个列表,包含了每只股票的触及涨停价后封板的概率。 然后对整体的数据取平均值:
dx= dict(fbl)
x = np.array(dx.values())
print x.mean()

最后得到的结果是:
64.0866513726

所以保持住涨停的概率还是大一些。所以站在概率大的一边上,触及涨停的时候应该继续持有,会有62.5%会到收盘保持涨停价。
 
(待续)
 
原创文章,转载请注明出处: 
http://30daydo.com/article/331 
 

python获取每天的涨停个股数据 和昨天涨停的今天表现

量化交易李魔佛 发表了文章 • 2 个评论 • 1466 次浏览 • 2018-06-02 10:47 • 来自相关话题

python获取每天的涨停个股数据 和昨天涨停的今天表现
 




今日的涨停信息





昨日涨停的今天信息
 
原创文章
转载请注明出处:http://30daydo.com/article/316
  查看全部
python获取每天的涨停个股数据 和昨天涨停的今天表现
 
ztb2_副本_副本_副本.jpg

今日的涨停信息

zrzt1_副本.jpg

昨日涨停的今天信息
 
原创文章
转载请注明出处:http://30daydo.com/article/316
 

正常退出tushare

量化交易李魔佛 发表了文章 • 1 个评论 • 696 次浏览 • 2018-05-07 21:31 • 来自相关话题

tushare最新的api中,很多函数的调用像这样,ts.bar(code,conn=conn), 其中conn=ts.get_api()
查看源码知道ts.get_api() 里面使用了多线程,程序一直在循环等待。 如果按ctrl + c,是无法正常终止tushare在后台的调用,需要使用ts.close_api(conn), 才能终止掉后台的多线程,这个时候程序才能正常退出,释放系统资源。
原创文章
转载请注明出处:http://30daydo.com/article/308
  查看全部
tushare最新的api中,很多函数的调用像这样,ts.bar(code,conn=conn), 其中conn=ts.get_api()
查看源码知道ts.get_api() 里面使用了多线程,程序一直在循环等待。 如果按ctrl + c,是无法正常终止tushare在后台的调用,需要使用ts.close_api(conn), 才能终止掉后台的多线程,这个时候程序才能正常退出,释放系统资源。
原创文章
转载请注明出处:http://30daydo.com/article/308
 

使用优矿获取股市的基本数据 实例操作

量化交易李魔佛 发表了文章 • 1 个评论 • 532 次浏览 • 2018-05-06 22:44 • 来自相关话题

1. 每日行业个股换手率排名
DataAPI.MktRANKInstTrGet

 行业名称,如:传媒,电气设备等,可多值输入,以下为申万28个行业名称:休闲服务,房地产,商业贸易,综合,钢铁,农林牧渔,食品饮料,采掘,电子,国防军工,通信,公用事业,交通运输,轻工制造,计算机,电气设备,家用电器,医药生物,传媒,非银金融,汽车,有色金属,机械设备,建筑材料,化工,纺织服装,银行,建筑装饰,可以是列表,可空
 
实例
 
原创文章
转载请注明出处:http://30daydo.com/article/306
  查看全部
1. 每日行业个股换手率排名
DataAPI.MktRANKInstTrGet

 行业名称,如:传媒,电气设备等,可多值输入,以下为申万28个行业名称:休闲服务,房地产,商业贸易,综合,钢铁,农林牧渔,食品饮料,采掘,电子,国防军工,通信,公用事业,交通运输,轻工制造,计算机,电气设备,家用电器,医药生物,传媒,非银金融,汽车,有色金属,机械设备,建筑材料,化工,纺织服装,银行,建筑装饰,可以是列表,可空
 
实例
 
原创文章
转载请注明出处:http://30daydo.com/article/306
 

原来这样的历史日线数据也可以拿来卖的呀

股票李魔佛 发表了文章 • 3 个评论 • 699 次浏览 • 2018-04-08 22:58 • 来自相关话题

  
原来这样的数据都可以拿去卖的。 确切的体验到知识就是金钱哈。

Screenshot_from_2018-04-08_22-47-21_thunbnail.png

  
原来这样的数据都可以拿去卖的。 确切的体验到知识就是金钱哈。

pandas中resample的how参数“ohlc”

量化交易李魔佛 发表了文章 • 2 个评论 • 1796 次浏览 • 2018-03-25 23:42 • 来自相关话题

这个ohlc对应的是股市中的open,high,low,close这几个价格。专门用于股票市场的分析。
比如我获取得到了一个股票从14年到现在的开盘,收盘,最高,最低等价格,然后我想对数据中的收盘价重新采样,转换成月数据。可以使用resample函数,参数中的how配合 ohlc。
 
获取原始数据:





 
提取收盘价





 
 
重新采样:





 
重新采样后获得的新数据:





 
可以看到现在的index是每个月的结束,而多了几列,close,open,high,low,这4列就是根据每个月的close价格而提取出来的,比如统计一月份的时候,一月份的收盘价会有一个最低和最高,最开始open1月1号和结束close的1月31号的价格。
 
 
原创文章
转载请注明出处:http://30daydo.com/article/288
  查看全部
这个ohlc对应的是股市中的open,high,low,close这几个价格。专门用于股票市场的分析。
比如我获取得到了一个股票从14年到现在的开盘,收盘,最高,最低等价格,然后我想对数据中的收盘价重新采样,转换成月数据。可以使用resample函数,参数中的how配合 ohlc。
 
获取原始数据:

Screenshot_from_2018-03-25_23-28-30.png

 
提取收盘价

Screenshot_from_2018-03-25_23-34-21.png

 
 
重新采样:

Screenshot_from_2018-03-25_23-34-55.png

 
重新采样后获得的新数据:

Screenshot_from_2018-03-25_23-35-25.png

 
可以看到现在的index是每个月的结束,而多了几列,close,open,high,low,这4列就是根据每个月的close价格而提取出来的,比如统计一月份的时候,一月份的收盘价会有一个最低和最高,最开始open1月1号和结束close的1月31号的价格。
 
 
原创文章
转载请注明出处:http://30daydo.com/article/288
 

可转债套利【一】 python找出折价可转债个股

量化交易李魔佛 发表了文章 • 2 个评论 • 3282 次浏览 • 2018-03-16 17:17 • 来自相关话题

关于可转债的定义,可以到https://xueqiu.com/6832369826/103042836 这里科普一下。
 
下面的内容默认你对可转债已经有一定的了解。
 
可转债的价值=正股价格/转股价格 + 利息,忽略可转债的利息,直接用公式 可转债的价值=正股价格/转股价格 计算可转债的价值。
 
如果当前可转债的交易价格(在交易软件上显示的价格)如:




所以万信转债的价格是121.5元,然后万信转债的价值呢? 按照上面的公式,万信转债的正股是万达信息,今天万达信息  (2018-03-16)的股价是





以收盘价为例,17.25。
 
而万信转债的股转价格呢? 这个可以到万信转债F10页面的公告中找到,为13.11元。 所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100, 所以万信转债的内在价值是1.315*100=131.5, 而当前的交易价格为 121.5





 
 
也就是你用121.5元买到一个价值 131.5的商品, 所以相当于打折买到了一个超值的商品,所以当前的万信转债是折价状态。
 
所以本次任务就是要找出可交易的可转债中折价状态的可转债。
 
然后直接上干货。上python代码。#-*-coding=utf-8
'''
可转债监控
'''
import tushare as ts
from setting import get_engine
engine = get_engine('db_bond')
import pandas as pd
import datetime
class ConvertBond():

def __init__(self):
self.conn=ts.get_apis()
self.allBonds=ts.new_cbonds(pause=2)
self.onSellBond=self.allBonds.dropna(subset=['marketprice'])
self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')

def stockPrice(self,code):
stock_df = ts.get_realtime_quotes(code)
price = float(stock_df['price'].values[0])
return price

def dataframe(self):
price_list=[]
for code in self.onSellBond['scode']:
price_list.append(self.stockPrice(code))
self.onSellBond['stock_price']=price_list
self.onSellBond['ratio'] = (
self.onSellBond['marketprice']
/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100
self.onSellBond['Updated']=self.today
self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')

def closed(self):
ts.close_apis(self.conn)

def main():
bond=ConvertBond()
bond.dataframe()
bond.closed()
if __name__=='__main__':
main()







 上面的setting库,把下面的*** 替换成你自己的Mysql用户和密码即可。import os
import MySQLdb
MYSQL_USER = *********
MYSQL_PASSWORD = ********
MYSQL_HOST = *********
MYSQL_PORT = *****

def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine 
上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示:







点击放大
  2018-03-16 可转债表格
 
其中折价率是ratio列。按照ratio列进行排列,只有2个是正,也就是当前市场是只有2只可转债是处于折价状态的,其余的都是溢价状态(价格比内在价值要贵,忽略利息的前提下,如果把4~5%的利息也算进去的话,-3~4%的折价率其实也算小折价吧)
 
目前万信转债折价10个点,宝信转债折价5.8个点。 所以适合低风险投资者建仓。 因为可转债有兜底价格,所以出现亏损的概率很低(除非遇到黑天鹅,公司破产了,像遇到乐视这种PPT独角兽公司,欠债不还的。 但是A股上能够有资格发行可转债的,本身对公司的盈利,分红都有硬性要求)。
 
所以可以保存上面的代码,可以每天运行一次,可以很方便地找出折价的个股,当然也可以在盘中一直监测,因为可转债的价格是实时变化的,一旦遇到大跌,跌到折价状态,你也可以择时入手标的。

原文链接:
http://30daydo.com/article/286
转载请注明出处 查看全部
关于可转债的定义,可以到https://xueqiu.com/6832369826/103042836 这里科普一下。
 
下面的内容默认你对可转债已经有一定的了解。
 
可转债的价值=正股价格/转股价格 + 利息,忽略可转债的利息,直接用公式 可转债的价值=正股价格/转股价格 计算可转债的价值。
 
如果当前可转债的交易价格(在交易软件上显示的价格)如:
wxzz.GIF

所以万信转债的价格是121.5元,然后万信转债的价值呢? 按照上面的公式,万信转债的正股是万达信息,今天万达信息  (2018-03-16)的股价是

万达信息.GIF

以收盘价为例,17.25。
 
而万信转债的股转价格呢? 这个可以到万信转债F10页面的公告中找到,为13.11元。 所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100, 所以万信转债的内在价值是1.315*100=131.5, 而当前的交易价格为 121.5

wxzz.GIF

 
 
也就是你用121.5元买到一个价值 131.5的商品, 所以相当于打折买到了一个超值的商品,所以当前的万信转债是折价状态。
 
所以本次任务就是要找出可交易的可转债中折价状态的可转债。
 
然后直接上干货。上python代码。
#-*-coding=utf-8
'''
可转债监控
'''
import tushare as ts
from setting import get_engine
engine = get_engine('db_bond')
import pandas as pd
import datetime
class ConvertBond():

def __init__(self):
self.conn=ts.get_apis()
self.allBonds=ts.new_cbonds(pause=2)
self.onSellBond=self.allBonds.dropna(subset=['marketprice'])
self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')

def stockPrice(self,code):
stock_df = ts.get_realtime_quotes(code)
price = float(stock_df['price'].values[0])
return price

def dataframe(self):
price_list=[]
for code in self.onSellBond['scode']:
price_list.append(self.stockPrice(code))
self.onSellBond['stock_price']=price_list
self.onSellBond['ratio'] = (
self.onSellBond['marketprice']
/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100
self.onSellBond['Updated']=self.today
self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')

def closed(self):
ts.close_apis(self.conn)

def main():
bond=ConvertBond()
bond.dataframe()
bond.closed()
if __name__=='__main__':
main()







 上面的setting库,把下面的*** 替换成你自己的Mysql用户和密码即可。
import os
import MySQLdb
MYSQL_USER = *********
MYSQL_PASSWORD = ********
MYSQL_HOST = *********
MYSQL_PORT = *****

def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine
 
上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示:


Screenshot_from_2018-03-28_09-14-35.png


点击放大
  2018-03-16 可转债表格
 
其中折价率是ratio列。按照ratio列进行排列,只有2个是正,也就是当前市场是只有2只可转债是处于折价状态的,其余的都是溢价状态(价格比内在价值要贵,忽略利息的前提下,如果把4~5%的利息也算进去的话,-3~4%的折价率其实也算小折价吧)
 
目前万信转债折价10个点,宝信转债折价5.8个点。 所以适合低风险投资者建仓。 因为可转债有兜底价格,所以出现亏损的概率很低(除非遇到黑天鹅,公司破产了,像遇到乐视这种PPT独角兽公司,欠债不还的。 但是A股上能够有资格发行可转债的,本身对公司的盈利,分红都有硬性要求)。
 
所以可以保存上面的代码,可以每天运行一次,可以很方便地找出折价的个股,当然也可以在盘中一直监测,因为可转债的价格是实时变化的,一旦遇到大跌,跌到折价状态,你也可以择时入手标的。

原文链接:
http://30daydo.com/article/286
转载请注明出处

tushare 调用ts.get_apis() 后一直在运行无法退出

量化交易李魔佛 发表了文章 • 0 个评论 • 804 次浏览 • 2018-03-16 00:47 • 来自相关话题

旧版本中运行ts.get_apis()后会一直在后台监听,但是在1.0.5的后续版本中,你可以手工中断这个后台监听,从而让你的程序可以正常退出。
 
conn=ts.get_apis()
......
 
在你的程序退出前,运行
ts.close_apis(conn)
 
这样你的程序就能够正常退出。 查看全部
旧版本中运行ts.get_apis()后会一直在后台监听,但是在1.0.5的后续版本中,你可以手工中断这个后台监听,从而让你的程序可以正常退出。
 
conn=ts.get_apis()
......
 
在你的程序退出前,运行
ts.close_apis(conn)
 
这样你的程序就能够正常退出。

python监测股票出现的规律大单

股票李魔佛 发表了文章 • 2 个评论 • 1162 次浏览 • 2018-02-27 12:03 • 来自相关话题

日期:2018-02-27 11:30
 
首先获取当日的历史分笔数据
code='300527'
df = ts.get_today_ticks(code)
 然后根据成交量进行排序:
df.sort_values(by='volume',ascending=False).head(100)显示前100的成交量。




 
 
从上面的表格可以看到,不断有1500手的卖盘,而且卖出价格比正常的药低3个点,所谓的砸盘。
但是每次砸完了价格又会正常的回来原来的地方。 从分时走势上也可以看到一个个凸起的大单成交量。





 
每次打压完,股价还会正常回到原来的位置。 个人觉得这个是有人在出货,但是不断有人在接货。是不同的两伙人。  查看全部
日期:2018-02-27 11:30
 
首先获取当日的历史分笔数据
code='300527'
df = ts.get_today_ticks(code)

 然后根据成交量进行排序:
df.sort_values(by='volume',ascending=False).head(100)
显示前100的成交量。
华舟应急.GIF

 
 
从上面的表格可以看到,不断有1500手的卖盘,而且卖出价格比正常的药低3个点,所谓的砸盘。
但是每次砸完了价格又会正常的回来原来的地方。 从分时走势上也可以看到一个个凸起的大单成交量。

华舟应急分时.GIF

 
每次打压完,股价还会正常回到原来的位置。 个人觉得这个是有人在出货,但是不断有人在接货。是不同的两伙人。 

python获取股权质押数据

股票李魔佛 发表了文章 • 2 个评论 • 704 次浏览 • 2018-02-09 15:58 • 来自相关话题

<占位,今晚回来更新>
<占位,今晚回来更新>

【量化选股】A股上有哪些东北股(排雷)?

量化交易李魔佛 发表了文章 • 0 个评论 • 738 次浏览 • 2018-01-31 01:09 • 来自相关话题

上一篇文章中写道,东北企业由于本地特色,会存在一定的造假风险,所以需要在选股的时候排除东北的A股上市企业。
 
打开jupyter notebook。然后输入下面的代码:





 
上面可以获得A股上市公司所有区域的分布。果然刘士余上台后,浙江地区的企业一下子超越广东,成为A股最多公司的省份(当然,这里的广东是把深圳给单独分离出去了),浙江有418个上市公司。
 
然后根据条件筛选列area,选出辽宁,吉林,黑龙江的企业。





共有152家上市公司。截止2018-01-30日。
列表太长没有显示完整,贴在附件里面供大家参考(排雷)。
 
原文地址:http://30daydo.com/article/271
转载请注明出处 查看全部
上一篇文章中写道,东北企业由于本地特色,会存在一定的造假风险,所以需要在选股的时候排除东北的A股上市企业。
 
打开jupyter notebook。然后输入下面的代码:

area.GIF

 
上面可以获得A股上市公司所有区域的分布。果然刘士余上台后,浙江地区的企业一下子超越广东,成为A股最多公司的省份(当然,这里的广东是把深圳给单独分离出去了),浙江有418个上市公司。
 
然后根据条件筛选列area,选出辽宁,吉林,黑龙江的企业。

area1.GIF

共有152家上市公司。截止2018-01-30日。
列表太长没有显示完整,贴在附件里面供大家参考(排雷)。
 
原文地址:http://30daydo.com/article/271
转载请注明出处

【量化分析】到底谁在买乐视网?2018年1月26日

股票李魔佛 发表了文章 • 2 个评论 • 937 次浏览 • 2018-01-26 17:02 • 来自相关话题

这是乐视复牌的第三天,连续3个跌停。





 
本来没有持有这一只股票,不过雪球上不时地出现一些文章,根据龙虎榜推测到底谁在接盘。 于是今天收盘,打开jupyter notebook来简单地分析一下。 大家也可以跟着学习一些分析的思路。因为今天的龙虎榜还没出来,等待会龙虎榜出来了可以再比较一下。
 
首先导入今天的分时数据





 
volume列就是我们感兴趣的成交量。单位是手(100股)
 
先计算一下今天的总成交量:






1021800股,额,比不少中小创的小股的成交量还大呢,瘦死的骆驼比马大。
 
去对比一下雪球或者东财的数据,看看数据是否准确。






 
嗯,1.02万手,数据一致。
 
接着我们来看看排序,按照成交量的大小排序,可以看到最大和最小的差别:





 
大单都集中在开盘和收盘阶段(其实开盘和收盘严格来说不算大单,因为同一时刻太多人一起买,所以掺杂在一起,如果把收盘和开盘的数据拿掉,其实真的没多少大单。。。)
 




 
然后剩下的都是些零零散散的1手的成交:

可以统计一下每个单数出现的频率:





 
出现最多的是1手,2手。这个很正常,如果出现较多的是超过100手的大单,那么也说明跌停很快被打开(后续如果有打算冒风险去撸一把乐视翘班的,可以自己写一个检测程序)
 
接着做一些统计:
定义大于100手的为大单。
然后计算100手大单占成交的比例:





 
嗯,有28%的比例呢。
 
然后计算一下小于10手的占成交比例。





有30%的比例。
 
再统计一下中位数和各分位数:





 
中位数是3,说明整个交易中,一半的成交是在等于或小于3手的,而分位数看到,1手的可以排到25%的位置,而8手则排到了75%的位置。
 
结论:
其实在买的都是小散,不知道是乐粉还是赌徒了。
原文地址:
http://30daydo.com/article/267
源码:https://github.com/Rockyzsu/stock/blob/master/levt_notebook.ipynb
  查看全部
这是乐视复牌的第三天,连续3个跌停。

letv.png

 
本来没有持有这一只股票,不过雪球上不时地出现一些文章,根据龙虎榜推测到底谁在接盘。 于是今天收盘,打开jupyter notebook来简单地分析一下。 大家也可以跟着学习一些分析的思路。因为今天的龙虎榜还没出来,等待会龙虎榜出来了可以再比较一下。
 
首先导入今天的分时数据

df.png

 
volume列就是我们感兴趣的成交量。单位是手(100股)
 
先计算一下今天的总成交量:

Snap3.png


1021800股,额,比不少中小创的小股的成交量还大呢,瘦死的骆驼比马大。
 
去对比一下雪球或者东财的数据,看看数据是否准确。


Snap4.png

 
嗯,1.02万手,数据一致。
 
接着我们来看看排序,按照成交量的大小排序,可以看到最大和最小的差别:

Snap5.png

 
大单都集中在开盘和收盘阶段(其实开盘和收盘严格来说不算大单,因为同一时刻太多人一起买,所以掺杂在一起,如果把收盘和开盘的数据拿掉,其实真的没多少大单。。。)
 
Snap6.png

 
然后剩下的都是些零零散散的1手的成交:

可以统计一下每个单数出现的频率:

Snap7.png

 
出现最多的是1手,2手。这个很正常,如果出现较多的是超过100手的大单,那么也说明跌停很快被打开(后续如果有打算冒风险去撸一把乐视翘班的,可以自己写一个检测程序)
 
接着做一些统计:
定义大于100手的为大单。
然后计算100手大单占成交的比例:

Snap8.png

 
嗯,有28%的比例呢。
 
然后计算一下小于10手的占成交比例。

Snap9.png

有30%的比例。
 
再统计一下中位数和各分位数:

Snap11.png

 
中位数是3,说明整个交易中,一半的成交是在等于或小于3手的,而分位数看到,1手的可以排到25%的位置,而8手则排到了75%的位置。
 
结论:
其实在买的都是小散,不知道是乐粉还是赌徒了。
原文地址:
http://30daydo.com/article/267
源码:https://github.com/Rockyzsu/stock/blob/master/levt_notebook.ipynb
 

python获取A股上市公司的盈利能力

量化交易李魔佛 发表了文章 • 0 个评论 • 1136 次浏览 • 2018-01-04 16:09 • 来自相关话题

利用tushare库,可以很方便的获取A股上市公司的基本面信息。
比如企业的盈利能力。
 import tushare as ts
#获取2017年第3季度的盈利能力数据
ts.get_profit_data(2017,3)返回的结果:
 
按年度、季度获取盈利能力数据,结果返回的数据属性说明如下:
code,代码 
name,名称 
roe,净资产收益率(%)
 net_profit_ratio,净利率(%) 
gross_profit_rate,毛利率(%) 
net_profits,净利润(百万元)  #这里的官网信息有误,单位应该是百万
esp,每股收益 
business_income,营业收入(百万元) 
bips,每股主营业务收入(元)
 
例如返回如下结果:
 
    code   name    roe  net_profit_ratio  gross_profit_rate  net_profits  \
  000717   韶钢松山  79.22              9.44            14.1042    1750.2624
  600793   宜宾纸业  65.40             13.31             7.9084     100.6484
  600306    商业城  63.19             18.55            17.8601     114.9175
  000526  *ST紫学  61.03              2.78            31.1212      63.6477
  600768   宁波富邦  57.83             14.95             2.7349      88.3171
 
原创,转载请注明:
http://30daydo.com/article/260
  查看全部
利用tushare库,可以很方便的获取A股上市公司的基本面信息。
比如企业的盈利能力。
 
import tushare as ts
#获取2017年第3季度的盈利能力数据
ts.get_profit_data(2017,3)
返回的结果:
 
按年度、季度获取盈利能力数据,结果返回的数据属性说明如下:
code,代码 
name,名称 
roe,净资产收益率(%)
 net_profit_ratio,净利率(%) 
gross_profit_rate,毛利率(%) 
net_profits,净利润(百万元)  #这里的官网信息有误,单位应该是百万
esp,每股收益 
business_income,营业收入(百万元) 
bips,每股主营业务收入(元)
 
例如返回如下结果:
 
    code   name    roe  net_profit_ratio  gross_profit_rate  net_profits  \
  000717   韶钢松山  79.22              9.44            14.1042    1750.2624
  600793   宜宾纸业  65.40             13.31             7.9084     100.6484
  600306    商业城  63.19             18.55            17.8601     114.9175
  000526  *ST紫学  61.03              2.78            31.1212      63.6477
  600768   宁波富邦  57.83             14.95             2.7349      88.3171
 
原创,转载请注明:
http://30daydo.com/article/260
 

python获取股票年涨跌幅排名

量化交易李魔佛 发表了文章 • 4 个评论 • 1679 次浏览 • 2017-12-30 23:11 • 来自相关话题

2017还剩一天就结束了,而A股在昨天已经收官了。 对于大部分投资者来说,这一年能跑赢指数已经很厉害的了,因为指数被权重股拉的失真了,上证指数的分时白线和黄线经常出现张开的大口,白线在上,黄线在下。
 
作为年终回顾,首先看看A股市场2017的总体涨跌幅排名。
 
下面函数是用来获取个股某个时间段的涨跌幅。code是股票代码,start为开始时间段,end为结束时间段。def profit(code,start,end):
try:
df=ts.get_k_data(code,start=start,end=end)
except Exception,e:
print e
return None
try:
p=(df['close'].iloc[-1]-df['close'].iloc[0])/df['close'].iloc[0]*100.00
except Exception,e:
print e
return None
return round(p,2)
如果要获取华大基因的2017年涨幅,可以使用profit('300678','2016-12-31','2017-12-31')
需要注意的是,需要添加一个except的异常处理,因为部分个股停牌时间超过一年,所以该股的收盘价都是空的,这种情况就返回一个None值,在dataframe里就是NaN。
 
剩下了的就是枚举所有A股的个股代码了,然后把遍历所有代码,调用profit函数即可。def price_change():
basic=ts.get_stock_basics()
pro=

for code in basic.index.values:
print code
p=profit(code,'2016-12-31','2017-12-31')
pro.append(p)
basic['price_change']=pro
basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')
结果保存到2017_all_price_change.xls中,里面有个股的基本信息,还追加了一列2017年的涨跌幅,price_change
 
最后我们把price_change按照从高到低进行排序。 看看哪些个股排名靠前。def analysis():
df=pd.read_excel('2017_all_price_change.xls',encoding='gbk')
df=df.sort_values(by='price_change',ascending=False)
df.to_excel('2017-year.xls',encoding='gbk')
最终保存的文件为2017-year.xls,当然你也可以保存到mysql的数据库当中。engine=get_engine('stock')
df.to_sql('2017years',engine)

其中get_engine() 函数如下定义:def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine
只需要把你的mysql数据库的用户名密码等变量加上去就可以了。
 
最终的结果如下:






点击查看大图 

附件是导出来的excel格式的数据,你们可以拿去参考。

下一篇我们来学习统计个股的信息,比如哪类股涨得好,哪类股具有相关性,哪类股和大盘走向类似等等。
 
原文链接:http://30daydo.com/article/258
转载请注明出处
 
附件

2017-year.zip


  查看全部
2017还剩一天就结束了,而A股在昨天已经收官了。 对于大部分投资者来说,这一年能跑赢指数已经很厉害的了,因为指数被权重股拉的失真了,上证指数的分时白线和黄线经常出现张开的大口,白线在上,黄线在下。
 
作为年终回顾,首先看看A股市场2017的总体涨跌幅排名。
 
下面函数是用来获取个股某个时间段的涨跌幅。code是股票代码,start为开始时间段,end为结束时间段。
def profit(code,start,end):
try:
df=ts.get_k_data(code,start=start,end=end)
except Exception,e:
print e
return None
try:
p=(df['close'].iloc[-1]-df['close'].iloc[0])/df['close'].iloc[0]*100.00
except Exception,e:
print e
return None
return round(p,2)

如果要获取华大基因的2017年涨幅,可以使用
profit('300678','2016-12-31','2017-12-31')

需要注意的是,需要添加一个except的异常处理,因为部分个股停牌时间超过一年,所以该股的收盘价都是空的,这种情况就返回一个None值,在dataframe里就是NaN。
 
剩下了的就是枚举所有A股的个股代码了,然后把遍历所有代码,调用profit函数即可。
def price_change():
basic=ts.get_stock_basics()
pro=

for code in basic.index.values:
print code
p=profit(code,'2016-12-31','2017-12-31')
pro.append(p)
basic['price_change']=pro
basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')

结果保存到2017_all_price_change.xls中,里面有个股的基本信息,还追加了一列2017年的涨跌幅,price_change
 
最后我们把price_change按照从高到低进行排序。 看看哪些个股排名靠前。
def analysis():
df=pd.read_excel('2017_all_price_change.xls',encoding='gbk')
df=df.sort_values(by='price_change',ascending=False)
df.to_excel('2017-year.xls',encoding='gbk')

最终保存的文件为2017-year.xls,当然你也可以保存到mysql的数据库当中。
engine=get_engine('stock')
df.to_sql('2017years',engine)

其中get_engine() 函数如下定义:
def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine

只需要把你的mysql数据库的用户名密码等变量加上去就可以了。
 
最终的结果如下:


2017-stock_副本.png

点击查看大图 

附件是导出来的excel格式的数据,你们可以拿去参考。

下一篇我们来学习统计个股的信息,比如哪类股涨得好,哪类股具有相关性,哪类股和大盘走向类似等等。
 
原文链接:http://30daydo.com/article/258
转载请注明出处
 
附件

 

dataframe reindex和reset_index区别

量化交易李魔佛 发表了文章 • 0 个评论 • 5511 次浏览 • 2017-12-30 15:58 • 来自相关话题

reset_index的作用是重新设置dataframe的index,范围为0~len(df)。 df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2

df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result 
上面代码把df和df2合并为一个result,但是result的index是乱的。





 
那么执行result2= result.reset_index()
得到如下的result2: (默认只是返回一个copy,原来的result没有发生改变,所以需要副本赋值给result2)





可以看到,原来的一列index现在变成了columns之一,新的index为[0,1,2,3,4,5]
如果添加参数 reset_index(drop=True) 那么原index会被丢弃,不会显示为一个新列。result2 = result.reset_index(drop=True)



 
reindex的作用是按照原有的列进行重新生成一个新的df。
 
还是使用上面的代码
result目前是df和df2的合并序列。
如下:




 
可以看到index为[0,1,2,3,4,0]
执行 
result3 = result.reindex(columns=['A','C'])




 
可以看到,原index并没有发生改变,而类变成了A和C,因为C是不存在的,所以使用了NaB填充,这个值的内容可以自己填充,可以改为默认填充0或者任意你想要的数据。

原文链接:http://30daydo.com/article/257 
欢迎转载,注明出处
  查看全部
reset_index的作用是重新设置dataframe的index,范围为0~len(df)。
    df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2

df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result
 
上面代码把df和df2合并为一个result,但是result的index是乱的。

df4.PNG

 
那么执行
result2= result.reset_index()

得到如下的result2: (默认只是返回一个copy,原来的result没有发生改变,所以需要副本赋值给result2)

df5.PNG

可以看到,原来的一列index现在变成了columns之一,新的index为[0,1,2,3,4,5]
如果添加参数 reset_index(drop=True) 那么原index会被丢弃,不会显示为一个新列。
result2 = result.reset_index(drop=True)
df6.PNG

 
reindex的作用是按照原有的列进行重新生成一个新的df。
 
还是使用上面的代码
result目前是df和df2的合并序列。
如下:
df7.PNG

 
可以看到index为[0,1,2,3,4,0]
执行 
result3 = result.reindex(columns=['A','C'])

df8.PNG

 
可以看到,原index并没有发生改变,而类变成了A和C,因为C是不存在的,所以使用了NaB填充,这个值的内容可以自己填充,可以改为默认填充0或者任意你想要的数据。

原文链接:http://30daydo.com/article/257 
欢迎转载,注明出处
 

dataframe的index索引是否可以重复

量化交易李魔佛 发表了文章 • 0 个评论 • 1512 次浏览 • 2017-12-30 15:10 • 来自相关话题

答案是肯定的。
  df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2输出如下:
df1





df2




 
然后进行合并: df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result
合并后的结果:





 
合并后的index是[0,1,2,3,4,0] 所以index集合是一个类似list的结构,而非set结构,允许重复数据的存在。
 
原文链接:http://30daydo.com/article/256 
转载请注明
 
  查看全部
答案是肯定的。
 
    df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print 'df\n', df
print 'df2\n', df2
输出如下:
df1
df.PNG


df2
df2.PNG

 
然后进行合并:
    df_x = [df, df2]
result = pd.concat(df_x)
print 'first result\n', result

合并后的结果:

dfx.PNG

 
合并后的index是[0,1,2,3,4,0] 所以index集合是一个类似list的结构,而非set结构,允许重复数据的存在。
 
原文链接:http://30daydo.com/article/256 
转载请注明
 
 

tushare使用get_stock_basic()保存为excel会因为乱码出错而无法保存

量化交易李魔佛 发表了文章 • 0 个评论 • 932 次浏览 • 2017-12-30 13:11 • 来自相关话题

代码如下:
basic=ts.get_stock_basics()

print basic.info()
print basic.head(10)

basic.to_excel('basic2017.xls',encoding='gbk')
运行后会出错:

'ascii' codec can't decode byte 0xe4 in position 0: ordinal not in range(128)
 
很明显的是编问题。 
 
然后尝试使用解决编码的步骤。
1. reload(sys) 设置default为utf-8: 失败
2. to_excel('stock.xls',encoding='gbk') : 失败,encoding参数换了几个都是失败,utf-8,gb2312,cp1252
 
最后解决的办法是,先把df保存为csv,然后再从csv从读取出来,然后再存储为excel。 整个过程的encoding参数都是用'gbk'.
basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')
  查看全部
代码如下:
    basic=ts.get_stock_basics()

print basic.info()
print basic.head(10)

basic.to_excel('basic2017.xls',encoding='gbk')

运行后会出错:

'ascii' codec can't decode byte 0xe4 in position 0: ordinal not in range(128)
 
很明显的是编问题。 
 
然后尝试使用解决编码的步骤。
1. reload(sys) 设置default为utf-8: 失败
2. to_excel('stock.xls',encoding='gbk') : 失败,encoding参数换了几个都是失败,utf-8,gb2312,cp1252
 
最后解决的办法是,先把df保存为csv,然后再从csv从读取出来,然后再存储为excel。 整个过程的encoding参数都是用'gbk'.
    basic.to_csv('2017_all_price_change.xls',encoding='gbk')
df=pd.read_csv('2017_all_price_change.xls',encoding='gbk')
df.to_excel('2017_all_price_change.xls',encoding='gbk')

 

数字货币量化揭秘-简单暴力但高效的高频交易机器人

量化交易littleDream 发表了文章 • 1 个评论 • 1295 次浏览 • 2017-12-05 16:23 • 来自相关话题

策略分享地址:https://www.botvs.com/strategy/1088

这个策略是我做虚拟货币以来的主要策略,后面经过不断完善和修改,复杂了很多,但主要思想并没有改变,分享的这个版本是无明显bug的 最初版本,最为简单清晰,没有仓位管理,每次交易都是满仓,没有卡死后重启等等,但也足够说明问题。

 策略从2014年8月运行,直到今年年初交易所收手续费。期间运行的还算很好,亏损的时间很少。资金从最初的200元跑到了80比特币。具体的过程可以看[小草的新浪博客](小草_新浪博客)里[虚拟货币自动化交易之路](虚拟货币自动化交易之路(五)_小草_新浪博客)系列文章。
 


下图是总资产折合币的曲线:



为什么分享这个策略

1.交易所收取手续费后,几乎杀死了所有的高频策略,我的也不例外。但策略改改也许还能用,大家可以研究一下。

2.好久没有分享东西了,这篇文章早就想写了。

3.和大家共同交流学习。




策略的原理

这个策略原理极为简单,可以理解为准高频的做市策略,各位看了之后可能想打人,这都能赚钱,当时几乎谁都能写出来。我开始也没预料到它能这么有效,可见心中有想法要赶紧付出实践,说不一定有意外之喜。在比特币机器人初兴的2014年,写出赚钱的策略太容易了。

和所有的高频策略一样,本策略也是基于orderbook,下图就是一个典型的比特币交易所的订单分布,



可以看到左侧是买单,显示了不同价格的挂单数量,右侧是卖单。可以想象如果一个人要买入比特币,如果不想挂单等待的话,只能选择吃单,如果他的单子比较多,会使得卖单挂单大量成交,对价格造成冲击,但是这种冲击一般不会一直持续,还有人想吃单卖出,价格在极短时间很可能还会恢复,反过来理解有人要卖币也类似。

以图中的挂单为例,如果要直接买入5个币,那么价格会达到10377,在这时如果有人要直接卖出5个币,价格会达到10348,这个空间就是利润空间.策略会在稍低于10377的价格挂单,如10376.99,同时会以稍高于10348的价格买入,如10348.01,这是如果刚才的情况发生了,显然就会赚到其中的差价。虽然不会每次都如此完美,但在概率的作用下,赚钱的几率实际高得惊人。

以现在策略的参数讲解一下具体操作,这个参数当然无法使用了,仅作一个说明。它会向上寻找累计卖挂单量为8个币的价格,这里是10377,那么此时的卖价就是这个价格减去0.01(减去多少可以是随机的),同理向下寻找累计买挂单为8个币,这里是10348,那么此时的卖价就是10348.01,此时买卖价的差价是10376.99-10348.01=28.98,大于策略预设的差价1.5,就以这两个价格挂单等待成交,如果价差小于1.5,也会找一个价格进行挂单,如盘口价格加减10,等待捡漏(更合适的应该是继续往下找跟多的深度)。




进一步的说明

1. 没有钱或币了怎么办?

这种情况在我的钱较少是十分普遍,大多数时候只挂一边的单子,但不是大问题。其实可以加入币钱平衡的逻辑,但在平衡的过程难免产生损失,毕竟每一次的成交都是概率的垂青,我选择保持单边等待成交,当然这样也浪费了另一边的成交机会。

2. 仓位是如何管理的?

刚开始都是满仓买入卖出,后来根据不同的参数分为不同的组,不会一次完全成交。

3. 没有止损吗?

策略有完整的买卖挂单的逻辑,我认为不需要止损(可以讨论),还有就是概率的垂青,成交就是机会,止损可惜了。

4. 如何调整为赚币的策略?

此时的参数是对称的,即向上8个币的累计卖单,向下8个币的累计买单,稍微不平衡一下,比如向上改为15个币的累计卖单,使得卖币机会更难得,有更大的几率会以更低的价格接回来,这样就会赚币,反过来就赚钱。实际上前期策略如此有效,币和钱都是增加的。




代码讲解

完整的代码可以见我在http://www.botvs.com得策略分享,这里只讲解核心逻辑函数。在没有改动的情况下,在botvs自带的模拟盘竟然运转完全正常,这是一个3年多前的策略,平台还支持到现在,太让人感动了。

首先是获取买卖价函数GetPrice(),需要获取订单深度信息,注意不同平台的订单深度信息长度不同,以及即使遍历了所有订单仍然没有所需要的量的情况(在后期许多0.01的网格挂单会导致这种情况),调用是GetPrice('Buy')就是获取买价。
 
function GetPrice(Type) {
//_C()是平台的容错函数
var depth=_C(exchange.GetDepth);
var amountBids=0;
var amountAsks=0;
//计算买价,获取累计深度达到预设的价格
if(Type=="Buy"){
for(var i=0;i<20;i++){
amountBids+=depth.Bids[i].Amount;
//参数floatamountbuy是预设的累计深度
if (amountBids>floatamountbuy){
//稍微加0.01,使得订单排在前面
return depth.Bids[i].Price+0.01;}
}
}
//同理计算卖价
if(Type=="Sell"){
for(var j=0; j<20; j++){
amountAsks+=depth.Asks[j].Amount;
if (amountAsks>floatamountsell){
return depth.Asks[j].Price-0.01;}
}
}
//遍历了全部深度仍未满足需求,就返回一个价格,以免出现bug
return depth.Asks[0].Price
}

// 每个循环的主函数onTick(),这里定的循环时间3.5s,每次循环都会把原来的单子撤销,重新挂单,越简单越不会遇到bug.

function onTick() {
var buyPrice = GetPrice("Buy");
var sellPrice= GetPrice("Sell");
//diffprice是预设差价,买卖价差如果小于预设差价,就会挂一个相对更深的价格
if ((sellPrice - buyPrice) <= diffprice){
buyPrice-=10;
sellPrice+=10;}
//把原有的单子全部撤销,实际上经常出现新的价格和已挂单价格相同的情况,此时不需要撤销
CancelPendingOrders()
//获取账户信息,确定目前账户存在多少钱和多少币
var account=_C(exchange.GetAccount);
//可买的比特币量,_N()是平台的精度函数
var amountBuy = _N((account.Balance / buyPrice-0.1),2);
//可卖的比特币量,注意到没有仓位的限制,有多少就买卖多少,因为我当时的钱很少
var amountSell = _N((account.Stocks),2);
if (amountSell > 0.02) {
exchange.Sell(sellPrice,amountSell);}
if (amountBuy > 0.02) {
exchange.Buy(buyPrice, amountBuy);}
//休眠,进入下一轮循环
Sleep(sleeptime);
}


尾巴

整个程序也就40多行,看上去十分简单,但当时也花了我一个多星期,这还是在botvs平台上情况下。最大的优势还是起步早,在2014年,市场上以搬砖为主,网格和抢盘口的高频也不多,使得策略如鱼得水,后来竞争不可避免越来越激烈,我的钱也越来越多,面临的挑战很多,每隔一段时间都要进行较大的改动来应对,但总体还算顺利。在交易平台不收取手续费的情况下,是程序化交易的天堂,散户因为不收手续费跟倾向于操作,为高频和套利提供了空间,这一切也基本随着动辄0.1-0.2%的双向手续费终结了,不仅是自己被收费的问题,而是整个市场活跃度下降。

但不需要高频的量化策略任然有很大的空间。

作者 小草 查看全部
策略分享地址:https://www.botvs.com/strategy/1088


这个策略是我做虚拟货币以来的主要策略,后面经过不断完善和修改,复杂了很多,但主要思想并没有改变,分享的这个版本是无明显bug的 最初版本,最为简单清晰,没有仓位管理,每次交易都是满仓,没有卡死后重启等等,但也足够说明问题。


 策略从2014年8月运行,直到今年年初交易所收手续费。期间运行的还算很好,亏损的时间很少。资金从最初的200元跑到了80比特币。具体的过程可以看[小草的新浪博客](小草_新浪博客)里[虚拟货币自动化交易之路](虚拟货币自动化交易之路(五)_小草_新浪博客)系列文章。
 


下图是总资产折合币的曲线:



为什么分享这个策略

1.交易所收取手续费后,几乎杀死了所有的高频策略,我的也不例外。但策略改改也许还能用,大家可以研究一下。

2.好久没有分享东西了,这篇文章早就想写了。

3.和大家共同交流学习。




策略的原理

这个策略原理极为简单,可以理解为准高频的做市策略,各位看了之后可能想打人,这都能赚钱,当时几乎谁都能写出来。我开始也没预料到它能这么有效,可见心中有想法要赶紧付出实践,说不一定有意外之喜。在比特币机器人初兴的2014年,写出赚钱的策略太容易了。

和所有的高频策略一样,本策略也是基于orderbook,下图就是一个典型的比特币交易所的订单分布,



可以看到左侧是买单,显示了不同价格的挂单数量,右侧是卖单。可以想象如果一个人要买入比特币,如果不想挂单等待的话,只能选择吃单,如果他的单子比较多,会使得卖单挂单大量成交,对价格造成冲击,但是这种冲击一般不会一直持续,还有人想吃单卖出,价格在极短时间很可能还会恢复,反过来理解有人要卖币也类似。

以图中的挂单为例,如果要直接买入5个币,那么价格会达到10377,在这时如果有人要直接卖出5个币,价格会达到10348,这个空间就是利润空间.策略会在稍低于10377的价格挂单,如10376.99,同时会以稍高于10348的价格买入,如10348.01,这是如果刚才的情况发生了,显然就会赚到其中的差价。虽然不会每次都如此完美,但在概率的作用下,赚钱的几率实际高得惊人。

以现在策略的参数讲解一下具体操作,这个参数当然无法使用了,仅作一个说明。它会向上寻找累计卖挂单量为8个币的价格,这里是10377,那么此时的卖价就是这个价格减去0.01(减去多少可以是随机的),同理向下寻找累计买挂单为8个币,这里是10348,那么此时的卖价就是10348.01,此时买卖价的差价是10376.99-10348.01=28.98,大于策略预设的差价1.5,就以这两个价格挂单等待成交,如果价差小于1.5,也会找一个价格进行挂单,如盘口价格加减10,等待捡漏(更合适的应该是继续往下找跟多的深度)。




进一步的说明

1. 没有钱或币了怎么办?

这种情况在我的钱较少是十分普遍,大多数时候只挂一边的单子,但不是大问题。其实可以加入币钱平衡的逻辑,但在平衡的过程难免产生损失,毕竟每一次的成交都是概率的垂青,我选择保持单边等待成交,当然这样也浪费了另一边的成交机会。

2. 仓位是如何管理的?

刚开始都是满仓买入卖出,后来根据不同的参数分为不同的组,不会一次完全成交。

3. 没有止损吗?

策略有完整的买卖挂单的逻辑,我认为不需要止损(可以讨论),还有就是概率的垂青,成交就是机会,止损可惜了。

4. 如何调整为赚币的策略?

此时的参数是对称的,即向上8个币的累计卖单,向下8个币的累计买单,稍微不平衡一下,比如向上改为15个币的累计卖单,使得卖币机会更难得,有更大的几率会以更低的价格接回来,这样就会赚币,反过来就赚钱。实际上前期策略如此有效,币和钱都是增加的。




代码讲解

完整的代码可以见我在http://www.botvs.com得策略分享,这里只讲解核心逻辑函数。在没有改动的情况下,在botvs自带的模拟盘竟然运转完全正常,这是一个3年多前的策略,平台还支持到现在,太让人感动了。

首先是获取买卖价函数GetPrice(),需要获取订单深度信息,注意不同平台的订单深度信息长度不同,以及即使遍历了所有订单仍然没有所需要的量的情况(在后期许多0.01的网格挂单会导致这种情况),调用是GetPrice('Buy')就是获取买价。
 
function GetPrice(Type) {
//_C()是平台的容错函数
var depth=_C(exchange.GetDepth);
var amountBids=0;
var amountAsks=0;
//计算买价,获取累计深度达到预设的价格
if(Type=="Buy"){
for(var i=0;i<20;i++){
amountBids+=depth.Bids[i].Amount;
//参数floatamountbuy是预设的累计深度
if (amountBids>floatamountbuy){
//稍微加0.01,使得订单排在前面
return depth.Bids[i].Price+0.01;}
}
}
//同理计算卖价
if(Type=="Sell"){
for(var j=0; j<20; j++){
amountAsks+=depth.Asks[j].Amount;
if (amountAsks>floatamountsell){
return depth.Asks[j].Price-0.01;}
}
}
//遍历了全部深度仍未满足需求,就返回一个价格,以免出现bug
return depth.Asks[0].Price
}

// 每个循环的主函数onTick(),这里定的循环时间3.5s,每次循环都会把原来的单子撤销,重新挂单,越简单越不会遇到bug.

function onTick() {
var buyPrice = GetPrice("Buy");
var sellPrice= GetPrice("Sell");
//diffprice是预设差价,买卖价差如果小于预设差价,就会挂一个相对更深的价格
if ((sellPrice - buyPrice) <= diffprice){
buyPrice-=10;
sellPrice+=10;}
//把原有的单子全部撤销,实际上经常出现新的价格和已挂单价格相同的情况,此时不需要撤销
CancelPendingOrders()
//获取账户信息,确定目前账户存在多少钱和多少币
var account=_C(exchange.GetAccount);
//可买的比特币量,_N()是平台的精度函数
var amountBuy = _N((account.Balance / buyPrice-0.1),2);
//可卖的比特币量,注意到没有仓位的限制,有多少就买卖多少,因为我当时的钱很少
var amountSell = _N((account.Stocks),2);
if (amountSell > 0.02) {
exchange.Sell(sellPrice,amountSell);}
if (amountBuy > 0.02) {
exchange.Buy(buyPrice, amountBuy);}
//休眠,进入下一轮循环
Sleep(sleeptime);
}



尾巴

整个程序也就40多行,看上去十分简单,但当时也花了我一个多星期,这还是在botvs平台上情况下。最大的优势还是起步早,在2014年,市场上以搬砖为主,网格和抢盘口的高频也不多,使得策略如鱼得水,后来竞争不可避免越来越激烈,我的钱也越来越多,面临的挑战很多,每隔一段时间都要进行较大的改动来应对,但总体还算顺利。在交易平台不收取手续费的情况下,是程序化交易的天堂,散户因为不收手续费跟倾向于操作,为高频和套利提供了空间,这一切也基本随着动辄0.1-0.2%的双向手续费终结了,不仅是自己被收费的问题,而是整个市场活跃度下降。

但不需要高频的量化策略任然有很大的空间。

作者 小草

TypeError: reduction operation 'argmin' not allowed for this dtype

量化交易李魔佛 发表了文章 • 0 个评论 • 3002 次浏览 • 2017-11-19 18:48 • 来自相关话题

使用pd.read_sql() 方法把Mysql的数据库转为dataframe后,使用 df['low'].idxmin() 或者df['low'].argmin() 方法是会出现这个错误。
 
date = date + '-01-01'
cmd = 'select * from `{}` where datetime > \'{}\''.format(code, date)

try:
df = pd.read_sql(cmd, history_engine,index_col='index')
except Exception,e:
print e
return None

# 不知道为啥,这里的类型发生改变
idx= df['low'].idxmin() 
 
TypeError: reduction operation 'argmin' not allowed for this dtype
 
把df的每列数据类型打印出来看看。
 
print df.dtypes
 
datetime datetime64[ns]
code object
name object
open object
close object
high object
low object
vol float64
amount float64
dtype: object
晕,居然把low这些float类型全部转为了object,所以解决办法就是把这些列的数据转为float64.
 
df['low']=df['low'].astype('float64')
这样之后,问题就解决了。
  查看全部
使用pd.read_sql() 方法把Mysql的数据库转为dataframe后,使用 df['low'].idxmin() 或者df['low'].argmin() 方法是会出现这个错误。
 
date = date + '-01-01'
cmd = 'select * from `{}` where datetime > \'{}\''.format(code, date)

try:
df = pd.read_sql(cmd, history_engine,index_col='index')
except Exception,e:
print e
return None

# 不知道为啥,这里的类型发生改变
idx= df['low'].idxmin()
 
 
TypeError: reduction operation 'argmin' not allowed for this dtype
 
把df的每列数据类型打印出来看看。
 
print df.dtypes
 
datetime    datetime64[ns]
code object
name object
open object
close object
high object
low object
vol float64
amount float64
dtype: object

晕,居然把low这些float类型全部转为了object,所以解决办法就是把这些列的数据转为float64.
 
df['low']=df['low'].astype('float64')

这样之后,问题就解决了。
 

监控聚币网行情 并实时发送到微信

量化交易李魔佛 发表了文章 • 1 个评论 • 3812 次浏览 • 2017-05-29 17:38 • 来自相关话题

最近由于好友推荐我入坑了国内的山寨币,所以顺便研究了下聚币网的API。 不过网页版的聚币网和手机版的做的不好,而且因为是7x24 小时交易,自己没有那么多的精力盯盘,所以写了python代码进行监控。




# -*-coding=utf-8-*-
__author__ = 'Rocky'
'''
http://30daydo.com
Contact: weigesysu@qq.com
'''
import random
import hashlib
import hmac,time
import smtplib
from email.mime.text import MIMEText
from email import Utils
import threading
import requests,datetime,itchat

from toolkit import Toolkit


class Jubi_web():
def __init__(self, send=None):
cfg = Toolkit.getUserData('data.cfg')
self.public_key = cfg['public_key']
self.private_key = cfg['private_key']
self.send=send
from_mail = cfg['from_mail']
password = cfg['password']
to_mail = cfg['to_mail']
smtp_server = 'smtp.qq.com'

self.server = smtp_server
self.username = from_mail.split("@")[0]
self.from_mail = from_mail
self.password = password
self.to_mail = to_mail
self.coin_list=['IFC','DOGE','EAC','DNC','MET','ZET','SKT','YTC','PLC','LKC',
'JBC','MRYC','GOOC','QEC','PEB','XRP','NXT','WDC','MAX','ZCC',
'HLB','RSS','PGC','RIO','XAS','TFC','BLK','FZ','ANS','XPM','VTC',
'KTC','VRC','XSGS','LSK','PPC','ETC','GAME','LTC','ETH','BTC']
# 初始化邮箱设置读取需要股票信息
# 这样子只登陆一次
if self.send == 'msn':

try:
self.smtp = smtplib.SMTP_SSL(port=465)
self.smtp.connect(self.server)
self.smtp.login(self.username, self.password)
except smtplib.SMTPException, e:
print e
return 0

if send=='wechat':
self.w_name=u'xxxxx'

itchat.auto_login(hotReload=True)
account=itchat.get_friends(self.w_name)


def send_wechat(self,name,content):
w_content=name+' '+content
itchat.send(w_content,toUserName=self.toName)
time.sleep(1)
itchat.send(w_content,toUserName='filehelper')


def send_text(self, name, content):

subject = '%s' % name
self.msg = MIMEText(content, 'plain', 'utf-8')
self.msg['to'] = self.to_mail
self.msg['from'] = self.from_mail
self.msg['Subject'] = subject
self.msg['Date'] = Utils.formatdate(localtime=1)
try:
self.smtp.sendmail(self.msg['from'], self.msg['to'], self.msg.as_string())
self.smtp.quit()
print "sent"
except smtplib.SMTPException, e:
print e
return 0

def warming(self, coin, up_price, down_price):
url = 'https://www.jubi.com/api/v1/ticker/'
while 1:
time.sleep(5)
try:
data = requests.post(url, data={'coin': coin}).json()
except Exception,e:
print e
print "time out. Retry"
time.sleep(15)
continue

current = float(data['last'])
if current >= up_price:
print "Up to ", up_price
print "current price ",current

if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))

time.sleep(1200)
if current <= down_price:
print "Down to ", down_price
print "current price ",current
if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))
time.sleep(1200)
#上面的内容尽量不用修改。


def getContent(self):
url = 'https://www.jubi.com/api/v1/trade_list'
params_data = {'key': 'x', 'signature': 'x'}
s = requests.get(url=url, params=params_data)

def getHash(self, s):
m = hashlib.md5()
m.update(s)
return m.hexdigest()

def sha_convert(self, s):
return hashlib.sha256(self.getHash(s)).hexdigest()

def get_nonce(self):
lens = 12
return ''.join([str(random.randint(0, 9)) for i in range(lens)])

def get_signiture(self):
url = 'xxxxxxxxx'
coin = 'zet'
nonce = self.get_nonce()

# sha=self.sha_convert(private_key)
md5 = self.getHash(self.private_key)
message = 'nonce=' + nonce + '&' + 'key=' + self.public_key
# print message
signature = hmac.new(md5, message, digestmod=hashlib.sha256).digest()
# print signature

# req=requests.post(url,data={'signature':signature,'key':public_key,'nonce':nonce,'coin':'zet'})
req = requests.post(url, data={'coin': coin})
print req.status_code
print req.text

def real_time_ticker(self, coin):
url = 'xxxxxxxx'
try:
data = requests.post(url, data={'coin': coin}).json()
#print data
except Exception ,e:
print e
return data


def real_time_depth(self, coin):
url = 'xxxxxxxxx'
data = requests.post(url, data={'coin': coin}).json()
print data
data_bids = data['bids']
data_asks = data['asks']
print "bids"
for i in data_bids:
print i[0],
print ' ',
print i[1]
print "asks"
for j in data_asks:
print j[0],
print ' ',
print j[1]

def list_all_price(self):
for i in self.coin_list:
print i,
print " price: ",
p=self.real_time_ticker(i.lower())
if p is not None:
print p[u'last']

def getOrder(self,coin):
url='https://www.jubi.com/api/v1/orders/'
try:
req=requests.get(url,params={'coin':coin})
except Exception,e:
print e

data=req.json()
return data
# recent 100 trade turn over
def turnover(self,coin):
i=coin.lower()
coins=Toolkit.getUserData('coins.csv')
total=long(coins[i])
[i] [/i]p=self.getOrder(i)
print p
amount=0.00
for j in p:
t= j[u'amount']
amount=float(t)+amount
#current=float(self.real_time_ticker(i)[u'last'])
turn_over=amount*1.00/total*100
print turn_over

def multi_thread(self,coin_list,price_list):
thread_num=len(coin_list)
thread_list=
for i in range(thread_num):
t=threading.Thread(target=self.warming, args=(coin_list,price_list[0],price_list[1]),)
thread_list.append(t)
for j in thread_list:
j.start()
for k in thread_list:
k.join()

if __name__ == '__main__':

obj = Jubi_web(send='wechat')
coin_list=['zet','doge']
price_list=[[0.2,0.13],[0.03,0.024]]
obj.multi_thread(coin_list,price_list)

[/i]
程序运行后,使用扫一扫登录。 

coin_list=['zet','doge'] price_list=[[0.2,0.13],[0.03,0.024]]
 
通过这个参数,设置你想要监控的币种和目标价格。
同时程序支持发送给多个用户。
 

 http://30daydo.com/article/205
转载请注明出处 查看全部
最近由于好友推荐我入坑了国内的山寨币,所以顺便研究了下聚币网的API。 不过网页版的聚币网和手机版的做的不好,而且因为是7x24 小时交易,自己没有那么多的精力盯盘,所以写了python代码进行监控。

Screenshot_2017-05-29-23-02-13-420_微信_副本_副本.png
# -*-coding=utf-8-*-
__author__ = 'Rocky'
'''
http://30daydo.com
Contact: weigesysu@qq.com
'''
import random
import hashlib
import hmac,time
import smtplib
from email.mime.text import MIMEText
from email import Utils
import threading
import requests,datetime,itchat

from toolkit import Toolkit


class Jubi_web():
def __init__(self, send=None):
cfg = Toolkit.getUserData('data.cfg')
self.public_key = cfg['public_key']
self.private_key = cfg['private_key']
self.send=send
from_mail = cfg['from_mail']
password = cfg['password']
to_mail = cfg['to_mail']
smtp_server = 'smtp.qq.com'

self.server = smtp_server
self.username = from_mail.split("@")[0]
self.from_mail = from_mail
self.password = password
self.to_mail = to_mail
self.coin_list=['IFC','DOGE','EAC','DNC','MET','ZET','SKT','YTC','PLC','LKC',
'JBC','MRYC','GOOC','QEC','PEB','XRP','NXT','WDC','MAX','ZCC',
'HLB','RSS','PGC','RIO','XAS','TFC','BLK','FZ','ANS','XPM','VTC',
'KTC','VRC','XSGS','LSK','PPC','ETC','GAME','LTC','ETH','BTC']
# 初始化邮箱设置读取需要股票信息
# 这样子只登陆一次
if self.send == 'msn':

try:
self.smtp = smtplib.SMTP_SSL(port=465)
self.smtp.connect(self.server)
self.smtp.login(self.username, self.password)
except smtplib.SMTPException, e:
print e
return 0

if send=='wechat':
self.w_name=u'xxxxx'

itchat.auto_login(hotReload=True)
account=itchat.get_friends(self.w_name)


def send_wechat(self,name,content):
w_content=name+' '+content
itchat.send(w_content,toUserName=self.toName)
time.sleep(1)
itchat.send(w_content,toUserName='filehelper')


def send_text(self, name, content):

subject = '%s' % name
self.msg = MIMEText(content, 'plain', 'utf-8')
self.msg['to'] = self.to_mail
self.msg['from'] = self.from_mail
self.msg['Subject'] = subject
self.msg['Date'] = Utils.formatdate(localtime=1)
try:
self.smtp.sendmail(self.msg['from'], self.msg['to'], self.msg.as_string())
self.smtp.quit()
print "sent"
except smtplib.SMTPException, e:
print e
return 0

def warming(self, coin, up_price, down_price):
url = 'https://www.jubi.com/api/v1/ticker/'
while 1:
time.sleep(5)
try:
data = requests.post(url, data={'coin': coin}).json()
except Exception,e:
print e
print "time out. Retry"
time.sleep(15)
continue

current = float(data['last'])
if current >= up_price:
print "Up to ", up_price
print "current price ",current

if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))

time.sleep(1200)
if current <= down_price:
print "Down to ", down_price
print "current price ",current
if self.send=='msn':
self.send_text(coin,str(current))
if self.send=='wechat':
self.send_wechat(coin,str(current))
time.sleep(1200)
#上面的内容尽量不用修改。


def getContent(self):
url = 'https://www.jubi.com/api/v1/trade_list'
params_data = {'key': 'x', 'signature': 'x'}
s = requests.get(url=url, params=params_data)

def getHash(self, s):
m = hashlib.md5()
m.update(s)
return m.hexdigest()

def sha_convert(self, s):
return hashlib.sha256(self.getHash(s)).hexdigest()

def get_nonce(self):
lens = 12
return ''.join([str(random.randint(0, 9)) for i in range(lens)])

def get_signiture(self):
url = 'xxxxxxxxx'
coin = 'zet'
nonce = self.get_nonce()

# sha=self.sha_convert(private_key)
md5 = self.getHash(self.private_key)
message = 'nonce=' + nonce + '&' + 'key=' + self.public_key
# print message
signature = hmac.new(md5, message, digestmod=hashlib.sha256).digest()
# print signature

# req=requests.post(url,data={'signature':signature,'key':public_key,'nonce':nonce,'coin':'zet'})
req = requests.post(url, data={'coin': coin})
print req.status_code
print req.text

def real_time_ticker(self, coin):
url = 'xxxxxxxx'
try:
data = requests.post(url, data={'coin': coin}).json()
#print data
except Exception ,e:
print e
return data


def real_time_depth(self, coin):
url = 'xxxxxxxxx'
data = requests.post(url, data={'coin': coin}).json()
print data
data_bids = data['bids']
data_asks = data['asks']
print "bids"
for i in data_bids:
print i[0],
print ' ',
print i[1]
print "asks"
for j in data_asks:
print j[0],
print ' ',
print j[1]

def list_all_price(self):
for i in self.coin_list:
print i,
print " price: ",
p=self.real_time_ticker(i.lower())
if p is not None:
print p[u'last']

def getOrder(self,coin):
url='https://www.jubi.com/api/v1/orders/'
try:
req=requests.get(url,params={'coin':coin})
except Exception,e:
print e

data=req.json()
return data
# recent 100 trade turn over
def turnover(self,coin):
i=coin.lower()
coins=Toolkit.getUserData('coins.csv')
total=long(coins[i])
[i] [/i]p=self.getOrder(i)
print p
amount=0.00
for j in p:
t= j[u'amount']
amount=float(t)+amount
#current=float(self.real_time_ticker(i)[u'last'])
turn_over=amount*1.00/total*100
print turn_over

def multi_thread(self,coin_list,price_list):
thread_num=len(coin_list)
thread_list=
for i in range(thread_num):
t=threading.Thread(target=self.warming, args=(coin_list,price_list[0],price_list[1]),)
thread_list.append(t)
for j in thread_list:
j.start()
for k in thread_list:
k.join()

if __name__ == '__main__':

obj = Jubi_web(send='wechat')
coin_list=['zet','doge']
price_list=[[0.2,0.13],[0.03,0.024]]
obj.multi_thread(coin_list,price_list)

[/i]

程序运行后,使用扫一扫登录。 

coin_list=['zet','doge'] price_list=[[0.2,0.13],[0.03,0.024]]
 
通过这个参数,设置你想要监控的币种和目标价格。
同时程序支持发送给多个用户。
 

 http://30daydo.com/article/205
转载请注明出处

TA-Lib中MOM的计算公式

量化交易李魔佛 发表了文章 • 0 个评论 • 1018 次浏览 • 2017-05-29 01:38 • 来自相关话题

MOM是价格动能。
 TA-Lib中MOM的参数有
ouput=talib.MOM(closed,timeperiod=5)
 
closed是你传入的价格list,可以是每天的收盘价,开盘价,或者你想要计算的所有价格。
timeperiod是你要计算的时间周期。
 
假如timeperiod=5,那么,这个计算的输出值就是 p5-p0, 如果今天是1月6日,股价为14块,而1月1日的股价为12块,那么这里通过MOM运算,得出来的就是14-12=2 这个值了。 然后如此类推,如果今天是1月7日,股价为15块,而1月2日股价为11块,那么MOM得出的是4,这样子获取到所有的值,绘制成曲线,就是MOM的曲线了。 查看全部
MOM是价格动能。
 TA-Lib中MOM的参数有
ouput=talib.MOM(closed,timeperiod=5)
 
closed是你传入的价格list,可以是每天的收盘价,开盘价,或者你想要计算的所有价格。
timeperiod是你要计算的时间周期。
 
假如timeperiod=5,那么,这个计算的输出值就是 p5-p0, 如果今天是1月6日,股价为14块,而1月1日的股价为12块,那么这里通过MOM运算,得出来的就是14-12=2 这个值了。 然后如此类推,如果今天是1月7日,股价为15块,而1月2日股价为11块,那么MOM得出的是4,这样子获取到所有的值,绘制成曲线,就是MOM的曲线了。

Price Momentum

股票李魔佛 发表了文章 • 0 个评论 • 793 次浏览 • 2017-05-29 01:20 • 来自相关话题

Understanding Price Momentum

Today's stock market is more than just a place to buy and hold securities. Many investors prefer to move quickly in and out of the market. That's just one reason technical strategies, such as price momentum, have grown in popularity.

In this article, we're going to provide some insights into the investment strategy known as price momentum.  We'll explain why some theorists believe this model offers investors a short-term profit opportunity.  We'll also talk about the pros and cons of this approach, including the long-term opportunity that price momentum provides the market.

What is Price Momentum?

Additional Resources

Calculating Stock Prices
Capital Asset Pricing Model
Arbitrage Pricing Theory
Stock Beta and Volatility
Random Walk Theory Explained

The theory behind price momentum is relatively simple.  Generally, we can talk about it in two ways; the first has to do with buying stocks:

Stocks that had relatively high returns over the past three to twelve months should return to investors above average returns over the next three to twelve months.

The theory also provides guidance on the right time to sell stocks:

Stocks that had relatively poor returns over the past three to twelve months should return to investors below average returns over the next three to twelve months.

This investment strategy was first theorized by Narasimhan Jegadeesh and Sheridan Titman in their publication "Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency," which was published in The Journal of Finance back in March 1993.

Price Momentum Model

The model is based on the assumption the stock market is not completely efficient. This is something that most economists believe to be true.  The two most practical explanations for the performance of this model include:

Investors are taking advantage of human behavior, including a "herding" mentality and / or an overreaction to news.
Investors employing a price momentum strategy are taking on additional risk; therefore, higher returns are required to compensate these investors for the risk they're assuming.

Within their study, Jegadeesh and Titman examined a large number of trading strategies.  One of the conclusions from that study is stated below:

Buying past winners, and selling past losers, allowed investors to achieve above average returns over the period 1956 to 1989.  In particular, stocks that were classified based on their prior 6-month performance, and held for 6 months realized an excess return of over 12% per year on average.

The Momentum Formula

Technical stock analysts understand the value this particular technique provides.  They're constantly crunching numbers to see if patterns emerge.  The actual formula for calculating price momentum is really quite simple, and takes the form:

M = CP - CPn

Where:

M = Momentum
CP = Closing price in the current period
CPn = Closing price N periods ago

For example, if a stock was trading at $35 per share six months ago, and is currently trading at $40 per share, then its six-month price momentum would be 40 minus 35 or 5.

Unfortunately, this formula is not normalized, and this makes it difficult to compare stocks selling at different price points.  A stock experiencing a 1% price movement from $300 to $303 would have a momentum value of three.  A second stock experiencing a 100% increase in price from $3 to $6 also has a momentum value of three.

Rate of Change Formula

One of the ways technical stock analysts can work around this problem is by calculating a rate of change value, which normalizes momentum:

RoC = (CP - CPn) / CPn

Where:

RoC = Rate of Change
CP = Closing price in the current period
CPn = Closing price N periods ago

Using the example above, the stock selling at $303 per share that was trading at $300 six months ago would have a Rate of Change of 3 / 300 or 1%, while the second stock would have a Rate of Change of 3 / 3 or 100%.

Momentum and Moving Averages

A second way that stock analysts use price momentum is in conjunction with moving averages.  Here the technical analyst makes a series of price momentum calculations and plots these along with a moving average of the momentum.

For example, the plot might contain 28-day moving averages along with daily price momentum figures.  Buy signals can be triggered when price momentum travels above its moving averages, and stays there for several trading days.  Sell signals can be triggered when momentum travels below its moving average.

Contrarian Investing

As mentioned in the beginning of this article, this model tells investors they should buy past winners and sell past losers.  Because this theory is based on past price performance, or historical market information, price momentum is a trading model that technical analysts would follow.  Fundamental analysts believe that a stock is bought and sold based on its intrinsic value, including the company's potential to produce profits for its shareholders in the future.

Fortunately, fundamental analysts can also use price momentum to their advantage by adopting what is termed a contrarian investing strategy.  Contrarian investors take the opposite approach that a theory advocates.  For example, a fundamental analyst might conclude:

A stock that has been rising may now be overvalued, while a stock that has been falling may be undervalued.

One could argue the further a stock moves from its true market value, the greater the opportunity for profits.  By tracking price momentum, and using this as a screening tool, fundamental analysts can then assess if a stock is truly undervalued or overvalued by studying the company's long-term financial health and earnings power.

About the Author - Understanding Price Momentum (Last Reviewed on November 22, 2016)
 
http://30daydo.com/article/203
  查看全部
Understanding Price Momentum

Today's stock market is more than just a place to buy and hold securities. Many investors prefer to move quickly in and out of the market. That's just one reason technical strategies, such as price momentum, have grown in popularity.

In this article, we're going to provide some insights into the investment strategy known as price momentum.  We'll explain why some theorists believe this model offers investors a short-term profit opportunity.  We'll also talk about the pros and cons of this approach, including the long-term opportunity that price momentum provides the market.

What is Price Momentum?

Additional Resources

Calculating Stock Prices
Capital Asset Pricing Model
Arbitrage Pricing Theory
Stock Beta and Volatility
Random Walk Theory Explained

The theory behind price momentum is relatively simple.  Generally, we can talk about it in two ways; the first has to do with buying stocks:

Stocks that had relatively high returns over the past three to twelve months should return to investors above average returns over the next three to twelve months.

The theory also provides guidance on the right time to sell stocks:

Stocks that had relatively poor returns over the past three to twelve months should return to investors below average returns over the next three to twelve months.

This investment strategy was first theorized by Narasimhan Jegadeesh and Sheridan Titman in their publication "Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency," which was published in The Journal of Finance back in March 1993.

Price Momentum Model

The model is based on the assumption the stock market is not completely efficient. This is something that most economists believe to be true.  The two most practical explanations for the performance of this model include:

Investors are taking advantage of human behavior, including a "herding" mentality and / or an overreaction to news.
Investors employing a price momentum strategy are taking on additional risk; therefore, higher returns are required to compensate these investors for the risk they're assuming.

Within their study, Jegadeesh and Titman examined a large number of trading strategies.  One of the conclusions from that study is stated below:

Buying past winners, and selling past losers, allowed investors to achieve above average returns over the period 1956 to 1989.  In particular, stocks that were classified based on their prior 6-month performance, and held for 6 months realized an excess return of over 12% per year on average.

The Momentum Formula

Technical stock analysts understand the value this particular technique provides.  They're constantly crunching numbers to see if patterns emerge.  The actual formula for calculating price momentum is really quite simple, and takes the form:

M = CP - CPn

Where:

M = Momentum
CP = Closing price in the current period
CPn = Closing price N periods ago

For example, if a stock was trading at $35 per share six months ago, and is currently trading at $40 per share, then its six-month price momentum would be 40 minus 35 or 5.

Unfortunately, this formula is not normalized, and this makes it difficult to compare stocks selling at different price points.  A stock experiencing a 1% price movement from $300 to $303 would have a momentum value of three.  A second stock experiencing a 100% increase in price from $3 to $6 also has a momentum value of three.

Rate of Change Formula

One of the ways technical stock analysts can work around this problem is by calculating a rate of change value, which normalizes momentum:

RoC = (CP - CPn) / CPn

Where:

RoC = Rate of Change
CP = Closing price in the current period
CPn = Closing price N periods ago

Using the example above, the stock selling at $303 per share that was trading at $300 six months ago would have a Rate of Change of 3 / 300 or 1%, while the second stock would have a Rate of Change of 3 / 3 or 100%.

Momentum and Moving Averages

A second way that stock analysts use price momentum is in conjunction with moving averages.  Here the technical analyst makes a series of price momentum calculations and plots these along with a moving average of the momentum.

For example, the plot might contain 28-day moving averages along with daily price momentum figures.  Buy signals can be triggered when price momentum travels above its moving averages, and stays there for several trading days.  Sell signals can be triggered when momentum travels below its moving average.

Contrarian Investing

As mentioned in the beginning of this article, this model tells investors they should buy past winners and sell past losers.  Because this theory is based on past price performance, or historical market information, price momentum is a trading model that technical analysts would follow.  Fundamental analysts believe that a stock is bought and sold based on its intrinsic value, including the company's potential to produce profits for its shareholders in the future.

Fortunately, fundamental analysts can also use price momentum to their advantage by adopting what is termed a contrarian investing strategy.  Contrarian investors take the opposite approach that a theory advocates.  For example, a fundamental analyst might conclude:

A stock that has been rising may now be overvalued, while a stock that has been falling may be undervalued.

One could argue the further a stock moves from its true market value, the greater the opportunity for profits.  By tracking price momentum, and using this as a screening tool, fundamental analysts can then assess if a stock is truly undervalued or overvalued by studying the company's long-term financial health and earnings power.

About the Author - Understanding Price Momentum (Last Reviewed on November 22, 2016)
 
http://30daydo.com/article/203
 

TA-Lib MA_Type

股票李魔佛 发表了文章 • 0 个评论 • 2511 次浏览 • 2017-05-29 00:43 • 来自相关话题

在TA-Lib中有一个参数的类型是MA_Type, 谷歌了一下,把内容贴出来。 
 
主要就是使用不一样的加权方式对数据进行处理。import talib
from talib import MA_Type

MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)
 
移动平均(英语:moving average,MA),又称“移动平均线”简称均线,是技术分析中一种分析时间序列数据的工具。最常见的是利用股价、回报或交易量等变数计算出移动平均。
移动平均可抚平短期波动,反映出长期趋势或周期。数学上,移动平均可视为一种卷积。
 

简单移动平均(英语:simple moving average,SMA)是某变数之前n个数值的未作加权算术平均。例如,收市价的10日简单移动平均指之前10日收市价的平均数。:

当计算连续的数值,一个新的数值加入,同时一个旧数值剔出,所以无需每次都重新逐个数值加起来。
在技术分析中,不同的市场对常用天数(n值)有不同的需求,例如:某些市场普遍的n值为10日、40日、200日;有些则是5日、10日、20日、60日、120日、240日,视乎分析时期长短而定。投资者冀从移动平均线的图表中分辨出支持位或阻力位。
 
 
 
加权移动平均(英语:weighted moving average,WMA)指计算平均值时将个别数据乘以不同数值,在技术分析中,n日WMA的最近期一个数值乘以n、次近的乘以n-1,如此类推,一直到0:
 
指数移动平均(英语:exponential moving average,EMA或EWMA)是以指数式递减加权的移动平均。各数值的加权影响力随时间而指数式递减,越近期的数据加权影响力越重,但较旧的数据也给予一定的加权值
 
     
     WMA                                             EMA
 
 
使用下面的代码实现不一样的MA
  #MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)
df=ts.get_k_data('300580',start='2017-01-12',end='2017-05-26')
closed=df['close'].values
sma=talib.MA(closed,timeperiod=10,matype=0)
ema=talib.MA(closed,timeperiod=10,matype=1)
wma=talib.MA(closed,timeperiod=10,matype=2)
dema=talib.MA(closed,timeperiod=10,matype=3)
tema=talib.MA(closed,timeperiod=10,matype=4)
trima=talib.MA(closed,timeperiod=10,matype=5)
kma=talib.MA(closed,timeperiod=10,matype=6)
mama=talib.MA(closed,timeperiod=10,matype=7)
t3=talib.MA(closed,timeperiod=10,matype=8)
#ouput=talib.MA(closed,timeperiod=5,matype=0)
print closed
plt.ylim([0,40])
plt.plot(sma)
plt.plot(ema)
plt.plot(wma)
plt.plot(dema)
plt.plot(tema)
plt.plot(trima)
plt.plot(kma)
plt.plot(mama)
plt.plot(t3)
plt.grid()
plt.show()
生成的图像如下:





 
http://30daydo.com/article/201
转载请注明出处 查看全部
在TA-Lib中有一个参数的类型是MA_Type, 谷歌了一下,把内容贴出来。 
 
主要就是使用不一样的加权方式对数据进行处理。
import talib
from talib import MA_Type

MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)

 
移动平均(英语:moving average,MA),又称“移动平均线”简称均线,是技术分析中一种分析时间序列数据的工具。最常见的是利用股价、回报或交易量等变数计算出移动平均。
移动平均可抚平短期波动,反映出长期趋势或周期。数学上,移动平均可视为一种卷积。
 

简单移动平均(英语:simple moving average,SMA)是某变数之前n个数值的未作加权算术平均。例如,收市价的10日简单移动平均指之前10日收市价的平均数。:

当计算连续的数值,一个新的数值加入,同时一个旧数值剔出,所以无需每次都重新逐个数值加起来。
在技术分析中,不同的市场对常用天数(n值)有不同的需求,例如:某些市场普遍的n值为10日、40日、200日;有些则是5日、10日、20日、60日、120日、240日,视乎分析时期长短而定。投资者冀从移动平均线的图表中分辨出支持位或阻力位。
 
 
 
加权移动平均(英语:weighted moving average,WMA)指计算平均值时将个别数据乘以不同数值,在技术分析中,n日WMA的最近期一个数值乘以n、次近的乘以n-1,如此类推,一直到0:
 
指数移动平均(英语:exponential moving average,EMA或EWMA)是以指数式递减加权的移动平均。各数值的加权影响力随时间而指数式递减,越近期的数据加权影响力越重,但较旧的数据也给予一定的加权值
 
     
     WMA                                             EMA
 
 
使用下面的代码实现不一样的MA
 
    #MA_Type: 0=SMA, 1=EMA, 2=WMA, 3=DEMA, 4=TEMA, 5=TRIMA, 6=KAMA, 7=MAMA, 8=T3 (Default=SMA)
df=ts.get_k_data('300580',start='2017-01-12',end='2017-05-26')
closed=df['close'].values
sma=talib.MA(closed,timeperiod=10,matype=0)
ema=talib.MA(closed,timeperiod=10,matype=1)
wma=talib.MA(closed,timeperiod=10,matype=2)
dema=talib.MA(closed,timeperiod=10,matype=3)
tema=talib.MA(closed,timeperiod=10,matype=4)
trima=talib.MA(closed,timeperiod=10,matype=5)
kma=talib.MA(closed,timeperiod=10,matype=6)
mama=talib.MA(closed,timeperiod=10,matype=7)
t3=talib.MA(closed,timeperiod=10,matype=8)
#ouput=talib.MA(closed,timeperiod=5,matype=0)
print closed
plt.ylim([0,40])
plt.plot(sma)
plt.plot(ema)
plt.plot(wma)
plt.plot(dema)
plt.plot(tema)
plt.plot(trima)
plt.plot(kma)
plt.plot(mama)
plt.plot(t3)
plt.grid()
plt.show()

生成的图像如下:

diff_ma.PNG

 
http://30daydo.com/article/201
转载请注明出处

TA-Lib 量化交易代码实例 <二> 获取布林线的上轨,中轨,下轨的数据

量化交易李魔佛 发表了文章 • 0 个评论 • 6759 次浏览 • 2017-05-28 23:08 • 来自相关话题

BOLL指标的原理
BOLL指标是美国股市分析家约翰·布林根据统计学中的标准差原理设计出来的一种非常简单实用的技术分析指标。一般而言,股价的运动总是围绕某一价值中枢(如均线、成本线等)在一定的范围内变动,布林线指标指标正是在上述条件的基础上,引进了“股价通道”的概念,其认为股价通道的宽窄随着股价波动幅度的大小而变化,而且股价通道又具有变异性,它会随着股价的变化而自动调整。正是由于它具有灵活性、直观性和趋势性的特点,BOLL指标渐渐成为投资者广为应用的市场上热门指标。
在众多技术分析指标中,BOLL指标属于比较特殊的一类指标。绝大多数技术分析指标都是通过数量的方法构造出来的,它们本身不依赖趋势分析和形态分析,而BOLL指标却股价的形态和趋势有着密不可分的联系。BOLL指标中的“股价通道”概念正是股价趋势理论的直观表现形式。BOLL是利用“股价通道”来显示股价的各种价位,当股价波动很小,处于盘整时,股价通道就会变窄,这可能预示着股价的波动处于暂时的平静期;当股价波动超出狭窄的股价通道的上轨时,预示着股价的异常激烈的向上波动即将开始;当股价波动超出狭窄的股价通道的下轨时,同样也预示着股价的异常激烈的向下波动将开始。
投资者常常会遇到两种最常见的交易陷阱,一是买低陷阱,投资者在所谓的低位买进之后,股价不仅没有止跌反而不断下跌;二是卖高陷阱,股票在所谓的高点卖出后,股价却一路上涨。布林线特别运用了爱因斯坦的相对论,认为各类市场间都是互动的,市场内和市场间的各种变化都是相对性的,是不存在绝对性的,股价的高低是相对的,股价在上轨线以上或在下轨线以下只反映该股股价相对较高或较低,投资者作出投资判断前还须综合参考其他技术指标,包括价量配合,心理类指标,类比类指标,市场间的关联数据等。
总之,BOLL指标中的股价通道对预测未来行情的走势起着重要的参考作用,它也是布林线指标所特有的分析手段。
[编辑]
BOLL指标的计算方法
在所有的指标计算中,BOLL指标的计算方法是最复杂的之一,其中引进了统计学中的标准差概念,涉及到中轨线(MB)、上轨线(UP)和下轨线(DN)的计算。另外,和其他指标的计算一样,由于选用的计算周期的不同,BOLL指标也包括日BOLL指标、周BOLL指标、月BOLL指标年BOLL指标以及分钟BOLL指标等各种类型。经常被用于股市研判的是日BOLL指标和周BOLL指标。虽然它们的计算时的取值有所不同,但基本的计算方法一样。以日BOLL指标计算为例,其计算方法如下:
1、日BOLL指标的计算公式
中轨线=N日的移动平均线
上轨线=中轨线+两倍的标准差
下轨线=中轨线-两倍的标准差
2、日BOLL指标的计算过程
1)计算MA
MA=N日内的收盘价之和÷N2)计算标准差MD
MD=平方根N日的(C-MA)的两次方之和除以N3)计算MB、UP、DN线
MB=(N-1)日的MA
UP=MB+2×MD
DN=MB-2×MD在股市分析软件中,BOLL指标一共由四条线组成,即上轨线UP 、中轨线MB、下轨线DN和价格线。其中上轨线UP是UP数值的连线,用黄色线表示;中轨线MB是MB数值的连线,用白色线表示;下轨线DN是DN数值的连线,用紫色线表示;价格线是以美国线表示,颜色为浅蓝色。和其他技术指标一样,在实战中,投资者不需要进行BOLL指标的计算,主要是了解BOLL的计算方法和过程,以便更加深入地掌握BOLL指标的实质,为运用指标打下基础。
 
#通过tushare获取股票信息
df=ts.get_k_data('300580',start='2017-01-12',end='2017-05-26')
#提取收盘价
closed=df['close'].values

upper,middle,lower=talib.BBANDS(closed,matype=talib.MA_Type.T3)

print upper,middle,lower
plt.plot(upper)
plt.plot(middle)
plt.plot(lower)
plt.grid()
plt.show()
diff1=upper-middle
diff2=middle-lower
print diff1
print diff2





 
最后那里可以看到diff1和diff2是一样的。 验证了布林线的定义ma+2d,m-2d。 查看全部

BOLL指标的原理
BOLL指标是美国股市分析家约翰·布林根据统计学中的标准差原理设计出来的一种非常简单实用的技术分析指标。一般而言,股价的运动总是围绕某一价值中枢(如均线、成本线等)在一定的范围内变动,布林线指标指标正是在上述条件的基础上,引进了“股价通道”的概念,其认为股价通道的宽窄随着股价波动幅度的大小而变化,而且股价通道又具有变异性,它会随着股价的变化而自动调整。正是由于它具有灵活性、直观性和趋势性的特点,BOLL指标渐渐成为投资者广为应用的市场上热门指标。
在众多技术分析指标中,BOLL指标属于比较特殊的一类指标。绝大多数技术分析指标都是通过数量的方法构造出来的,它们本身不依赖趋势分析和形态分析,而BOLL指标却股价的形态和趋势有着密不可分的联系。BOLL指标中的“股价通道”概念正是股价趋势理论的直观表现形式。BOLL是利用“股价通道”来显示股价的各种价位,当股价波动很小,处于盘整时,股价通道就会变窄,这可能预示着股价的波动处于暂时的平静期;当股价波动超出狭窄的股价通道的上轨时,预示着股价的异常激烈的向上波动即将开始;当股价波动超出狭窄的股价通道的下轨时,同样也预示着股价的异常激烈的向下波动将开始。
投资者常常会遇到两种最常见的交易陷阱,一是买低陷阱,投资者在所谓的低位买进之后,股价不仅没有止跌反而不断下跌;二是卖高陷阱,股票在所谓的高点卖出后,股价却一路上涨。布林线特别运用了爱因斯坦的相对论,认为各类市场间都是互动的,市场内和市场间的各种变化都是相对性的,是不存在绝对性的,股价的高低是相对的,股价在上轨线以上或在下轨线以下只反映该股股价相对较高或较低,投资者作出投资判断前还须综合参考其他技术指标,包括价量配合,心理类指标,类比类指标,市场间的关联数据等。
总之,BOLL指标中的股价通道对预测未来行情的走势起着重要的参考作用,它也是布林线指标所特有的分析手段。
[编辑]
BOLL指标的计算方法
在所有的指标计算中,BOLL指标的计算方法是最复杂的之一,其中引进了统计学中的标准差概念,涉及到中轨线(MB)、上轨线(UP)和下轨线(DN)的计算。另外,和其他指标的计算一样,由于选用的计算周期的不同,BOLL指标也包括日BOLL指标、周BOLL指标、月BOLL指标年BOLL指标以及分钟BOLL指标等各种类型。经常被用于股市研判的是日BOLL指标和周BOLL指标。虽然它们的计算时的取值有所不同,但基本的计算方法一样。以日BOLL指标计算为例,其计算方法如下:
1、日BOLL指标的计算公式
中轨线=N日的移动平均线
上轨线=中轨线+两倍的标准差
下轨线=中轨线-两倍的标准差
2、日BOLL指标的计算过程
1)计算MA
MA=N日内的收盘价之和÷N2)计算标准差MD
MD=平方根N日的(C-MA)的两次方之和除以N3)计算MB、UP、DN线
MB=(N-1)日的MA
UP=MB+2×MD
DN=MB-2×MD在股市分析软件中,BOLL指标一共由四条线组成,即上轨线UP 、中轨线MB、下轨线DN和价格线。其中上轨线UP是UP数值的连线,用黄色线表示;中轨线MB是MB数值的连线,用白色线表示;下轨线DN是DN数值的连线,用紫色线表示;价格线是以美国线表示,颜色为浅蓝色。和其他技术指标一样,在实战中,投资者不需要进行BOLL指标的计算,主要是了解BOLL的计算方法和过程,以便更加深入地掌握BOLL指标的实质,为运用指标打下基础。
 
    #通过tushare获取股票信息
df=ts.get_k_data('300580',start='2017-01-12',end='2017-05-26')
#提取收盘价
closed=df['close'].values

upper,middle,lower=talib.BBANDS(closed,matype=talib.MA_Type.T3)

print upper,middle,lower
plt.plot(upper)
plt.plot(middle)
plt.plot(lower)
plt.grid()
plt.show()
diff1=upper-middle
diff2=middle-lower
print diff1
print diff2


布林线.PNG

 
最后那里可以看到diff1和diff2是一样的。 验证了布林线的定义ma+2d,m-2d。

quantdigger 量化交易入门 代码示例

量化交易李魔佛 发表了文章 • 0 个评论 • 1632 次浏览 • 2017-05-28 21:39 • 来自相关话题

第五天
 
《》
待更新
第五天
 
《》
待更新