from jqdata import finance 
from pylab import mpl
from matplotlib.ticker import  MultipleLocator
import pandas as pd
import warnings
import numpy as np
import datetime
import matplotlib.pyplot as plt
import time
import tushare as ts

#过滤警告信息
warnings.filterwarnings("ignore")

#是否是一字板
def isYZB(data, i):
    if data.iloc[i]['open'] == data.iloc[i]['low'] \
    and data.iloc[i]['open'] == data.iloc[i]['close'] \
    and data.iloc[i]['open'] == data.iloc[i]['high_limit'] \
    and data.iloc[i]['close']/data.iloc[i-1]['close'] > 1.09:
        return True
    return False

#是否是涨停
def isUpLimit(data, i):
    if data.iloc[i]['high_limit'] == data.iloc[i]['close']\
    and data.iloc[i]['close']/data.iloc[i-1]['close'] > 1.09 :
        return True
    return False

cntUpLmtTime1 = 0
cntUpLmtTime2 = 0
cntUpLmtDay = ''

#计算涨停数
def countUpLimit(data, day, stock):
    #最后一条数据索引
    lastIndex = data.shape[0]-1
    if not isUpLimit(data, lastIndex):
        return 0
    i = lastIndex
    upLimitCnt = 0
    while i >= 0:
        if isUpLimit(data, i):
            upLimitCnt += 1
            i -= 1
        else:
            break
    #如果涨停前面几天都是一字板，那么不算，从可以买入的那天开始算
    firstUpLmt = lastIndex-upLimitCnt+1
    i = firstUpLmt
    while i < lastIndex:
        if isYZB(data, i):
            upLimitCnt -= 1  #减去一字板个数
            i += 1
        else:
            break
    return upLimitCnt

#计算最大值所在列名        
def calcMaxIndex(row):#对每一行处理的函数
    maxValues = row[row==row['max']].dropna(how='all')
    codes = maxValues.index.tolist()
    codes.remove('max')
    row['code'] = codes
    return row

#格式化tushare日期为聚宽格式
def formatTSDateToJoint(data):
    for i in range(len(data)):
        item = data[i]
        data[i] = item[0:4]+'-'+item[4:6]+'-'+item[6:8]
    return data

def formatDate(data):
    for i in range(len(data)):
        data[i] = data[i][:10]
        
    return data

print('\n-------------开始制作-------------')
startTime = time.clock()
#开始统计日期
startDate = '2018-05-01'
startDate = (datetime.datetime.now()+datetime.timedelta(days=-330)).strftime("%Y-%m-%d")
#结束统计日期
endDate = '2019-02-11'
#endDate = (datetime.datetime.now()+datetime.timedelta(days=-1)).strftime("%Y-%m-%d")
#由于聚宽的接口不能没有提供上交所，深交所的交易日期数据，所以使用tushare的
#机智得使用指数行情来获取交易日期^_^
tradeDates = get_price('399001.XSHE', start_date=startDate, end_date=endDate, \
                                 frequency='daily', fields=['open'],\
                                 skip_paused=True, fq='pre')
tradeDates = tradeDates.index.tolist()
#-----------TODO调试代码-----------
#开始统计，如果是次新，那么就去除前20天的数据，这里只统计2018至今的连板
#取得市值符合条件的股票
stocks = get_fundamentals(query(
          valuation.code, valuation.market_cap, valuation.pe_ratio, income.total_operating_revenue
      ).filter(
          valuation.circulating_market_cap < 150,
          valuation.circulating_market_cap > 5
      ).order_by(
          # 按市值降序排列
          valuation.circulating_market_cap.desc()
      ), date = endDate)
stocks = stocks['code'].tolist()

#连板统计结果
continuousLimit = pd.DataFrame([], index=tradeDates)
print('日期和股票准备就绪，耗时%.2f' % (time.clock()-startTime) )

for i in range(30, len(tradeDates)):
    #-----------统计当天最高的连板天数----------------------
    day = tradeDates[i]
    dayProcessTime = time.clock()
    callServerTime = 0
    countUpLimitTime = 0
    cnt = 0
    if '399001.XSHE' not in continuousLimit.columns:
        continuousLimit['399001.XSHE'] = [0]*continuousLimit.shape[0]
    continuousLimit.loc[day, '399001.XSHE'] = 1
    for stock in stocks:
        #print('正在处理：%s %s' % (day, stock))
        #获取历史行情，如果有停牌，那么这个startDate就不能这么取，默认多取20条，
        #也就是停牌超过10交易日很可能就没法统计了
        startDate = tradeDates[0]
        if tradeDates.index(day) > 30:
            startDate = tradeDates[tradeDates.index(day)-30]
        callServerStart = time.clock()
        historyPrice = get_price(stock, start_date=startDate, end_date=day, \
                                 frequency='daily', fields=['open', 'low', 'close', 'high_limit'],\
                                 skip_paused=True, fq='pre')
        callServerTime = callServerTime+time.clock()-callServerStart
        #如果提前30天取数据还不够15条，那么说明停牌时间过长，不在考虑范围
        if historyPrice.shape[0] < 15:
            continue
        latestRow = historyPrice.tail(1)
        #如果最新一条数据不是当天数据，那么是停牌，不统计
        if day not in latestRow.index:
            continue
        countUpLimitStart = time.clock()
        #计算每天个股的连板数
        cnt = countUpLimit(historyPrice, day, stock)
        if cnt >= 1:
            if stock not in continuousLimit.columns:
                continuousLimit[stock] = [0]*continuousLimit.shape[0]
            continuousLimit.loc[day, stock] = cnt  #这个loc非常耗时，无用数据就别存了
        
    progress = ((i-29)/(len(tradeDates)-30))*100
    remainingTime = (time.clock()-dayProcessTime)*(len(tradeDates)-i)
    remainingTime = remainingTime/60
    dayProcessTime = time.clock()-dayProcessTime
    print('%s日处理耗时：%.2f秒=>get_price耗时：%.2f秒，进度：%d%%，预计剩余时间：%.2f分钟' % \
          (day.strftime("%Y-%m-%d"), dayProcessTime, callServerTime, progress, remainingTime))
#计算每天的最高连板数
continuousLimit = continuousLimit[continuousLimit>=1]    
continuousLimit = continuousLimit.dropna(axis=0, how='all')  
continuousLimit = continuousLimit.dropna(axis=1, how='all') 
continuousLimit = continuousLimit.fillna(0)
continuousLimit['max'] = continuousLimit.max(axis=1)
continuousLimit = continuousLimit.apply(lambda x:calcMaxIndex(x),axis=1)
#由于上面公式添加列名之后没有新加列名字，默认为0，所以要替换掉最后一个列名
cols = continuousLimit.columns.tolist()
cols[len(cols)-1] = 'code'
continuousLimit.columns = cols

#保存到文件供下次直接读取分析
continuousLimit.to_csv('./output/continuousLimit.csv', encoding='utf_8_sig')

print('数据统计完毕!')
workTime = int(time.clock()-startTime)/60
print('总处理耗时：%.2f分钟' % workTime)

from jqdata import finance 
from pylab import mpl
from matplotlib.ticker import  MultipleLocator
import pandas as pd
import warnings
import numpy as np
import datetime
import matplotlib.pyplot as plt
import time
import tushare as ts
from mpl_toolkits.axisartist.parasite_axes import HostAxes, ParasiteAxes

#计算最大值所在列名        
def calcMaxIndex(row):#对每一行处理的函数
    maxValues = row[row==row['max']].dropna(how='all')
    codes = maxValues.index.tolist()
    codes.remove('max')
    row['code'] = codes
    return row
#continuousLimit = pd.read_csv('./output/continuousLimit2014_2015.csv', index_col=0, header=0)
continuousLimit = pd.read_csv('./output/continuousLimit.csv', index_col=0, header=0)

continuousLimit = continuousLimit[:70]
#由于文件中的code数组无法取值，所以这里需要重新计算一遍
continuousLimit = continuousLimit.apply(lambda x:calcMaxIndex(x),axis=1)
#由于上面公式添加列名之后没有新加列名字，默认为0，所以要替换掉最后一个列名
cols = continuousLimit.columns.tolist()
cols[len(cols)-1] = 'code'
continuousLimit.columns = cols


indexPrice = get_price('000001.XSHG', start_date='2016-01-01', end_date='2020-01-01', \
                                 frequency='daily', fields=['close'],\
                                 skip_paused=True, fq='pre')
tradeDates = indexPrice.index.tolist()
for i in range(0, len(tradeDates)):
    tradeDates[i] = str(tradeDates[i])[0:10]

print('数据准备就绪，开始制图、、、')
'''
'''
#绘制指数图
#Y轴最大最小值
maxContLimit = max(continuousLimit['max'].tolist())+1
minContLimit = min(continuousLimit['max'].tolist())-1
figsizeX = continuousLimit.shape[0]*3
figsizeY = (maxContLimit-minContLimit)*3

mpl.rcParams.update({'font.size': 16})
mpl.rcParams['font.sans-serif'] = ['SimHei']
mpl.rcParams['axes.unicode_minus'] = False # 解决保存图像是负号'-'显示为方块的问题,或者转换负号为字
dates = continuousLimit.index.tolist()
x = np.arange(len(dates))
periodIndexPrices = indexPrice[dates[0]:dates[-1]]
periodIndexPrices = periodIndexPrices['close'].tolist()
periods = continuousLimit['max'].tolist()
maxIndexPrice = max(periodIndexPrices)+30
minIndexPrice = min(periodIndexPrices)-30

fig, axPeriod = plt.subplots() 
fig.set_figwidth(figsizeX)
fig.set_figheight(figsizeY)
axPeriod.plot(x, periods, 'r*-', ms=25)
axPeriod.set_xticks(x)
axPeriod.set_xticklabels(dates)
axPeriod.set_xlabel("日期")
axPeriod.set_ylabel("连板数")
axPeriod.set_ylim(minContLimit, maxContLimit)
for xtick in axPeriod.get_xticklabels():
    xtick.set_rotation(50)
    
axIndex = axPeriod.twinx()
axIndex.plot(x, periodIndexPrices, 'o-')
axIndex.set_ylabel("上证指数")
axIndex.set_ylim(minIndexPrice, maxIndexPrice)



#面王统计
noodleKings = []
noodleKingCnt = 0

for i in range(continuousLimit.shape[0]):
    #最高板BEGIN
    #这里是统计今天的龙头，所以用今天的数据
    rowData = continuousLimit.iloc[i]
    stockName = '>>>>>龙 头<<<<<'
    codes = rowData['code']
    for j in range(len(codes)):
        if '399001' in codes[j]:
            continue
        stockName += '\n'
        stock = codes[j]
        stockName +=  get_security_info(stock).display_name
    #连板数   ----------------------------
    contLimit = rowData['max']
    xTextPos = i  #x轴文字位置
    yTextPos = contLimit  #y轴文字位置
    if yTextPos >= 7:
        yTextPos = yTextPos-1
        xTextPos += 0.05
    elif yTextPos == 1:
        yTextPos = 1.3
    else:
        yTextPos += 0.3
    if i == continuousLimit.shape[0]-1:
        xTextPos = i
    elif i == 0:
        xTextPos = i+0.15
    stockName += '['+str(int(contLimit))+']'
    #最高板END
    
    #中军BEGIN
    rowData = continuousLimit.iloc[i]  #注意是前一天的数据
    rowData.pop('code')
    rowData.pop('max')
    startDate = continuousLimit.index.tolist()[i-1]
    endDate = continuousLimit.index.tolist()[i]
    for stock,boards in rowData.iteritems():
        if 3>rowData[stock]:
            continue
        '''
        price = get_price(stock, start_date=startDate, end_date=endDate, \
                             frequency='daily', fields=['open','close','high','high_limit'],\
                             skip_paused=True, fq='pre')    
        if price.empty or price.shape[0]!=2:
            continue
            '''
        #把4板及以上的也加进去
        if rowData[stock] >= 3: 
            name = get_security_info(stock).display_name
            if '中 军' not in stockName:    
                stockName += '\n>>>>>中 军<<<<<'
            if name not in stockName:
                #计算强度
                stockName += '\n'+name+'['+str(int(rowData[stock]))+']'
    #中军END
    stockName += '\n--------------------'
    
    #炸板率 -------------------------------
    fail2For3 = 0
    success2For3 = 0
    fail3For4 = 0
    success3For4 = 0
    fail4For5 = 0
    success4For5 = 0
    fail5For6 = 0
    success5For6 = 0
    rushBoardStocks = {
        'fail2For3':'',
        'success2For3':'',
        'fail3For4':'',
        'success3For4':'',
        'fail4For5':'',
        'success4For5':'',
        'fail5For6':'',
        'success5For6':''
    }
    #拿昨天的连板数据统它们在今天的强度和晋级情况
    if i>0:
        #昨日连板强度BEGIN
        rowData = continuousLimit.iloc[i-1]  #注意是前一天的数据
        rowData.pop('code')
        rowData.pop('max')
        startDate = continuousLimit.index.tolist()[i-1]
        endDate = continuousLimit.index.tolist()[i]
        for stock,boards in rowData.iteritems():
            if 0==rowData[stock]:
                continue
            price = get_price(stock, start_date=startDate, end_date=endDate, \
                                 frequency='daily', fields=['open','close','high','high_limit'],\
                                 skip_paused=True, fq='pre')    
            if price.empty or price.shape[0]!=2:
                continue
            #把4板及以上的也加进去
            if rowData[stock] >= 3: 
                name = get_security_info(stock).display_name
                if name not in stockName:
                    if '今日掉队' not in stockName:    
                        stockName += '\n>>>>今日掉队<<<<'
                    #计算强度
                    strength = (price.iloc[1]['close']/price.iloc[0]['close']-1)*100
                    stockName += '\n'+name+str(' {:.0f}%').format(strength)
                    stockName += '['+str(int(rowData[stock]))+']'
        #昨日连板强度END
            
            #停牌就懒得处理了
            #因为之前统计的是明日的炸板率，所以有炸板情况，但是改成统计今天的炸板率，因为这个循环里面都是今天涨停的，所以有问题
            #这里得拿昨天的数据
            if price.iloc[1]['high'] == price.iloc[1]['high_limit']:
                if price.iloc[1]['high_limit'] == price.iloc[1]['close']:
                    if 2==rowData[stock]:
                        success2For3 += 1
                        rushBoardStocks['success2For3'] += str(stock)+','
                    elif 3==rowData[stock]:
                        success3For4 += 1
                        rushBoardStocks['success3For4'] += str(stock)+','
                    elif 4==rowData[stock]:
                        success4For5 += 1
                        rushBoardStocks['success4For5'] += str(stock)+','
                    elif 5==rowData[stock]:
                        success5For6 += 1
                        rushBoardStocks['success5For6'] += str(stock)+','
                else:
                    if 2==rowData[stock]:
                        fail2For3 += 1
                        rushBoardStocks['fail2For3'] += str(stock)+','
                    elif 3==rowData[stock]:
                        fail3For4 += 1
                        rushBoardStocks['fail3For4'] += str(stock)+','
                    elif 4==rowData[stock]:
                        fail4For5 += 1
                        rushBoardStocks['fail4For5'] += str(stock)+','
                    elif 5==rowData[stock]:
                        fail5For6 += 1
                        rushBoardStocks['fail5For6'] += str(stock)+','
    #面霸统计，这里需要特别注意的是要拿前天和昨天的连板股来统计，前天的连板股，昨天跌一天或者炸板，今天再跌一天
    #昨天的连板今天炸板跌，或者直接跌2种情况
    #计算都是用这三天的数据来计算
        #昨天连板个股
        rowData = continuousLimit.iloc[i-1]
        rowData.pop('code')
        rowData.pop('max')
        for stock,boards in rowData.iteritems():
            if 0==rowData[stock]:
                continue
            noodleKings.append(stock)  #当日所有连板个股都加入面霸统计
        #前天连板个股
        rowData = continuousLimit.iloc[i-2]
        rowData.pop('code')
        rowData.pop('max')
        for stock,boards in rowData.iteritems():
            if 0==rowData[stock]:
                continue
            noodleKings.append(stock)  #当日所有连板个股都加入面霸统计
        startDate = continuousLimit.index.tolist()[i-2]
        endDate = continuousLimit.index.tolist()[i]
        if len(noodleKings) > 0:
            for item in noodleKings:
                #拿到最新2天的数据，检查最近2天是否有炸板，有炸板就从炸板的涨停价开始算，没有就用第三天的收盘价算
                noodlePrice = get_price(item, start_date=startDate, end_date=endDate, \
                        frequency='daily', fields=['close','high','high_limit'],\
                        skip_paused=True, fq='pre')    
                if noodlePrice.shape[0] == 3:
                    #默认从T-2收盘价开始算
                    downStart = noodlePrice.iloc[0]['close']
                    #如果炸板，那么从涨停价开始算
                    if noodlePrice.iloc[1]['high'] == noodlePrice.iloc[1]['high_limit'] \
                        and noodlePrice.iloc[1]['close'] != noodlePrice.iloc[1]['high_limit']:
                        #T-1天炸板，那么从
                        downStart = noodlePrice.iloc[1]['high']
                    if noodlePrice.iloc[2]['high'] == noodlePrice.iloc[2]['high_limit'] \
                        and noodlePrice.iloc[2]['close'] != noodlePrice.iloc[2]['high_limit']:
                        downStart = noodlePrice.iloc[2]['high']
                    downRate = (1 - noodlePrice.iloc[2]['close']/downStart)*100
                    if downRate >= 15:
                        name = get_security_info(item).display_name
                        noodleKingCnt += 1
    noodleKings = []  #清空，以便统计下一个交易日
    explodeRate = ''
    if fail4For5+success4For5+fail3For4+success3For4+fail2For3+success2For3>0:
        stockName += '\n>>>>梯队晋级<<<<'
    if (fail4For5+success4For5)>0:
        explodeRate = '\n4进5={:.0f}败/{:.0f}成'.format(fail4For5, success4For5)
        stockName += explodeRate
    if (fail3For4+success3For4)>0:
        explodeRate = '\n3进4={:.0f}败/{:.0f}成'.format(fail3For4, success3For4)
        stockName += explodeRate   
    if (fail2For3+success2For3)>0:
        explodeRate = '\n2进3={:.0f}败/{:.0f}成'.format(fail2For3, success2For3)
        stockName += explodeRate
    if noodleKingCnt>0:
        stockName += '\n----面霸{:.0f}个----'.format(noodleKingCnt)
    axPeriod.annotate(stockName, xy=(i, contLimit), \
                 xytext=(xTextPos, yTextPos), xycoords='data',\
                arrowprops=dict(facecolor='#4DFFFF', shrink=0.01))
    noodleKingCnt = 0
plt.savefig("./output/龙头周期.png") # save as png
plt.show()
print('制作完毕!')

import pandas as pd

continuousLimit = pd.read_csv('./output/continuousLimit.csv', index_col=0, header=0)
'''
dateIndex=continuousLimit.index.tolist().index('2019-05-06')
print(continuousLimit[dateIndex-1:dateIndex+4])
continuousLimit = continuousLimit[-60:]
'''

totalFail2For3 = 0
totalSuccess2For3 = 0
totalFail3For4 = 0
totalSuccess3For4 = 0
totalFail4For5 = 0
totalSuccess4For5 = 0
totalFail5For6 = 0
totalSuccess5For6 = 0
for i in range(1, (continuousLimit.shape[0])):
    rowData = continuousLimit.iloc[i-1]
    startDate = continuousLimit.index.tolist()[i-1]
    endDate = continuousLimit.index.tolist()[i]
    stockName = ''
    rowData.pop('code')
    rowData.pop('max')
    fail2For3 = 0
    success2For3 = 0
    fail3For4 = 0
    success3For4 = 0
    fail4For5 = 0
    success4For5 = 0
    fail5For6 = 0
    success5For6 = 0
    rushBoardStocks = {
        'fail2For3':'',
        'success2For3':'',
        'fail3For4':'',
        'success3For4':'',
        'fail4For5':'',
        'success4For5':'',
        'fail5For6':'',
        'success5For6':''
    }
    for stock,boards in rowData.iteritems():
        if 0==rowData[stock]:
            continue
        price = get_price(stock, start_date=endDate, end_date=endDate, \
                             frequency='daily', fields=['close','high','high_limit'],\
                             skip_paused=True, fq='pre')    
        if price.empty:
            continue
        #停牌就懒得处理了
        if price.iloc[0]['high'] == price.iloc[0]['high_limit']:
            if price.iloc[0]['high_limit'] == price.iloc[0]['close']:
                if 2==rowData[stock]:
                    success2For3 += 1
                    totalSuccess2For3 += 1
                    rushBoardStocks['success2For3'] += str(stock)+','
                elif 3==rowData[stock]:
                    success3For4 += 1
                    totalSuccess3For4 += 1
                    rushBoardStocks['success3For4'] += str(stock)+','
                elif 4==rowData[stock]:
                    success4For5 += 1
                    totalSuccess4For5 += 1
                    rushBoardStocks['success4For5'] += str(stock)+','
                elif 5==rowData[stock]:
                    success5For6 += 1
                    totalSuccess5For6 += 1
                    rushBoardStocks['success5For6'] += str(stock)+','
            else:
                if 2==rowData[stock]:
                    fail2For3 += 1
                    totalFail2For3 += 1
                    rushBoardStocks['fail2For3'] += str(stock)+','
                elif 3==rowData[stock]:
                    fail3For4 += 1
                    totalFail3For4 += 1
                    rushBoardStocks['fail3For4'] += str(stock)+','
                elif 4==rowData[stock]:
                    fail4For5 += 1
                    totalFail4For5 += 1
                    rushBoardStocks['fail4For5'] += str(stock)+','
                elif 5==rowData[stock]:
                    fail5For6 += 1
                    totalFail5For6 += 1
                    rushBoardStocks['fail5For6'] += str(stock)+','
    print('------------------------------------')     
    print(endDate)
    if (fail2For3+success2For3)>0:
        print('----2进3炸板率为%.0f%% \n 失败:%s \n 成功:%s' \
              %(fail2For3*100/(fail2For3+success2For3), \
                rushBoardStocks['fail2For3'], rushBoardStocks['success2For3']))  
    if (fail3For4+success3For4)>0:
        print('----3进4炸板率为%.0f%%\n 失败:%s \n 成功:%s' \
              %(fail3For4*100/(fail3For4+success3For4), \
                rushBoardStocks['fail3For4'], rushBoardStocks['success3For4']))  
    if (fail4For5+success4For5)>0:
        print('----4进5炸板率为%.0f%%\n 失败:%s \n 成功:%s' \
              %(fail4For5*100/(fail4For5+success4For5), \
                rushBoardStocks['fail4For5'], rushBoardStocks['success4For5']))  
    if (fail5For6+success5For6)>0:
        print('----5进6炸板率为%.0f%%\n 失败:%s \n 成功:%s' \
              %(fail5For6*100/(fail5For6+success5For6), \
                rushBoardStocks['fail5For6'], rushBoardStocks['success5For6']))   
print('----------------------\n整体炸板率统计：')        
if (totalFail2For3+totalSuccess2For3)>0:
    print('----2进3炸板率为%.0f%%'  %(totalFail2For3*100/(totalFail2For3+totalSuccess2For3)))  
if (totalFail3For4+totalSuccess3For4)>0:
    print('----3进4炸板率为%.0f%%' %(totalFail3For4*100/(totalFail3For4+totalSuccess3For4)))  
if (totalFail4For5+totalSuccess4For5)>0:
    print('----4进5炸板率为%.0f%%' %(totalFail4For5*100/(totalFail4For5+totalSuccess4For5)))  
if (totalFail5For6+totalSuccess5For6)>0:
    print('----5进6炸板率为%.0f%%' %(totalFail5For6*100/(totalFail5For6+totalSuccess5For6)))   

import pandas as pd

continuousLimit = pd.read_csv('./output/continuousLimit.csv', index_col=0, header=0)
continuousLimit = continuousLimit[-60:]


stocks = ''
for index, rowData in continuousLimit.iterrows():
    rowData.pop('max')
    rowData.pop('code')
    rowData = rowData[rowData==3]
    size = rowData.size
    cnt += size
    if size>0:
        stocks += str(rowData.index.tolist())
print(stocks)

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as mtick
from pylab import mpl


#plt.rcdefaults()
mpl.rcParams['font.sans-serif'] = ['SimHei'] #解决绘图中文显示问题
mpl.rcParams['axes.unicode_minus'] = False   # 解决保存图像是负号'-'显示为方块的问题

info_list = [(u"小给", 88, 23), (u"小人", 78, 10), (u"小民", 90, 5), (u"小一", 66, 9), (u"小个", 80, 22), (u"小胶", 48, 5), (u"小带", 77, 19)]
positions = np.arange(len(info_list))
names = [row[0] for row in info_list]
scores = [row[1] for row in info_list]
proges = [row[2] for row in info_list]

fig, ax1 = plt.subplots()

# 成绩直方图
ax1.bar(positions, scores, width=0.6, align='center', color='r', label=u"成绩")
ax1.set_xticks(positions)

ax1.set_xticklabels(names)
ax1.set_xlabel(u"名字")
ax1.set_ylabel(u"成绩")
max_score = max(scores)
ax1.set_ylim(0, int(max_score * 1.2))
# 成绩标签
for x,y in zip(positions, scores):
    ax1.text(x, y + max_score * 0.02, y, ha='center', va='center', fontsize=13)

# 变动折线图
ax2 = ax1.twinx()
ax2.plot(positions, proges, 'o-', label=u"进步幅度")
max_proges = max(proges)
# 变化率标签
for x,y in zip(positions, proges):
    ax2.text(x, y + max_proges * 0.02, ('%.1f%%' %y), ha='center', va= 'bottom', fontsize=13)
# 设置纵轴格式
fmt = '%.1f%%'
yticks = mtick.FormatStrFormatter(fmt)
ax2.yaxis.set_major_formatter(yticks)
ax2.set_ylim(0, int(max_proges * 1.2))
ax2.set_ylabel(u"进步幅度")

# 图例
#handles1, labels1 = ax1.get_legend_handles_labels()
#handles2, labels2 = ax2.get_legend_handles_labels()
#plt.legend(handles1+handles2, labels1+labels2, loc='upper right')

plt.show()