def __init__(self, sess):
BaseParser.__init__(self)
self.sess = sess
self.item = None
self.party = None
self.content = False
self.title = False
self.date = None
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 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 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 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 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 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 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
def parse(self,res,parseDay,id=''):
ret = True
dayList = BaseParser.getPastTradingDayList(parseDay,2)
day1 = dayList[0] # 第1天
day2 = dayList[1] # 第2天
#day3 = dayList[2] # 第3天
shortTerm = 20
longTerm = 60
# 第一天短线小于长线
maLong = self.getMAPrice(res,BaseParser.getPastTradingDayList(day1,longTerm))
maShort = self.getMAPrice(res,BaseParser.getPastTradingDayList(day1,shortTerm))
if maShort >= maLong:
return False
# 第二天长线大于短线
maLong = self.getMAPrice(res,BaseParser.getPastTradingDayList(day2,longTerm))
maShort = self.getMAPrice(res,BaseParser.getPastTradingDayList(day2,shortTerm))
if maShort < maLong:
return False
return ret
def getParseResult(self,isDump=False):
idList = []
num = 0
macdFileList = BaseParser.getMacdFileList()
for f in macdFileList:
try:
res = open(f,'r').read()
ret = self.parse(res,self._parseDay)
if ret:
idList.append(f[-6:])
num += 1
print str(num) + ' ↗'
except Exception, e:
pass
print repr(e)
def isSupportByMa(self, res, parseDay, maDays):
endPrice = self.getEndPriceOfDay(res, parseDay)
minPrice = self.getMinPriceOfDay(res, parseDay)
if endPrice == 0 or minPrice == 0:
return False
dayList = BaseParser.getPastTradingDayList(parseDay, maDays)
(v, v, ma) = self.getMAPrice(res, dayList)
if ma < 0:
return False
if not ((minPrice < ma) and (endPrice > ma)):
return False
return True
def isRgb(self, res, day):
days = 1
dayList = BaseParser.getPastTradingDayList(parseDay, days)
dataOfDays = RgbParser.getMaData(parseDay, id, days)
if False == dataOfDays:
return False
maR = float(dataOfDays[dayList[-1]][0]) # 5
maG = float(dataOfDays[dayList[-1]][1]) # 10
maB = float(dataOfDays[dayList[-1]][2]) # 20
if not ((maR > maG) and (maG > maB)):
return False
return True
def getMutationScore(id, parseDay):
path = Tools.getKdjDataPath() + '/' + id
res = open(path, 'r').read()
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
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
d1 = float(dataOfDays[dayList[-3]][1])
d2 = float(dataOfDays[dayList[-2]][1])
d3 = float(dataOfDays[dayList[-1]][1])
# 新股
if d1 >= 100 or d2 >= 100 or d3 >= 100:
return 0
# 有顶
if d1 > d2:
return 0
if d3 > d2:
return 0
# 陡：2日D增幅不小于2
dv1 = d2 - d1
# 急：拐弯急
dv2 = d2 - d3
# 高：当前成熟度
h = 100.0 - d3
# 分
# score = (d2-d1)*(d2-d3)*(100-d3)
# score = dv1 * dv2 * (100.0 - d3)
# score = (d2-d1)*(d2-d3)*(10-d3/10)
score = dv1 * dv2 * (10 - d3 / 10.0)
# print score
return score
def ParseMarket(self):
BaseParser.ParseMarket(self)
try:
f = requests.get(self.download_url)
workbook = xlrd.open_workbook(file_contents=f.content)
worksheet = workbook.sheet_by_index(0)
for row_idx in range(3, worksheet.nrows):
row = worksheet.row(row_idx)
market_symbol = {}
market_symbol['code'] = row[0].value.strip() + '.HK'
if market_symbol['code'][0] == '0':
market_symbol['code'] = market_symbol['code'][1:]
market_symbol['name'] = row[1].value.strip()
self.market_symbols.append(market_symbol)
except Exception as e:
print(e)
def isJN(parseDay, id=''):
days = 4
dayList = BaseParser.getPastTradingDayList(parseDay, days)
dataOfDays = KdjParser.getKDJData(parseDay, id, days)
if False == dataOfDays:
return False
'''
N
'''
j1 = float(dataOfDays[dayList[0]][2])
j2 = float(dataOfDays[dayList[1]][2])
j3 = float(dataOfDays[dayList[2]][2])
j4 = float(dataOfDays[dayList[3]][2])
if not ((j4 > j3) and (j3 < j2) and (j2 > j1)):
return False
return True
def isSwallowUp(self, res, parseDay):
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(startPriceOfDay2 - endPriceOfDay3)
# 第2天阴线
if endPriceOfDay2 > startPriceOfDay2:
return False
# 第3天阳线
if endPriceOfDay3 <= startPriceOfDay3:
return False
# 第3天实体长度是第2天的2倍
if (entityOfDay2 != 0) and (entityOfDay3 / entityOfDay2 < 2.618):
return False
# 第3天开盘低于第2天收盘
if endPriceOfDay2 < startPriceOfDay3:
return False
# 第3天收盘大于第2天开盘
if endPriceOfDay3 <= startPriceOfDay2:
return False
# 第3天同时吞没第1天
if min(startPriceOfDay3, endPriceOfDay3) >= min(
startPriceOfDay1, endPriceOfDay1):
return False
if max(startPriceOfDay3, endPriceOfDay3) <= max(
startPriceOfDay1, endPriceOfDay1):
return False
return True
def isPenetrateMa(self, res, parseDay):
dayList = BaseParser.getPastTradingDayList(parseDay, 60)
(v, v, ma) = self.getMAPrice(res, dayList)
startPrice = self.getStartPriceOfDay(res, parseDay)
endPrice = self.getEndPriceOfDay(res, parseDay)
if endPrice <= startPrice:
return False
if startPrice >= ma:
return False
if endPrice <= ma:
return False
return True
def isJW(parseDay, id=''):
days = 5
dayList = BaseParser.getPastTradingDayList(parseDay, days)
dataOfDays = KdjParser.getKDJData(parseDay, id, days)
if False == dataOfDays:
return False
'''
W
'''
j1 = float(dataOfDays[dayList[0]][2])
j2 = float(dataOfDays[dayList[1]][2])
j3 = float(dataOfDays[dayList[2]][2])
j4 = float(dataOfDays[dayList[3]][2])
j5 = float(dataOfDays[dayList[4]][2])
if not ((j5 > j4) and (j4 < j3) and (j3 > j2) and (j2 < j1)):
return False
return True
def getKDJData(parseDay, id, days):
path = Tools.getKdjDataPath() + '/' + id
try:
res = open(path, 'r').read()
if len(res) < 50:
return False
dayList = BaseParser.getPastTradingDayList(parseDay, days)
kdjList = eval(res[13:-1])
dataOfDays = {}
for item in kdjList:
for d in dayList:
if d == item['time']:
dataOfDays[d] = eval(item['kdj'])
except Exception, e:
# pass
# print repr(e)
return False
def isDDeclineDeceleration(parseDay, id):
path = Tools.getKdjDataPath() + '/' + id
try:
res = open(path, 'r').read()
if len(res) < 50:
return False # 交由人工判断
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
kdjList = eval(res[26:-1])
dataOfDays = {}
for item in kdjList:
for d in dayList:
if d == item['time']:
dataOfDays[d] = eval(item['kdj'])
except Exception, e:
pass
# print repr(e)
return False
def parse(self, res, parseDay, id=''):
# 换手率
crStatus = True
dayList = BaseParser.getPastTradingDayList(parseDay, 10)
for day in dayList:
cr = self.getChangeRateOfDay(res, parseDay)
if cr < 0.1 or cr > 0.20:
crStatus = False
break
if not crStatus:
return False
# 区间涨幅
# day1 = dayList[0]
# day2 = dayList[-1]
# endPrice1 = self.getEndPriceOfDay(res,day1)
# endPrice2 = self.getEndPriceOfDay(res,day2)
# gr = (endPrice2 - endPrice1)/endPrice1
# if id == '002464':
# print day1,endPrice1
# print day2,endPrice2
# print gr
# if gr > 0.05:
# return False
# 区间振幅
minPrice = 999999
maxPrice = 0
for day in dayList:
minP = self.getMinPriceOfDay(res, day)
if minP < minPrice:
minPrice = minP
for day in dayList:
maxP = self.getMaxPriceOfDay(res, day)
if maxP > maxPrice:
maxPrice = maxP
ar = (maxPrice - minPrice) / minPrice
if ar > 0.12:
return False
return True
def isSpires(parseDay, id):
path = Tools.getKdjDataPath() + '/' + id
res = open(path, 'r').read()
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
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
d1 = float(dataOfDays[dayList[-3]][1])
d2 = float(dataOfDays[dayList[-2]][1])
d3 = float(dataOfDays[dayList[-1]][1])
if d1 >= 100 or d2 >= 100 or d3 >= 100:
print '-------------------------------------------------->'
return False
# 有顶
# d1 <= d2 >= d3
if d1 > d2:
return False
if d3 > d2:
return False
# # score = dv * r
# # 陡：2日D增幅不小于2
# dv1 = d2 - d1
# # 急：拐弯急
# dv2 = d2 - d3
# # 高：当前成熟度
# h = (100 - d)/10.0
# # 分
# score = dv1 * dv2 * h
return True
def isBiasAllNegative(parseDay,id):
path = Tools.getBiasDataPath()+'/' +id
try:
res = open(path,'r').read()
if len(res) < 50:
return False # 交由人工判断
dayList = BaseParser.getPastTradingDayList(parseDay,2)
biasList = eval(res[26:-1])
dataOfDays = {}
for item in biasList:
for d in dayList:
if d == item['time']:
dataOfDays[d] = eval(item['bias'])
except Exception, e:
pass
# print repr(e)
return False
def isDTopReversal(parseDay, id=''):
path = Tools.getKdjDataPath() + '/' + id
res = open(path, 'r').read()
dayList = BaseParser.getPastTradingDayList(parseDay, 3)
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
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 genKLines(self,res,parseDay):
kLines = {}
dayList = BaseParser.getPastTradingDayList(parseDay,60) # 过去一个季度
splitList = []
for i in xrange(0,12):
splitList.append([i*5,(i+1)*5])
index = 1
for l in splitList:
kLines[index] ={}
kLineDayList = dayList[l[0]:l[1]]
kLines[index]['dayList'] = kLineDayList
kLines[index]['start'] = self.getStartPriceOfDay(res,kLineDayList[0])
kLines[index]['end'] = self.getEndPriceOfDay(res,kLineDayList[-1])
kLines[index]['min'] = self.getMinPriceOfDays(res,kLineDayList)
kLines[index]['max'] = self.getMaxPriceOfDays(res,kLineDayList)
kLines[index]['avg'] = self.getAvgPriceOfDays(res,kLineDayList)
index += 1
return kLines
def getParseResult(self,isDump=False):
idList = []
num = 0
biasFileList = BaseParser.getBiasFileList()
parsedNum = 0
total = len(biasFileList)
for f in biasFileList:
try:
id = f[-6:]
self.printProcess(parsedNum,total)
res = open(f,'r').read()
ret = self.parse(res,self._parseDay,id)
if ret:
idList.append(id)
num += 1
print str(num) + ' ↗'
parsedNum += 1
except Exception, e:
parsedNum += 1
pass
def isKdDeathCross(parseDay, id):
days = 2
dayList = BaseParser.getPastTradingDayList(parseDay, days)
dataOfDays = KdjParser.getKDJData(parseDay, id, days)
if False == dataOfDays:
return False
# D在20之下
# dayLimit = 20
# d = float(dataOfDays[dayList[-1]][1])
# if d > dayLimit or d < 1: # d大于20，或d数据错误
# return False
k1 = float(dataOfDays[dayList[-2]][0])
k2 = float(dataOfDays[dayList[-1]][0])
d = float(dataOfDays[dayList[-1]][1])
if not ((k1 > d) and (k2 < d)):
return False
return True
def parse(self, url):
self.links = []
BaseParser.parse(self, url)
