sports_scrapy/hg3535/spiders/lanqiu.py

# -*- coding: utf-8 -*-
import copy
import datetime
import json
import scrapy
from scrapy.http import Request

from ..items import Lanqiu


def rangqiu_daxiao(inner, pt):
    concede = [inner[i] for i in range(len(inner)) if i % 2 is 1]
    # 主队让球条件赔率
    concedehome = [concede[i] for i in range(len(concede)) if i % 2 is 0]
    # 客队让球条件赔率
    concedeguest = [concede[i] for i in range(len(concede)) if i % 2 is 1]
    # 主队让球条件
    concede_home_rule = [concedehome[i] for i in range(len(concedehome)) if i % 2 == 0]
    # 客队让球条件
    concede_guest_rule = [concedeguest[i] for i in range(len(concedeguest)) if i % 2 == 0]
    # 客队让球赔率
    if pt is 3:
        concede_guest = [float(concedeguest[i]) - 1 for i in range(len(concedeguest)) if i % 2 is 1]
        # 主队让球赔率
        concede_home = [float(concedehome[i]) - 1 for i in range(len(concedehome)) if i % 2 is 1]
    else:
        concede_home = [concedehome[i] for i in range(len(concedehome)) if i % 2 is 1]
        concede_guest = [concedeguest[i] for i in range(len(concedeguest)) if i % 2 is 1]
    return concede_home_rule, concede_home, concede_guest_rule, concede_guest


def danshaung_fun(inner):
    odd_even = [inner[i] for i in range(len(inner)) if i % 2 is 1]
    # 全场 总分单
    odd_even_odd = [odd_even[i] for i in range(len(odd_even)) if i % 2 is 0]
    # 全场 总分双
    odd_even_even = [odd_even[i] for i in range(len(odd_even)) if i % 2 is 1]
    return odd_even_odd, odd_even_even


class LanqiuSpider(scrapy.Spider):
    name = "lanqiu"
    to_day = datetime.datetime.now()
    allowed_domains = ['hg3535z.com']
    custom_settings = {
        "ITEM_PIPELINES": {
            "hg3535.pipeline.lanqiu.Lanqiupipeline": 300,
            # 'hg3535.pipeline.zuqiu.Zuqiupipeline': 300,
        },
        # 'LOG_LEVEL': 'DEBUG',
        # 'LOG_FILE': "../hg3535/log/lanqiu_{}_{}_{}.log".format(to_day.year, to_day.month, to_day.day)
    }

    def start_requests(self):
        # newall_lists = ['am', 'ftht1x2', 'oe', 'tg', 'htft', 'cs', 'fglg', 'or']
        for y in range(1, 4):
            # url = 'https://hg3535z.com/odds2/d/getodds?sid=2&pt='+str(y)+'&ubt=am&pn=0&sb=2&dc=null&pid=0'
            url = "https://odata.jiushan6688.com/odds6i/d/getodds/zh-cn/sid/2/pt/" + str(
                y) + "/ubt/am/pn/0/sb/2/dc/null/pid/0"
            yield scrapy.Request(url=url, callback=self.parse, dont_filter=True, meta={'pt': y})
            # yield scrapy.Request(url=url, callback=self.parse, meta={'pt': y}, dont_filter=True)

    def parse(self, response):
        if response.text:
            try:
                datas = json.loads(response.text).get('n-ot', "").get('egs', "")
            except:
                datas = ""
            try:
                pt = copy.copy(response.meta['pt'])
            except:
                pt = 0
            if datas:
                # id_list = []
                for result in datas:
                    new_results = result['es']
                    for new_result in new_results:
                        game_id = str(new_result['i'][16])
                        if pt == 1:
                            # url = "https://hg3535z.com/odds2/d/getamodds?eid=" + game_id + "&iip=false&ubt=am&isp=false"
                            url = "https://odata.jiushan6688.com/odds6i/d/getamodds/zh-cn/eid/" + game_id + "/iip/false/ubt/am/isp/false"
                            yield Request(url=url, callback=self.parse_each, meta={'pt': pt}, dont_filter=True)
                        if pt == 2:
                            # url = "https://hg3535z.com/odds2/d/getamodds?eid=" + game_id + "&iip=false&ubt=am&isp=false"
                            url = "https://odata.jiushan6688.com/odds6i/d/getamodds/zh-cn/eid/" + game_id + "/iip/false/ubt/am/isp/false"
                            yield Request(url=url, callback=self.parse_each, meta={'pt': pt}, dont_filter=True)
                        if pt == 3:
                            # url = "https://hg3535z.com/odds2/d/getamodds?eid=" + game_id + "&iip=false&ubt=am&isp=true"
                            url = "https://odata.jiushan6688.com/odds6i/d/getamodds/zh-cn/eid/" + game_id + "/iip/false/ubt/am/isp/true"
                            yield Request(url=url, callback=self.parse_each, meta={'pt': pt}, dont_filter=True)

    def parse_each(self, response):
        try:
            new_datas = json.loads(response.text)['eg']
            pt = response.meta['pt']
            lanqiu = json.loads(response.text)['i'][31]
        except:
            pt = 0
            new_datas = ""
            lanqiu = ""
        item = Lanqiu()
        if new_datas:
            # 联赛id
            league_id = new_datas.get("c", "").get("k", "")
            # 联赛名
            league_name = new_datas.get("c", "").get("n", "")
            new_data = new_datas.get("es", "")
            team_scores_dict = {}
            team_scores_dict_rule = {}
            concedes_dict = {}
            concedes_dict_rule = {}
            total_sizes_dict = {}
            total_sizes_dict_rule = {}
            odd_evens_dict = {}
            odd_evens_dict_rule = {}
            last_numbers_dict = {}
            capots_dict = {}
            data = []
            for result in new_data:
                if result['pci']['ctid'] == 0:
                    # 比赛id
                    game_id = str(result['k'])
                    data.append(game_id)
                    # 球队1
                    team_home = result['i'][0]
                    data.append(team_home)
                    # 球队2
                    team_guest = result['i'][1]
                    data.append(team_guest)
                    # 数量(97>)
                    number = result['i'][2]
                    data.append(number)
                    # 比赛状态
                    zhuangtai = result['i'][3]
                    data.append(zhuangtai)
                    # 日期
                    data_game = result['i'][4]
                    data.append(data_game)
                    # 开赛时间
                    time_game = result['i'][5]
                    data.append(time_game)
                    # 队1分数
                    score_home1 = result['i'][10]
                    data.append(score_home1)
                    # 队2分数
                    score_guest1 = result['i'][11]
                    data.append(score_guest1)
                    # 第几节
                    jijie = result['i'][12]
                    data.append(jijie)
                    # 球队得分
                    qiudui = result['pci'].get('ctn', "")
                    data.append(qiudui)

                    # ----------------------------------------让球分割线---------------------------------------------------------------------
                    try:
                        concedes = result['o']["ah"]["v"]
                        # print(concedes)
                        # 主队让球条件,主队让球赔率,客队让球条件,客队让球赔率
                        concede_home_rule, concede_home, concede_guest_rule, concede_guest = rangqiu_daxiao(
                            inner=concedes, pt=pt)
                        concedes_dict_rule['concede_home'] = concede_home_rule
                        concedes_dict['concede_home'] = concede_home
                        concedes_dict_rule['concede_guest'] = concede_guest_rule
                        concedes_dict['concede_guest'] = concede_guest
                    except:
                        # concede_guest = ""
                        # concede_guest_rule = ""
                        # concede_home = ""
                        # concede_home_rule = ""
                        concedes_dict_rule['concede_home'] = None
                        concedes_dict['concede_home'] = None
                        concedes_dict_rule['concede_guest'] = None
                        concedes_dict['concede_guest'] = None
                    # print(concedes_dict)
                    try:
                        half_concedes = result['o']["ah1st"]["v"]
                        # 上半场 主队让球条件
                        half_concede_home_rule, half_concede_home, half_concede_guest_rule, half_concede_guest = rangqiu_daxiao(
                            inner=half_concedes, pt=pt)
                        concedes_dict_rule['half_concede_home'] = half_concede_home_rule
                        concedes_dict['half_concede_home'] = half_concede_home
                        concedes_dict_rule['half_concede_guest'] = half_concede_guest_rule
                        concedes_dict['half_concede_guest'] = half_concede_guest

                    except:
                        # half_concede_home_rule = ""
                        # half_concede_home = ""
                        # half_concede_guest_rule = ""
                        # half_concede_guest = ""
                        concedes_dict_rule['half_concede_home'] = None
                        concedes_dict['half_concede_home'] = None
                        concedes_dict_rule['half_concede_guest'] = None
                        concedes_dict['half_concede_guest'] = None

                    # 第一节让球
                    try:
                        one_concedes = result['o']["ahq1"]["v"]
                        one_concede_home_rule, one_concede_home, one_concede_guest_rule, one_concede_guest = rangqiu_daxiao(
                            inner=one_concedes, pt=pt)
                        concedes_dict_rule['one_concede_home'] = one_concede_home_rule
                        concedes_dict['one_concede_home'] = one_concede_home
                        concedes_dict_rule['one_concede_guest'] = one_concede_guest_rule
                        concedes_dict['one_concede_guest'] = one_concede_guest

                    except:
                        # one_concede_guest = ""
                        # one_concede_guest_rule = ""
                        # one_concede_home = ""
                        # one_concede_home_rule = ""
                        concedes_dict_rule['one_concede_home'] = None
                        concedes_dict['one_concede_home'] = None
                        concedes_dict_rule['one_concede_guest'] = None
                        concedes_dict['one_concede_guest'] = None
                    # 第二节让球
                    try:
                        two_concedes = result['o']["ahq2"]["v"]
                        two_concede_home_rule, two_concede_home, two_concede_guest_rule, two_concede_guest = rangqiu_daxiao(
                            inner=two_concedes, pt=pt)
                        concedes_dict_rule['two_concede_home'] = two_concede_home_rule
                        concedes_dict['two_concede_home'] = two_concede_home
                        concedes_dict_rule['two_concede_guest'] = two_concede_guest_rule
                        concedes_dict['two_concede_guest'] = two_concede_guest
                    except:
                        # two_concede_guest = ""
                        # two_concede_guest_rule = ""
                        # two_concede_home = ""
                        # two_concede_home_rule = ""
                        concedes_dict_rule['two_concede_home'] = None
                        concedes_dict['two_concede_home'] = None
                        concedes_dict_rule['two_concede_guest'] = None
                        concedes_dict['two_concede_guest'] = None
                    # 第三节让球
                    try:
                        three_concedes = result['o']["ahq3"]["v"]
                        three_concede_home_rule, three_concede_home, three_concede_guest_rule, three_concede_guest = rangqiu_daxiao(
                            inner=three_concedes, pt=pt)
                        concedes_dict_rule['three_concede_home'] = three_concede_home_rule
                        concedes_dict['three_concede_home'] = three_concede_home
                        concedes_dict_rule['three_concede_guest'] = three_concede_guest_rule
                        concedes_dict['three_concede_guest'] = three_concede_guest

                    except:
                        # three_concede_guest = ""
                        # three_concede_guest_rule = ""
                        # three_concede_home = ""
                        # three_concede_home_rule = ""
                        concedes_dict_rule['three_concede_home'] = None
                        concedes_dict['three_concede_home'] = None
                        concedes_dict_rule['three_concede_guest'] = None
                        concedes_dict['three_concede_guest'] = None
                    # 第四节让球
                    try:
                        four_concedes = result['o']["ahq4"]["v"]
                        four_concede_home_rule, four_concede_home, four_concede_guest_rule, four_concede_guest = rangqiu_daxiao(
                            inner=four_concedes, pt=pt)
                        concedes_dict_rule['four_concede_home'] = four_concede_home_rule
                        concedes_dict['four_concede_home'] = four_concede_home
                        concedes_dict_rule['four_concede_guest'] = four_concede_guest_rule
                        concedes_dict['four_concede_guest'] = four_concede_guest

                    except:
                        # four_concede_guest = ""
                        # four_concede_guest_rule = ""
                        # four_concede_home = ""
                        # four_concede_home_rule = ""
                        concedes_dict_rule['four_concede_home'] = None
                        concedes_dict['four_concede_home'] = None
                        concedes_dict_rule['four_concede_guest'] = None
                        concedes_dict['four_concede_guest'] = None
                    # ----------------------------------------总分大小分割线 - ---------------------------------------------------------------
                    # 全场总分大小
                    try:
                        total_sizes = result['o']["ou"]["v"]
                        total_sizes_big_rule, total_sizes_big, total_sizes_small_rule, total_sizes_small = rangqiu_daxiao(
                            inner=total_sizes, pt=pt)
                        total_sizes_dict_rule["total_size_big"] = total_sizes_big_rule
                        total_sizes_dict["total_size_big"] = total_sizes_big
                        total_sizes_dict_rule["total_size_small"] = total_sizes_small_rule
                        total_sizes_dict["total_size_small"] = total_sizes_small
                    except:
                        # total_sizes_big_rule = ""
                        # total_sizes_big = ""
                        # total_sizes_small_rule = ""
                        # total_sizes_small = ""
                        total_sizes_dict_rule["total_size_big"] = None
                        total_sizes_dict["total_size_big"] = None
                        total_sizes_dict_rule["total_size_small"] = None
                        total_sizes_dict["total_size_small"] = None
                    # 上半场总分大小
                    try:
                        half_total_sizes = result['o']["ou1st"]["v"]
                        half_total_sizes_big_rule, half_total_sizes_big, half_total_sizes_small_rule, half_total_sizes_small = rangqiu_daxiao(
                            inner=half_total_sizes, pt=pt)
                        total_sizes_dict_rule["half_total_size_big"] = half_total_sizes_big_rule
                        total_sizes_dict["half_total_size_big"] = half_total_sizes_big
                        total_sizes_dict_rule["half_total_size_small"] = half_total_sizes_small_rule
                        total_sizes_dict["half_total_size_small"] = half_total_sizes_small
                    except:
                        # half_total_sizes_big_rule = ""
                        # half_total_sizes_big = ""
                        # half_total_sizes_small_rule = ""
                        # half_total_sizes_small = ""
                        total_sizes_dict_rule["half_total_size_big"] = None
                        total_sizes_dict["half_total_size_big"] = None
                        total_sizes_dict_rule["half_total_size_small"] = None
                        total_sizes_dict["half_total_size_small"] = None
                    # 第一节总分大小
                    try:
                        one_total_sizes = result['o']["ou1st"]["v"]
                        one_total_sizes_big_rule, one_total_size_big, one_total_sizes_small_rule, one_total_sizes_small = rangqiu_daxiao(
                            inner=one_total_sizes, pt=pt)
                        total_sizes_dict_rule["one_total_size_big"] = one_total_sizes_big_rule
                        total_sizes_dict["one_total_size_big"] = one_total_size_big
                        total_sizes_dict_rule["one_total_size_small"] = one_total_sizes_small_rule
                        total_sizes_dict["one_total_size_small"] = one_total_sizes_small
                    except:
                        # one_total_sizes_big_rule = ""
                        # one_total_sizes_big = ""
                        # one_total_sizes_small_rule = ""
                        # one_total_sizes_small = ""
                        total_sizes_dict_rule["one_total_size_big"] = None
                        total_sizes_dict["one_total_size_big"] = None
                        total_sizes_dict_rule["one_total_size_small"] = None
                        total_sizes_dict["one_total_size_small"] = None
                    # 第二节场总分大小
                    try:
                        two_total_sizes = result['o']["ou1st"]["v"]
                        two_total_sizes_big_rule, two_total_sizes_big, two_total_sizes_small_rule, two_total_sizes_small = rangqiu_daxiao(
                            inner=two_total_sizes, pt=pt)
                        total_sizes_dict_rule["two_total_size_big"] = two_total_sizes_big_rule
                        total_sizes_dict["two_total_size_big"] = two_total_sizes_big
                        total_sizes_dict_rule["two_total_size_small"] = two_total_sizes_small_rule
                        total_sizes_dict["two_total_size_small"] = two_total_sizes_small
                    except:
                        # two_total_sizes_big_rule = ""
                        # two_total_sizes_big = ""
                        # two_total_sizes_small_rule = ""
                        # two_total_sizes_small = ""
                        total_sizes_dict_rule["two_total_size_big"] = None
                        total_sizes_dict["two_total_size_big"] = None
                        total_sizes_dict_rule["two_total_size_small"] = None
                        total_sizes_dict["two_total_size_small"] = None
                    # 第三节总分大小
                    try:
                        three_total_sizes = result['o']["ou1st"]["v"]
                        three_total_sizes_big_rule, three_total_sizes_big, three_total_sizes_small_rule, three_total_sizes_small = rangqiu_daxiao(
                            inner=three_total_sizes, pt=pt)
                        total_sizes_dict_rule["three_total_size_big"] = three_total_sizes_big_rule
                        total_sizes_dict["three_total_size_big"] = three_total_sizes_big
                        total_sizes_dict_rule["three_total_size_small"] = three_total_sizes_small_rule
                        total_sizes_dict["three_total_size_small"] = three_total_sizes_small
                    except:
                        # three_total_sizes_big_rule = ""
                        # three_total_sizes_big = ""
                        # three_total_sizes_small_rule = ""
                        # three_total_sizes_small = ""
                        total_sizes_dict_rule["three_total_size_big"] = None
                        total_sizes_dict["three_total_size_big"] = None
                        total_sizes_dict_rule["three_total_size_small"] = None
                        total_sizes_dict["three_total_size_small"] = None
                    # 第四节总分大小
                    try:
                        four_total_sizes = result['o']["ou1st"]["v"]
                        four_total_sizes_big_rule, four_total_sizes_big, four_total_sizes_small_rule, four_total_sizes_small = rangqiu_daxiao(
                            inner=four_total_sizes, pt=pt)
                        total_sizes_dict_rule["four_total_size_big"] = four_total_sizes_big_rule
                        total_sizes_dict["four_total_size_big"] = four_total_sizes_big
                        total_sizes_dict_rule["four_total_size_small"] = four_total_sizes_small_rule
                        total_sizes_dict["four_total_size_small"] = four_total_sizes_small
                    except:
                        # four_total_sizes_big_rule = ""
                        # four_total_sizes_big = ""
                        # four_total_sizes_small_rule = ""
                        # four_total_sizes_small = ""
                        total_sizes_dict_rule["four_total_size_big"] = None
                        total_sizes_dict["four_total_size_big"] = None
                        total_sizes_dict_rule["four_total_size_small"] = None
                        total_sizes_dict["four_total_size_small"] = None

                    # ----------------------------------------总分单双分割线------------------------------------------------------------------
                    # 全场 总分单双
                    try:
                        odd_evens = result['o']["oe"]["v"]
                        # # 全场 总分单, 全场 总分双
                        # odd_even_odd, odd_even_even = danshaung_fun(inner=odd_evens)
                        odd_evens_dict["two_sides_single"] = odd_evens[1]
                        odd_evens_dict_rule['two_sides_single'] = '单'
                        odd_evens_dict["two_sides_double"] = odd_evens[3]
                        odd_evens_dict_rule['two_sides_double'] = '双'
                    except:
                        # odd_even_odd = ""
                        # odd_even_even = ""
                        odd_evens_dict["two_sides_single"] = None
                        odd_evens_dict_rule['two_sides_single'] = '单'
                        odd_evens_dict["two_sides_double"] = None
                        odd_evens_dict_rule['two_sides_double'] = '双'
                    # 上半场全场 总分单双

                    try:
                        half_odd_evens = result['o']["oe1st"]["v"]
                        # 上半场 总分单, 上半场 总分双
                        # half_odd_even_odd,half_odd_even_even = danshaung_fun(inner=half_odd_evens)
                        odd_evens_dict["two_sides_single"] = half_odd_evens[1]
                        odd_evens_dict_rule['two_sides_single'] = '单'
                        odd_evens_dict["two_sides_double"] = half_odd_evens[3]
                        odd_evens_dict_rule['two_sides_double'] = '双'
                    except:
                        # half_odd_even_odd = ""
                        # half_odd_even_even = ""
                        odd_evens_dict["half_two_sides_single"] = None
                        odd_evens_dict_rule['half_two_sides_single'] = '单'
                        odd_evens_dict["half_two_sides_double"] = None
                        odd_evens_dict_rule['half_two_sides_double'] = '双'

                    # 总分:单/双-第一节
                    try:
                        one_odd_evens = result['o']["oeq1"]["v"]
                        # one_odd_even_odd,one_odd_even_even = danshaung_fun(inner=one_odd_evens)
                        odd_evens_dict["one_two_sides_single"] = one_odd_evens[1]
                        odd_evens_dict_rule['one_two_sides_single'] = '单'
                        odd_evens_dict["one_two_sides_double"] = one_odd_evens[3]
                        odd_evens_dict_rule['one_two_sides_double'] = '双'
                    except:
                        # one_odd_even_odd = ""
                        # one_odd_even_even = ""
                        odd_evens_dict["one_two_sides_single"] = None
                        odd_evens_dict_rule['one_two_sides_single'] = '单'
                        odd_evens_dict["one_two_sides_double"] = None
                        odd_evens_dict_rule['one_two_sides_double'] = '双'

                    # 总分:单/双-第二节
                    try:
                        two_odd_evens = result['o']["oeq2"]["v"]
                        # two_odd_even_odd,two_odd_even_even = danshaung_fun(inner=two_odd_evens)
                        odd_evens_dict["two_two_sides_single"] = two_odd_evens[1]
                        odd_evens_dict_rule['two_two_sides_single'] = '单'
                        odd_evens_dict["two_two_sides_double"] = two_odd_evens[3]
                        odd_evens_dict_rule['two_two_sides_double'] = '双'
                    except:
                        # two_odd_even_odd = ""
                        # two_odd_even_even = ""
                        odd_evens_dict["two_two_sides_single"] = None
                        odd_evens_dict_rule['two_two_sides_single'] = '单'
                        odd_evens_dict["two_two_sides_double"] = None
                        odd_evens_dict_rule['two_two_sides_double'] = '双'

                    # 总分:单/双-第三节
                    try:
                        three_odd_evens = result['o']["oeq3"]["v"]
                        # three_odd_even_odd,three_odd_even_even = danshaung_fun(inner=three_odd_evens)
                        odd_evens_dict["three_two_sides_single"] = three_odd_evens[1]
                        odd_evens_dict_rule['three_two_sides_single'] = '单'
                        odd_evens_dict["three_two_sides_double"] = three_odd_evens[3]
                        odd_evens_dict_rule['three_two_sides_double'] = '双'


                    except:
                        # three_odd_even_odd = ""
                        # three_odd_even_even = ""
                        odd_evens_dict["three_two_sides_single"] = None
                        odd_evens_dict_rule['three_two_sides_single'] = '单'
                        odd_evens_dict["three_two_sides_double"] = None
                        odd_evens_dict_rule['three_two_sides_double'] = '双'

                    # 总分:单/双-第四节
                    try:
                        four_odd_evens = result['o']["oeq4"]["v"]
                        # four_odd_even_odd,four_odd_even_even = danshaung_fun(inner=four_odd_evens)
                        odd_evens_dict["four_two_sides_single"] = four_odd_evens[1]
                        odd_evens_dict_rule['four_two_sides_single'] = '单'
                        odd_evens_dict["four_two_sides_double"] = four_odd_evens[3]
                        odd_evens_dict_rule['four_two_sides_double'] = '双'
                    except:
                        # four_odd_even_odd = ""
                        # four_odd_even_even = ""
                        odd_evens_dict["four_two_sides_single"] = None
                        odd_evens_dict_rule['four_two_sides_single'] = '单'
                        odd_evens_dict["four_two_sides_double"] = None
                        odd_evens_dict_rule['four_two_sides_double'] = '双'

                    # ----------------------------------------球队得分最后一位数分割线---------------------------------------------------------
                    # 球队得分最后一位数 主队

                    try:
                        last_numbers = result["p-o"][0]['o']
                        last_home = {last_numbers[0][0]: last_numbers[0][2], last_numbers[1][0]: last_numbers[1][2],
                                     last_numbers[2][0]: last_numbers[2][2], last_numbers[3][0]: last_numbers[3][2],
                                     last_numbers[4][0]: last_numbers[4][2]}
                        # if last_numbers:
                        #     for last_number in last_numbers:
                        #         last_home[last_number[0]] = last_number[2]
                    except:
                        last_home = {}
                    last_numbers_dict["last_home"] = last_home
                    # 球队得分最后一位数 客队
                    try:
                        new_last_numbers = result["p-o"][1]['o']
                        last_guest = {new_last_numbers[0][0]: new_last_numbers[0][2],
                                      new_last_numbers[1][0]: new_last_numbers[1][2],
                                      new_last_numbers[2][0]: new_last_numbers[2][2],
                                      new_last_numbers[3][0]: new_last_numbers[3][2],
                                      new_last_numbers[4][0]: new_last_numbers[4][2]}
                        # if new_last_numbers:
                        #     for new_last_number in new_last_numbers:
                        #         last_guest[new_last_number[0]] = new_last_number[2]
                    except:
                        last_guest = {}
                    last_numbers_dict["last_guest"] = last_guest
                    # ------------------------------------------------------独赢分割线---------------------------------------------------------

                    # 独赢
                    try:
                        capots = result['o']["ml"]["v"]
                        capot_list = [capots[i] for i in range(len(capots)) if i % 2 == 1]
                        capot_home = capot_list[0]
                        capot_guest = capot_list[1]
                        capots_dict["capot_home"] = capot_home
                        capots_dict["capot_guest"] = capot_guest
                    except:
                        # capot_home = ""
                        # capot_guest = ""
                        capots_dict["capot_home"] = None
                        capots_dict["capot_guest"] = None

                    # 上半场独赢
                    try:
                        half_capots = result['o']["ml1st"]["v"]
                        half_capot_list = [half_capots[i] for i in range(len(half_capots)) if i % 2 == 1]
                        half_capot_home = half_capot_list[0]
                        half_capot_guest = half_capot_list[1]
                        capots_dict["half_capot_home"] = half_capot_home
                        capots_dict["half_capot_guest"] = half_capot_guest
                    except:
                        # half_capot_home = ""
                        # half_capot_guest = ""
                        capots_dict["half_capot_home"] = None
                        capots_dict["half_capot_guest"] = None

                    # 第一节独赢
                    try:
                        one_capots = result['o']["mlq1"]["v"]
                        one_capot_list = [one_capots[i] for i in range(len(one_capots)) if i % 2 == 1]
                        one_capot_home = one_capot_list[0]
                        one_capot_guest = one_capot_list[1]
                        capots_dict["one_capot_home"] = one_capot_home
                        capots_dict["one_capot_guest"] = one_capot_guest
                    except:
                        # one_capot_home = ""
                        # one_capot_guest = ""
                        capots_dict["one_capot_home"] = None
                        capots_dict["one_capot_guest"] = None

                    # 第二节独赢
                    try:
                        two_capots = result['o']["mlq2"]["v"]
                        two_capot_list = [two_capots[i] for i in range(len(two_capots)) if i % 2 == 1]
                        two_capot_home = two_capot_list[0]
                        two_capot_guest = two_capot_list[1]
                        capots_dict["two_capot_home"] = two_capot_home
                        capots_dict["two_capot_guest"] = two_capot_guest
                    except:
                        # two_capot_home = ""
                        # two_capot_guest = ""
                        capots_dict["two_capot_home"] = None
                        capots_dict["two_capot_guest"] = None

                    # 第三节独赢
                    try:
                        three_capots = result['o']["mlq3"]["v"]
                        three_capot_list = [three_capots[i] for i in range(len(three_capots)) if i % 2 == 1]
                        three_capot_home = three_capot_list[0]
                        three_capot_guest = three_capot_list[1]
                        capots_dict["three_capot_home"] = three_capot_home
                        capots_dict["three_capot_guest"] = three_capot_guest
                    except:
                        # three_capot_home = ""
                        # three_capot_guest = ""
                        capots_dict["three_capot_home"] = None
                        capots_dict["three_capot_guest"] = None

                    # 第四节独赢
                    try:
                        four_capots = result['o']["mlq2"]["v"]
                        four_capot_list = [four_capots[i] for i in range(len(four_capots)) if i % 2 == 1]
                        four_capot_home = four_capot_list[0]
                        four_capot_guest = four_capot_list[1]
                        capots_dict["four_capot_home"] = four_capot_home
                        capots_dict["four_capot_guest"] = four_capot_guest
                    except:
                        # four_capot_home = ""
                        # four_capot_guest = ""
                        capots_dict["four_capot_home"] = None
                        capots_dict["four_capot_guest"] = None

                # ---------------------------------------------------华丽分割线列表es[1]--------------------------------------------------
                # 球队得分 全场主队 home
                if result['pci']['ctid'] == 41:
                    try:
                        score_home = new_data[1]
                    except:
                        score_home = ""
                    # print(game_id)
                    if score_home:
                        try:
                            score_homes = score_home["o"]["ou"]['v']
                            score_home_big_rule, score_home_big, score_home_small_rule, score_home_small = rangqiu_daxiao(
                                inner=score_homes)
                            team_scores_dict_rule["score_home_big"] = score_home_big_rule
                            team_scores_dict["score_home_big"] = score_home_big
                            team_scores_dict_rule["score_home_small"] = score_home_small_rule
                            team_scores_dict["score_home_small"] = score_home_small
                        except:
                            # score_home_small = ""
                            # score_home_small_rule = ""
                            # score_home_big_rule = ""
                            # score_home_big = ""
                            team_scores_dict_rule["score_home_big"] = None
                            team_scores_dict["score_home_big"] = None
                            team_scores_dict_rule["score_home_small"] = None
                            team_scores_dict["score_home_small"] = None
                        # 球队得分 上半场主队 home
                        try:
                            half_score_homes = score_home['o']['ou1st']['v']
                            # 球队得分 上半场主队 大条件
                            half_score_home_big_rule, half_score_home_big, half_score_home_small_rule, half_score_home_small = rangqiu_daxiao(
                                inner=half_score_homes)
                            team_scores_dict_rule["half_score_home_big"] = half_score_home_big_rule
                            team_scores_dict["half_score_home_big"] = half_score_home_big
                            team_scores_dict_rule["half_score_home_small"] = half_score_home_small_rule
                            team_scores_dict["half_score_home_small"] = half_score_home_small
                        except:
                            # half_score_home_small = ""
                            # half_score_home_small_rule = ""
                            # half_score_home_big = ""
                            # half_score_home_big_rule = ""
                            team_scores_dict_rule["half_score_home_big"] = None
                            team_scores_dict["half_score_home_big"] = None
                            team_scores_dict_rule["half_score_home_small"] = None
                            team_scores_dict["half_score_home_small"] = None

                        # 球队得分:主队-大 / 小-第一节
                        try:
                            one_score_homes = score_home['o']["ouq1"]["v"]
                            one_score_home_big_rule, one_score_home_big, one_score_home_small_rule, one_score_home_small = rangqiu_daxiao(
                                inner=one_score_homes)
                            team_scores_dict_rule["one_score_home_big"] = one_score_home_big_rule
                            team_scores_dict["one_score_home_big"] = one_score_home_big
                            team_scores_dict_rule["one_score_home_small"] = one_score_home_small_rule
                            team_scores_dict["one_score_home_small"] = one_score_home_small
                        except:
                            # one_score_home_small = ""
                            # one_score_home_small_rule = ""
                            # one_score_home_big = ""
                            # one_score_home_big_rule = ""
                            team_scores_dict_rule["one_score_home_big"] = None
                            team_scores_dict["one_score_home_big"] = None
                            team_scores_dict_rule["one_score_home_small"] = None
                            team_scores_dict["one_score_home_small"] = None

                        # 球队得分:主队-大 / 小-第一节
                        try:
                            two_score_homes = score_home['o']["ouq2"]["v"]
                            two_score_home_big_rule, two_score_home_big, two_score_home_small_rule, two_score_home_small = rangqiu_daxiao(
                                inner=two_score_homes)
                            team_scores_dict_rule["two_score_home_big"] = two_score_home_big_rule
                            team_scores_dict["two_score_home_big"] = two_score_home_big
                            team_scores_dict_rule["two_score_home_small"] = two_score_home_small_rule
                            team_scores_dict["two_score_home_small"] = two_score_home_small
                        except:
                            # two_score_home_small = ""
                            # two_score_home_small_rule = ""
                            # two_score_home_big = ""
                            # two_score_home_big_rule = ""
                            team_scores_dict_rule["two_score_home_big"] = None
                            team_scores_dict["two_score_home_big"] = None
                            team_scores_dict_rule["two_score_home_small"] = None
                            team_scores_dict["two_score_home_small"] = None

                        # 球队得分:主队-大 / 小-第一节
                        try:
                            three_score_homes = score_home['o']["ouq3"]["v"]
                            three_score_home_big_rule, three_score_home_big, three_score_home_small_rule, three_score_home_small = rangqiu_daxiao(
                                inner=three_score_homes)
                            team_scores_dict_rule["three_score_home_big"] = three_score_home_big_rule
                            team_scores_dict["three_score_home_big"] = three_score_home_big
                            team_scores_dict_rule["three_score_home_small"] = three_score_home_small_rule
                            team_scores_dict["three_score_home_small"] = three_score_home_small
                        except:
                            # three_score_home_small = ""
                            # three_score_home_small_rule = ""
                            # three_score_home_big = ""
                            # three_score_home_big_rule = ""
                            team_scores_dict_rule["three_score_home_big"] = None
                            team_scores_dict["three_score_home_big"] = None
                            team_scores_dict_rule["three_score_home_small"] = None
                            team_scores_dict["three_score_home_small"] = None

                        # 球队得分:主队-大 / 小-第四节
                        try:
                            four_score_homes = score_home['o']["ouq4"]["v"]
                            four_score_home_big_rule, four_score_home_big, four_score_home_small_rule, four_score_home_small = rangqiu_daxiao(
                                inner=four_score_homes)
                            team_scores_dict_rule["four_score_home_big"] = four_score_home_big_rule
                            team_scores_dict["four_score_home_big"] = four_score_home_big
                            team_scores_dict_rule["four_score_home_small"] = four_score_home_small_rule
                            team_scores_dict["four_score_home_small"] = four_score_home_small
                        except:
                            # four_score_home_small = ""
                            # four_score_home_small_rule = ""
                            # four_score_home_big = ""
                            # four_score_home_big_rule = ""
                            team_scores_dict_rule["four_score_home_big"] = None
                            team_scores_dict["four_score_home_big"] = None
                            team_scores_dict_rule["four_score_home_small"] = None
                            team_scores_dict["four_score_home_small"] = None

                # ---------------------------------------------------华丽分割线列表es[2]--------------------------------------------------
                # 球队得分 客队 guest
                if result['pci']['ctid'] == 42:
                    try:
                        score_guest = new_data[2]
                    except:
                        score_guest = ""
                    if score_guest:
                        try:
                            # 球队得分: 大 / 小
                            score_guests = score_guest["o"]["ou"]['v']
                            score_guest_big_rule, score_guest_big, score_guest_small_rule, score_guest_small = rangqiu_daxiao(
                                inner=score_guests)
                            team_scores_dict_rule["score_guest_big"] = score_guest_big_rule
                            team_scores_dict["score_guest_big"] = score_guest_big
                            team_scores_dict_rule["score_guest_small"] = score_guest_small_rule
                            team_scores_dict["score_guest_small"] = score_guest_small
                        except:
                            # score_guest_small = None
                            # score_guest_small_rule = None
                            # score_guest_big = None
                            # score_guest_big_rule = None
                            team_scores_dict_rule["score_guest_big"] = None
                            team_scores_dict["score_guest_big"] = None
                            team_scores_dict_rule["score_guest_small"] = None
                            team_scores_dict["score_guest_small"] = None

                        # 球队得分 上半场客队 guest
                        try:
                            half_score_guests = score_guest["o"]['ou1st']['v']
                            half_score_guest_big_rule, half_score_guest_big, half_score_guest_small_rule, half_score_guest_small = rangqiu_daxiao(
                                inner=half_score_guests)
                            team_scores_dict_rule["half_score_guest_big"] = half_score_guest_big_rule
                            team_scores_dict["half_score_guest_big"] = half_score_guest_big
                            team_scores_dict_rule["half_score_guest_small"] = half_score_guest_small_rule
                            team_scores_dict["half_score_guest_small"] = half_score_guest_small
                        except:
                            # half_score_guest_small = None
                            # half_score_guest_small_rule = None
                            # half_score_guest_big = None
                            # half_score_guest_big_rule = None
                            team_scores_dict_rule["half_score_guest_big"] = None
                            team_scores_dict["half_score_guest_big"] = None
                            team_scores_dict_rule["half_score_guest_small"] = None
                            team_scores_dict["half_score_guest_small"] = None
                        # 球队得分第一节
                        try:
                            one_score_guests = score_guest["o"]['ouq1']['v']
                            one_score_guest_big_rule, one_score_guest_big, one_score_guest_small_rule, one_score_guest_small = rangqiu_daxiao(
                                inner=one_score_guests)
                            team_scores_dict_rule["one_score_guest_big"] = one_score_guest_big_rule
                            team_scores_dict["one_score_guest_big"] = one_score_guest_big
                            team_scores_dict_rule["one_score_guest_small"] = one_score_guest_small_rule
                            team_scores_dict["one_score_guest_small"] = one_score_guest_small
                        except:
                            # one_score_guest_small = None
                            # one_score_guest_small_rule = None
                            # one_score_guest_big = None
                            # one_score_guest_big_rule = None
                            team_scores_dict_rule["one_score_guest_big"] = None
                            team_scores_dict["one_score_guest_big"] = None
                            team_scores_dict_rule["one_score_guest_small"] = None
                            team_scores_dict["one_score_guest_small"] = None

                        # 球队得分第二节
                        try:
                            two_score_guests = score_guest["o"]['ouq2']['v']
                            two_score_guest_big_rule, two_score_guest_big, two_score_guest_small_rule, two_score_guest_small = rangqiu_daxiao(
                                inner=two_score_guests)
                            team_scores_dict_rule["two_score_guest_big"] = two_score_guest_big_rule
                            team_scores_dict["two_score_guest_big"] = two_score_guest_big
                            team_scores_dict_rule["two_score_guest_small"] = two_score_guest_small_rule
                            team_scores_dict["two_score_guest_small"] = two_score_guest_small
                        except:
                            team_scores_dict_rule["two_score_guest_big"] = None
                            team_scores_dict["two_score_guest_big"] = None
                            team_scores_dict_rule["two_score_guest_small"] = None
                            team_scores_dict["two_score_guest_small"] = None
                        # 球队得分第三节
                        try:
                            three_score_guests = score_guest["o"]['ouq3']['v']
                            three_score_guest_big_rule, three_score_guest_big, three_score_guest_small_rule, three_score_guest_small = rangqiu_daxiao(
                                inner=three_score_guests)
                            team_scores_dict_rule["three_score_guest_big"] = three_score_guest_big_rule
                            team_scores_dict["three_score_guest_big"] = three_score_guest_big
                            team_scores_dict_rule["three_score_guest_small"] = three_score_guest_small_rule
                            team_scores_dict["three_score_guest_small"] = three_score_guest_small
                        except:
                            team_scores_dict_rule["three_score_guest_big"] = None
                            team_scores_dict["three_score_guest_big"] = None
                            team_scores_dict_rule["three_score_guest_small"] = None
                            team_scores_dict["three_score_guest_small"] = None
                        # 球队得分第四节
                        try:
                            four_score_guests = score_guest["o"]['ouq4']['v']
                            four_score_guest_big_rule, four_score_guest_big, four_score_guest_small_rule, four_score_guest_small = rangqiu_daxiao(
                                inner=four_score_guests)
                            team_scores_dict_rule["four_score_guest_big"] = four_score_guest_big_rule
                            team_scores_dict["four_score_guest_big"] = four_score_guest_big
                            team_scores_dict_rule["four_score_guest_small"] = four_score_guest_small_rule
                            team_scores_dict["four_score_guest_small"] = four_score_guest_small
                        except:
                            team_scores_dict_rule["four_score_guest_big"] = None
                            team_scores_dict["four_score_guest_big"] = None
                            team_scores_dict_rule["four_score_guest_small"] = None
                            team_scores_dict["four_score_guest_small"] = None

            # 联赛id
            item['league_id'] = league_id
            # 联赛名
            item['league_name'] = league_name
            # item['result'] = result
            # 比赛id
            item['game_id'] = data[0]
            # 球队1
            item['team_home'] = data[1]
            # 球队2
            item['team_guest'] = data[2]
            # 数量(97>)
            item['number'] = data[3]
            # 比赛状态
            item['zhuangtai'] = data[4]
            # 日期
            item['data_game'] = data[5]
            # 开赛时间
            item['time_game'] = data[6]
            # 队1分数
            item['score_home'] = data[7]
            # 队2分数
            item['score_guest'] = data[8]
            # 第几节
            item['jijie'] = data[9]
            item['pt'] = pt
            # 球队得分
            item['qiudui'] = data[10]
            item['concede'] = concedes_dict
            item['concede_rule'] = concedes_dict_rule
            item['odd_even'] = odd_evens_dict
            item['odd_even_rule'] = odd_evens_dict_rule
            item['total_size'] = total_sizes_dict
            item['total_size_rule'] = total_sizes_dict_rule
            item['last_number'] = last_numbers_dict
            item['capot'] = capots_dict
            item['team_score'] = team_scores_dict
            item['team_score_rule'] = team_scores_dict_rule
            item['lanqiu'] = lanqiu
            yield item