def haveSLOWKDDeathCross(parseDay, id, days, maDays):
dataOfDays = KdjParser.getKDJData(parseDay, id, days + maDays)
# print dataOfDays
if False == dataOfDays:
return False
cDayList = BaseParser.getPastTradingDayList(parseDay, days + 1)
# print cDayList
haveDeathCross = False
for i in xrange(1, days + 1):
preD = float(dataOfDays[cDayList[i - 1]][1])
nowD = float(dataOfDays[cDayList[i]][1])
sumD = 0
maDayList = BaseParser.getPastTradingDayList(cDayList[i], maDays)
for day in maDayList:
d = float(dataOfDays[day][1])
sumD += d
maD = sumD / maDays
if ((preD > maD) and (nowD < maD)):
haveDeathCross = True
break
if haveDeathCross:
return True
return False
def parse(self, res, parseDay, id=''):
ret = True
# x 2 3
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
day1 = dayList[0]
day2 = dayList[1]
day3 = dayList[2]
# 第1日阳线、穿透均线
if not self.isPenetrateMa(res, day1):
return False
dayList = BaseParser.getPastTradingDayList(day1, 60)
(v, v, ma) = self.getMAPrice(res, dayList)
# 第2日站稳
endPrice2 = self.getEndPriceOfDay(res, day2)
if endPrice2 <= ma:
return False
# 第2日站稳
endPrice3 = self.getEndPriceOfDay(res, day3)
if endPrice3 <= ma:
return False
# 去掉底太小的（至少10根最低价在线下，即两周的蓄能）
# 去掉站不稳的（线穿3实体）
return ret
def parse(self, res, parseDay, id=''):
ret = False
dayList = BaseParser.getPastTradingDayList(parseDay, 5)
startPrice = self.getEndPriceOfDay(res, dayList[3])
endPrice = self.getEndPriceOfDay(res, dayList[4])
growthRate = (endPrice - startPrice) / startPrice
if growthRate < 0.09:
return False
startPrice = self.getEndPriceOfDay(res, dayList[2])
endPrice = self.getEndPriceOfDay(res, dayList[3])
growthRate = (endPrice - startPrice) / startPrice
if growthRate > 0.03:
return False
startPrice = self.getEndPriceOfDay(res, dayList[1])
endPrice = self.getEndPriceOfDay(res, dayList[2])
growthRate = (endPrice - startPrice) / startPrice
if growthRate > 0.03:
return False
startPrice = self.getEndPriceOfDay(res, dayList[0])
endPrice = self.getEndPriceOfDay(res, dayList[1])
growthRate = (endPrice - startPrice) / startPrice
if growthRate > 0.03:
return False
return True
def parse(self, res, parseDay, id=''):
# 近几日无涨停、跌停行情，排除基于获利和解套的
dayList = BaseParser.getPastTradingDayList(parseDay, 5)
for day in dayList:
if self.isUpwardLimit(res, day):
return False
if self.isDownwardLimit(res, day):
return False
# 流通市值小于50亿
basicInfo = BaseParser.getBasicInfoById(id)
mvc = float(basicInfo[45])
if mvc < 1:
return False # 错误数据
if mvc > 5000000000:
return False
# 去掉ST，涨停有限
name = Tools.getNameById(id)
if 'st' in name or 'ST' in name:
return False
# # 换手率大于1%
# changeRate = float(self.geChangeRateOfDay(res,parseDay))
# if changeRate < 1.0:
# return False
return True
def isDUpwardAndNotTooHigh(parseDay, id):
path = Tools.getKdjDataPath() + '/' + id
res = open(path, 'r').read()
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
kdjList = eval(res[26:-1])
dataOfDays = {}
for item in kdjList:
for d in dayList:
if d == item['time']:
dataOfDays[d] = eval(item['kdj'])
# print dataOfDays
d1 = float(dataOfDays[dayList[-2]][1])
d = float(dataOfDays[dayList[-1]][1])
# 数据错误，当做下降处理
if (len(dataOfDays) < 1) or (len(dayList) != len(dataOfDays)):
return False
# d在下降
if d < d1:
return False
# d大于70
if d > 70:
return False
return True
def isRiseIsStronger(self, res, parseDay):
# 240-180 | 180-120 | 120-60 | 区间均价递增
dayList = BaseParser.getPastTradingDayList(parseDay, 240)
dayList1 = dayList[0:60]
dayList2 = dayList[60:120]
dayList3 = dayList[120:180]
dayList4 = dayList[180:240]
(v, v, ma1) = self.getMAPrice(res, dayList1)
(v, v, ma2) = self.getMAPrice(res, dayList2)
(v, v, ma3) = self.getMAPrice(res, dayList3)
(v, v, ma4) = self.getMAPrice(res, dayList4)
if ma1 <= 0 or ma2 <= 0 or ma3 <= 0 or ma4 <= 0: # -1
return False
# 四象
if self.isInRise([ma2, ma3, ma4]):
#print '〇↗↗↗'
return True
if self.isInRise([ma1, ma3, ma4]):
#print '↗〇↗↗'
return True
if self.isInRise([ma1, ma2, ma4]):
#print '↗↗〇↗'
return True
#if self.isInRise([ma1,ma2,ma3]):
#print '↗↗↗〇'
# return True
return False
def isMa5RiseUp(self, res, parseDay):
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
day1 = dayList[0]
day2 = dayList[1]
day3 = dayList[2]
dayList1 = BaseParser.getPastTradingDayList(day1, 5)
dayList2 = BaseParser.getPastTradingDayList(day2, 5)
dayList3 = BaseParser.getPastTradingDayList(day3, 5)
(v, v, ma1) = self.getMAPrice(res, dayList1)
(v, v, ma2) = self.getMAPrice(res, dayList2)
(v, v, ma3) = self.getMAPrice(res, dayList3)
diff1 = ma2 - ma1
diff2 = ma3 - ma2
if diff2 < diff1:
return False
return True
def isHaveAdamSupport(self, res, parseDay, days):
dayList = BaseParser.getPastTradingDayList(parseDay, days)
day1 = dayList[0]
day2 = dayList[-1]
endPrice1 = self.getEndPriceOfDay(res, day1)
endPrice2 = self.getEndPriceOfDay(res, day2)
return day2 > day1
def calcuR(self, idList, num):
vList = []
for id in idList:
path = Tools.getPriceDirPath() + '/' + str(id)
res = open(path, 'r').read()
# am = self.getEntityAm(res,parseDay)
# d = KdjParser.getD(parseDay,id)
# r = am/d
# r = d
dayList = BaseParser.getPastTradingDayList(parseDay, 5)
(v, v, ma) = self.getMAPrice(res, dayList)
endPrice = self.getEndPriceOfDay(res, parseDay)
r = ma / endPrice
vList.append((id, r))
# 排序
sList = sorted(vList, key=lambda x: -x[1])
# sList = sorted(vList,key=lambda x: x[1])
print "sorted list:"
print sList
selectedList = sList[:num]
print "\nselected list:"
print selectedList
l = []
for item in selectedList:
l.append(item[0])
return l
def parse(self, res, parseDay, id=''):
ret = False
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
day1 = dayList[0] # 第一天
day2 = dayList[1] # 第二天
day3 = dayList[2] # 第三天
startPriceOfDay1 = self.getStartPriceOfDay(res, day1)
endPriceOfDay1 = self.getEndPriceOfDay(res, day1)
entityOfDay1 = abs(startPriceOfDay1 - endPriceOfDay1)
startPriceOfDay2 = self.getStartPriceOfDay(res, day2)
endPriceOfDay2 = self.getEndPriceOfDay(res, day2)
entityOfDay2 = abs(startPriceOfDay2 - endPriceOfDay2)
startPriceOfDay3 = self.getStartPriceOfDay(res, day3)
endPriceOfDay3 = self.getEndPriceOfDay(res, day3)
entityOfDay3 = abs(startPriceOfDay3 - endPriceOfDay3)
# 去掉第1天不是阴线
if endPriceOfDay1 >= startPriceOfDay1:
return False
# 去掉第3天不是阳线
if endPriceOfDay3 <= startPriceOfDay3:
return False
# 第2天必须和前后两天形成实体跳空
upperEntityPriceOfDay2 = max(startPriceOfDay2, endPriceOfDay2)
if upperEntityPriceOfDay2 > min(endPriceOfDay1, startPriceOfDay3):
return False
# 第2天的实体长度应该小于另两天的1/4
if entityOfDay2 / min(entityOfDay1, entityOfDay3) > 0.25:
return False
return True
def isKdjBull(parseDay, id):
path = Tools.getKdjDataPath() + '/' + id
res = open(path, 'r').read()
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
kdjList = eval(res[26:-1])
dataOfDays = {}
for item in kdjList:
for d in dayList:
if d == item['time']:
dataOfDays[d] = eval(item['kdj'])
# 数据错误
if (len(dataOfDays) < 1) or (len(dayList) != len(dataOfDays)):
return False
k1 = float(dataOfDays[dayList[-2]][0])
k2 = float(dataOfDays[dayList[-1]][0])
d1 = float(dataOfDays[dayList[-2]][1])
d2 = float(dataOfDays[dayList[-1]][1])
j1 = float(dataOfDays[dayList[-2]][2])
j2 = float(dataOfDays[dayList[-1]][2])
# D在20之下
dayLimit = 20
if d2 > dayLimit or d2 < 1: # d大于20，或d数据错误
return False
if (k2 <= k1) or (d2 <= d1) or (j2 <= j1):
return False
# J K D
if not ((j2 > k2) and (k2 > d2)):
return False
return True
def isUpGap(self, res, parseDay):
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
day1 = dayList[0]
day2 = dayList[1]
maxPriceOfDay1 = self.getMaxPriceOfDay(res, day1)
minPriceOfDay2 = self.getMinPriceOfDay(res, day2)
return minPriceOfDay2 > maxPriceOfDay1
def parse(self, res, parseDay, id=''):
dayList = BaseParser.getPastTradingDayList(parseDay, 5)
endPrice = self.getEndPriceOfDay(res, parseDay)
# 必须秃顶（一字板 或 T字板）
startP = self.getStartPriceOfDay(res, parseDay)
minP = self.getMinPriceOfDay(res, parseDay)
maxP = self.getMaxPriceOfDay(res, parseDay)
if not (maxP == startP):
return False
# 当日涨停
if not self.isUpwardLimit(res, dayList[-2], dayList[-1]):
return False
# 昨日涨停（至少2连板）
# if not self.isUpwardLimit(res,dayList[-3],dayList[-2]):
# return False
# 当日收盘价在MA5之上
(v, v, ma) = self.getMAPrice(res, dayList)
if endPrice < ma:
return False
# rebound ma5
gr = UpWardLimitStepBackMaParser.getReboundMa5(res, parseDay)
if gr <= -1:
return False
return True
def isBiasMinOfDays(parseDay,days,id):
path = Tools.getBiasDataPath()+'/' +id
res = open(path,'r').read()
dayList = BaseParser.getPastTradingDayList(parseDay,days)
biasList = eval(res[26:-1])
dataOfDays = {}
for item in biasList:
for d in dayList:
if d == item['time']:
dataOfDays[d] = eval(item['bias'])
# 坏数据：个股交易日未必连续
if (len(dataOfDays)<1) or (len(dayList) != len(dataOfDays)):
# print 'len(dataOfDays)<1) or (len(dayList) != len(dataOfDays)'
return False
# bias n日最低
biasIsMin = True
bias = float(dataOfDays[parseDay][1])
for day,data in dataOfDays.items():
theBias = float(dataOfDays[day][1])
if theBias < bias:
biasIsMin = False
break
if not biasIsMin:
return False
return True
def parse(self, res, parseDay, id=''):
dayList = BaseParser.getPastTradingDayList(parseDay, 5) # 5日线
lastDay = dayList[-2]
startPriceOfLastDay = self.getStartPriceOfDay(res, lastDay)
endPriceOfLastDay = self.getEndPriceOfDay(res, lastDay)
startPrice = self.getStartPriceOfDay(res, parseDay)
endPrice = self.getEndPriceOfDay(res, parseDay)
if startPrice == 0 or startPriceOfLastDay == 0:
return False
# 吞没线
# -----------------------------------------------------------------------------
# 第一天非阳线
if endPriceOfLastDay > startPriceOfLastDay:
return False
# 第二天阳线
if endPrice <= startPrice:
return False
# 第二天吞没第一天
if not ((startPrice < endPriceOfLastDay) and
(endPrice > startPriceOfLastDay)):
return False
# 第二天收盘价低于5日线
# -----------------------------------------------------------------------------
(v, v, ma5) = self.getMAPrice(res, dayList)
if endPrice >= ma5:
return False
return True
def parse(self, res, parseDay, id=''):
ret = False
dayList = self.getPastTradingDayList(parseDay, self._days)
limitNum = 0
for day in dayList:
if self.isUpLimit(res, day):
limitNum += 1
print limitNum
# 板数判断
if limitNum < self._num:
return False
# MA判断
dayList = BaseParser.getPastTradingDayList(parseDay, 5)
ma5 = self.getMAPrice(res, dayList)
endPrice = self.getEndPriceOfDay(res, parseDay)
if endPrice < ma5:
return False
return True
def isMaSupport(self,res,parseDay,maDays):
dayList = BaseParser.getPastTradingDayList(parseDay,maDays)
(v,v,ma) = self.getMAPrice(res,dayList)
minPrice = self.getMinPriceOfDay(res,parseDay)
endPrice = self.getEndPriceOfDay(res,parseDay)
if ((minPrice < ma) and (endPrice > ma)):
return True
return False
def isTriangularSupport(self, res, parseDay):
dayList5 = BaseParser.getPastTradingDayList(parseDay, 5)
dayList10 = BaseParser.getPastTradingDayList(parseDay, 10)
dayList20 = BaseParser.getPastTradingDayList(parseDay, 20)
(v1, v2, ma5) = self.getMAPrice(res, dayList5)
(v1, v2, ma10) = self.getMAPrice(res, dayList10)
(v1, v2, ma20) = self.getMAPrice(res, dayList20)
# 当日 ma5 > ma20 > ma10
if not ((ma5 > ma20) and (ma20 > ma10)):
return False
if abs(ma20 - ma5) < abs(ma20 - ma10):
return False
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
parseDay = dayList[0]
dayList5 = BaseParser.getPastTradingDayList(parseDay, 5)
dayList10 = BaseParser.getPastTradingDayList(parseDay, 10)
dayList20 = BaseParser.getPastTradingDayList(parseDay, 20)
(v1, v2, ma5) = self.getMAPrice(res, dayList5)
(v1, v2, ma10) = self.getMAPrice(res, dayList10)
(v1, v2, ma20) = self.getMAPrice(res, dayList20)
# 2日前 ma20 > ma5 > ma10
if not ((ma20 > ma5) and (ma5 > ma10)):
return False
return True
def parse(self, res, parseDay, id=''):
ret = False
dayList5 = BaseParser.getPastTradingDayList(parseDay, 5)
dayList10 = BaseParser.getPastTradingDayList(parseDay, 10)
dayList20 = BaseParser.getPastTradingDayList(parseDay, 20)
(v1, v2, ma5) = self.getMAPrice(res, dayList5)
(v1, v2, ma10) = self.getMAPrice(res, dayList10)
(v1, v2, ma20) = self.getMAPrice(res, dayList20)
# 当日 ma5 > ma20 > ma10
if not ((ma5 > ma20) and (ma20 > ma10)):
return False
# if abs(ma20-ma5) < abs(ma20-ma10):
# return False
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
parseDay = dayList[0]
dayList5 = BaseParser.getPastTradingDayList(parseDay, 5)
dayList10 = BaseParser.getPastTradingDayList(parseDay, 10)
dayList20 = BaseParser.getPastTradingDayList(parseDay, 20)
(v1, v2, ma5) = self.getMAPrice(res, dayList5)
(v1, v2, ma10) = self.getMAPrice(res, dayList10)
(v1, v2, ma20) = self.getMAPrice(res, dayList20)
# 2日前 ma20 > ma5 > ma10
if not ((ma20 > ma5) and (ma5 > ma10)):
return False
return True
def parse(self, res, parseDay, id=''):
ret = False
startPrice = self.getStartPriceOfDay(res, parseDay)
endPrice = self.getEndPriceOfDay(res, parseDay)
# 阳线
if endPrice <= startPrice:
return False
# 取均线
dayList5 = BaseParser.getPastTradingDayList(parseDay, 5)
dayList10 = BaseParser.getPastTradingDayList(parseDay, 10)
dayList20 = BaseParser.getPastTradingDayList(parseDay, 20)
(v1, v2, ma5) = self.getMAPrice(res, dayList5)
(v1, v2, ma10) = self.getMAPrice(res, dayList10)
(v1, v2, ma20) = self.getMAPrice(res, dayList20)
minMa = min(ma5, ma10, ma20)
maxMa = max(ma5, ma10, ma20)
# (maxMa - minMa) < endPrice*0.03
if not ((maxMa - minMa) < endPrice * 0.03):
return False
# 条件2
maxP = max(ma5, ma10, ma20, endPrice)
minP = min(ma5, ma10, ma20, endPrice)
r = maxP / minP
if r > 1.06:
return False
if not self.isInPlatform(res, parseDay):
return False
#
# if minMa <= min(startPrice,endPrice):
# return False
# if maxMa >= max(startPrice,endPrice):
# return False
return True
def isDownwardLimit(self, res, parseDay):
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
endPriceOfDay1 = self.getEndPriceOfDay(res, dayList[0])
endPriceOfDay2 = self.getEndPriceOfDay(res, dayList[1])
if 0 == endPriceOfDay1 or 0 == endPriceOfDay2:
return False
gr = (endPriceOfDay2 - endPriceOfDay1) / endPriceOfDay1
if gr < -0.09:
return True
return False
def isUpwardLimit(self, res, parseDay):
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
endPrice1 = self.getEndPriceOfDay(res, dayList[-2])
endPrice2 = self.getEndPriceOfDay(res, dayList[-1])
if endPrice1 == 0 or endPrice2 == 0:
return False
r = (endPrice2 - endPrice1) / endPrice1
if r < 0.095:
return False
return True
def getJ(parseDay, id):
days = 1
dayList = BaseParser.getPastTradingDayList(parseDay, days)
dataOfDays = KdjParser.getKDJData(parseDay, id, days)
if False == dataOfDays:
return False
# D在指定值之下
j = float(dataOfDays[parseDay][2])
return j
def isRecentlyInPlatform(self, res, parseDay):
havePlatformTrend = False
dayList = BaseParser.getPastTradingDayList(parseDay, 10)
for day in dayList:
if self.isInPlatform(res, day):
havePlatformTrend = True
break
if not havePlatformTrend:
return False
return True
def parse(self,res,parseDay,id=''):
# 5日线金叉10日线
# =========================================================================
dayList = BaseParser.getPastTradingDayList(parseDay,2)
lastDay = dayList[0]
dayList = BaseParser.getPastTradingDayList(lastDay,5)
(v,v,ma5_1) = self.getMAPrice(res,dayList)
dayList = BaseParser.getPastTradingDayList(parseDay,5)
(v,v,ma5_2) = self.getMAPrice(res,dayList)
dayList = BaseParser.getPastTradingDayList(parseDay,10)
(v,v,ma10) = self.getMAPrice(res,dayList)
if (ma5_1 < ma10) and (ma5_2 > ma10):
return True
return False
def isPenetrateUpwardMa60(self, res, parseDay):
dayList = BaseParser.getPastTradingDayList(parseDay, 2)
day1 = dayList[0]
day2 = dayList[1]
# 前一日收盘价在MA之下
dayList = BaseParser.getPastTradingDayList(day1, 60)
(v, v, ma) = self.getMAPrice(res, dayList)
endPrice1 = self.getEndPriceOfDay(res, day1)
if endPrice1 >= ma:
return False
# 当日收盘价在MA之上
dayList = BaseParser.getPastTradingDayList(day2, 60)
(v, v, ma) = self.getMAPrice(res, dayList)
parseDayMa = ma
endPrice2 = self.getEndPriceOfDay(res, day2)
if endPrice2 <= ma:
return False
return True
def isJUpwardReverse(parseDay, id=''):
days = 3
dayList = BaseParser.getPastTradingDayList(parseDay, days)
dataOfDays = KdjParser.getKDJData(parseDay, id, days)
if False == dataOfDays:
return False
j1 = float(dataOfDays[dayList[0]][2])
j2 = float(dataOfDays[dayList[1]][2])
j3 = float(dataOfDays[dayList[2]][2])
if not ((j2 < j1) and (j2 < j3)):
return False
return True
def isDUpwardReverse(parseDay, id=''):
days = 3
dayList = BaseParser.getPastTradingDayList(parseDay, days)
dataOfDays = KdjParser.getKDJData(parseDay, id, days)
if False == dataOfDays:
return False
d1 = float(dataOfDays[dayList[0]][1])
d2 = float(dataOfDays[dayList[1]][1])
d3 = float(dataOfDays[dayList[2]][1])
if not ((d2 < d1) and (d2 < d3)):
return False
return True
def parse(self, res, parseDay, id=''):
ret = False
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
day1 = dayList[0]
day2 = dayList[1]
day3 = dayList[2]
startPriceOfDay1 = self.getStartPriceOfDay(res, day1)
endPriceOfDay1 = self.getEndPriceOfDay(res, day1)
startPriceOfDay2 = self.getStartPriceOfDay(res, day2)
endPriceOfDay2 = self.getEndPriceOfDay(res, day2)
startPriceOfDay3 = self.getStartPriceOfDay(res, day3)
endPriceOfDay3 = self.getEndPriceOfDay(res, day3)
if 0 == startPriceOfDay1 or 0 == endPriceOfDay1:
return False
if 0 == startPriceOfDay2 or 0 == endPriceOfDay2:
return False
if 0 == startPriceOfDay3 or 0 == endPriceOfDay3:
return False
# 0, 1, 2
# day1 day2 day3
# 当日非一字板
rate = (endPriceOfDay3 - startPriceOfDay3) / startPriceOfDay3
if rate < 0.005:
return False
# 当日板了，day3即当日
gr2 = (endPriceOfDay3 - endPriceOfDay2) / endPriceOfDay2
if gr2 < 0.099:
return False
# 前一日板了
gr1 = (endPriceOfDay2 - endPriceOfDay1) / endPriceOfDay1
if gr1 < 0.099:
return False
# 仅二连板
# dayList = BaseParser.getPastTradingDayList(day1,2)
# endPriceOfDay0 = self.getEndPriceOfDay(res,dayList[0])
# if 0==endPriceOfDay0:
# return False
# gr0 = (endPriceOfDay1-endPriceOfDay0)/endPriceOfDay0
# if gr0 > 0.099:
# return False
# changeRate = self.geChangeRateOfDay(res,parseDay)
# if changeRate > 0.15:
# return False
return True
def isDUpward(parseDay, id):
days = 2
dataOfDays = KdjParser.getKDJData(parseDay, id, days)
if False == dataOfDays:
return False
dayList = BaseParser.getPastTradingDayList(parseDay, days)
preD = float(dataOfDays[dayList[0]][1])
nowD = float(dataOfDays[dayList[1]][1])
if nowD <= preD:
return False
return True
