激进买入策略修改

Administrator

2024-04-30 f34371f754a4099355dfa0f2a6b6bcca81ec2817

激进买入策略修改

 l2/l2_data_manager_new.py

@@ -648,7 +648,12 @@
        """
        can_buy_result = CodePlateKeyBuyManager.can_buy(code)
        if can_buy_result:
            return can_buy_result[5]
            if can_buy_result[5]:
                return can_buy_result[5]
            elif not can_buy_result[0] and can_buy_result[1]:
                # 10:00:00 前的独苗可激进买入
                if tool.trade_time_sub(tool.get_now_time_str(),"10:00:00") <=0:
                    return ["独苗"]
        return None

    @classmethod

 test/test.py

@@ -1,8 +1,21 @@
from utils import tool


def test_active_buy():
    current_rank = 2

    TIME_STR_RANGES = ["10:00:00", "10:30:00", "11:00:00", "13:00:00", "13:30:00", "14:00:00", "14:30:00",
                       "15:00:00"]
    TIME_INT_RANGES = [int(x.replace(':', '')) for x in TIME_STR_RANGES]
    MAX_RANKS = [3, 3, 2, 2, 1, 0, 0, 0]
    now_time_str = "09:36:00".replace(':', '')
    for i in range(len(TIME_INT_RANGES)):
        if int(now_time_str) <= TIME_INT_RANGES[i]:
            if MAX_RANKS[i] > current_rank:
                return True
            break
    return False


if __name__ == "__main__":
    num = 25070171
    limit_up_price = 5.1
    if limit_up_price:
        money_y = round((num * float(limit_up_price)) / 1e8, 1)
        money = int(200 * money_y + 280)
        count = int(money_y * 10) // 10 + 3
        print( money, count)
    print(test_active_buy())

 third_data/code_plate_key_manager.py

@@ -513,74 +513,30 @@

    # 是否需要激进买
    @classmethod
    def __is_need_active_buy(cls, code, block, current_limit_up_datas, limit_up_record_datas,
                             yesterday_current_limit_up_codes):
    def __is_need_active_buy(cls, code, block, current_rank, open_limit_up_count):
        """
        激进买入规则：主板老大且前面有高位板/20cm
        @param code:
        @param block:
        @param current_limit_up_datas:
        @param limit_up_record_datas:
        @param yesterday_current_limit_up_codes:
        板块是否需要激进买入
        规则：根据身位判断是否需要激进买，根据时间划分
        @param code: 代码
        @param block: 板块名称
        @param current_rank: 目前在板块中的身位，从0开始
        @param open_limit_up_count: 开1的数量
        @return:
        """
        code_limit_up_reason_dict = {}
        for d in limit_up_record_datas:
            code_limit_up_reason_dict[d[3]] = d[2]

        # 前面有高位板/非主板涨停且曾涨停主板排老大则激进买
        block_codes_info = []
        contains_code = False
        for d in current_limit_up_datas:
            reason = kpl_util.get_current_limit_up_reason(d)
            if reason != block:
                continue
            if d[0] == code:
                contains_code = True
            # 格式：[代码,涨停时间,是否高位板, 自由流通市值]
            block_codes_info.append((d[0], d[2], d[0] in yesterday_current_limit_up_codes, d[7]))
        if not contains_code:
            block_codes_info.append((code, int(time.time()), False, global_util.zyltgb_map.get(code)))
        block_codes_info.sort(key=lambda x: x[1])
        # 暂存在当前代码之前涨停的高位板/非主板代码
        before_codes = []
        for info in block_codes_info:
            if info[0] == code:
        real_current_rank = max(current_rank - open_limit_up_count, 0)

        TIME_STR_RANGES = ["10:00:00", "10:30:00", "11:00:00", "13:00:00", "13:30:00", "14:00:00", "14:30:00",
                           "15:00:00"]
        TIME_INT_RANGES = [int(x.replace(':', '')) for x in TIME_STR_RANGES]
        MAX_RANKS = [3, 3, 2, 2, 1, 0, 0, 0]
        now_time_str = tool.get_now_time_str().replace(':', '')
        for i in range(len(TIME_INT_RANGES)):
            if int(now_time_str) <= TIME_INT_RANGES[i]:
                if MAX_RANKS[i] > real_current_rank:
                    return True
                break
            if info[2] or not tool.is_shsz_code(info[0]):
                before_codes.append(info[0])
        if before_codes:
            # 判断历史涨停主板身位
            record_shsz_rank, record_shsz_rank_codes = kpl_block_util.get_code_record_rank(code, block,
                                                                                           limit_up_record_datas,
                                                                                           code_limit_up_reason_dict,
                                                                                           yesterday_current_limit_up_codes,
                                                                                           shsz=True)
            if record_shsz_rank == 0:
                # 历史主板老大
                return True, f"主板老大且前面有非主板/高位板涨停，先于涨停代码：{before_codes}"
        # 排除自己有3个涨停，且这4个中自由流通市值最小，且涨停过的代码中主板排名前4
        if len(block_codes_info) >= 4:
            temp_codes = []
            for info in block_codes_info:
                # 不是高位板且是主板
                if not info[2] and tool.is_shsz_code(info[0]):
                    # 格式：(代码, 自由流通市值)
                    temp_codes.append((info[0], info[3]))
            # 判断是否为主板中自由市值最小
            temp_codes.sort(key=lambda x: x[1])
            if temp_codes[0][0] == code:
                # 自由市值最小
                # 判断历史身位
                record_shsz_rank, record_shsz_rank_codes = kpl_block_util.get_code_record_rank(code, block,
                                                                                               limit_up_record_datas,
                                                                                               code_limit_up_reason_dict,
                                                                                               yesterday_current_limit_up_codes,
                                                                                               shsz=True)
                if record_shsz_rank < 4:
                    return True, f"板块有大于3票涨停，且自由流通市值最小，身位({record_shsz_rank})前4"

        return False, "不满足激进买入条件"
        return False

    # 返回内容(是否可买, 是否为独苗, 描述信息, 是否为强势主线, 是否需要激进买)
    @classmethod
@@ -595,18 +551,14 @@
        block_codes = current_limit_up_block_codes_dict.get(block)
        if block_codes is None:
            block_codes = set()
        # 计算是否需要激进买入
        active_buy = cls.__is_need_active_buy(code, block, current_limit_up_datas,
                                              limit_up_record_datas,
                                              yesterday_current_limit_up_codes)

        if not block_codes:
            # 高位板泛化板块中无板块
            if not high_level_block_codes.get(block):
                return False, True, f"{block}:板块无涨停", False, active_buy
                return False, True, f"{block}:板块无涨停", False, False
        elif len(block_codes) == 1 and code in block_codes:
            if not high_level_block_codes.get(block):
                return False, True, f"{block}:板块只有当前代码涨停", False, active_buy
                return False, True, f"{block}:板块只有当前代码涨停", False, False
        # 可以买的最大排名
        # open_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes(code, block, limit_up_record_datas,
        #                                                                   code_limit_up_reason_dict)
@@ -669,6 +621,9 @@
                                                                                                    current_open_limit_up_codes),
                                                                                                shsz=True,
                                                                                                limit_up_time=first_limit_up_time)
        # 计算是否需要激进买入
        is_active_buy = cls.__is_need_active_buy(code, block, current_shsz_rank, len(current_open_limit_up_codes))

        # record_shsz_rank, record_shsz_rank_codes = kpl_block_util.get_code_record_rank(code, block,
        #                                                                                limit_up_record_datas,
        #                                                                                code_limit_up_reason_dict,
@@ -676,10 +631,10 @@
        #                                                                                shsz=True)
        if int(tool.get_now_time_str().replace(":", "")) <= int("094000") and is_strong_block:
            # 强势主线加强势10分钟
            return True, False, f"【{block}】：强势主线+强势10分钟", is_strong_block, active_buy
            return True, False, f"【{block}】：强势主线+强势10分钟", is_strong_block, is_active_buy

        if current_shsz_rank < len(current_open_limit_up_codes) + max_rank:
            return True, False, f"【{block}】前排代码：{current_shsz_rank}", is_strong_block, active_buy
            return True, False, f"【{block}】前排代码：{current_shsz_rank}", is_strong_block, is_active_buy
        else:
            # k_format = code_nature_analyse.CodeNatureRecordManager().get_k_format_cache(code)
            # if k_format and k_format[8][0]:
@@ -692,8 +647,8 @@
                situation = MarketSituationManager().get_situation_cache()
                zylt_threshold_as_yi = buy_condition_util.get_zyltgb_threshold(situation)
                if zyltgb_as_yi and zylt_threshold_as_yi[2] <= zyltgb_as_yi <= zylt_threshold_as_yi[3]:
                    return True, False, f"【{block}】强势板块 自由流通市值({zyltgb_as_yi})大于{zylt_threshold_as_yi[2]}亿 小于{zylt_threshold_as_yi[3]}亿", is_strong_block, active_buy
            return False, False, f"【{block}】前排代码：{front_current_shsz_rank_codes} 超过{len(current_open_limit_up_codes) + max_rank}个", is_strong_block, active_buy
                    return True, False, f"【{block}】强势板块 自由流通市值({zyltgb_as_yi})大于{zylt_threshold_as_yi[2]}亿 小于{zylt_threshold_as_yi[3]}亿", is_strong_block, is_active_buy
            return False, False, f"【{block}】前排代码：{front_current_shsz_rank_codes} 超过{len(current_open_limit_up_codes) + max_rank}个", is_strong_block, is_active_buy

        # 过时的代码
        # if open_limit_up_codes:
@@ -740,18 +695,14 @@
        block_codes = current_limit_up_block_codes_dict.get(block)
        if block_codes is None:
            block_codes = set()
        # 计算是否需要激进买入
        active_buy = cls.__is_need_active_buy(code, block, current_limit_up_datas,
                                              limit_up_record_datas,
                                              yesterday_current_limit_up_codes)

        if not block_codes:
            # 高位板泛化板块中无板块
            if not high_level_block_codes.get(block):
                return False, True, f"{block}:板块无涨停", False, active_buy
                return False, True, f"{block}:板块无涨停", False, False
        elif len(block_codes) == 1 and code in block_codes:
            if not high_level_block_codes.get(block):
                return False, True, f"{block}:板块只有当前代码涨停", False, active_buy
                return False, True, f"{block}:板块只有当前代码涨停", False, False
        # 可以买的最大排名
        # open_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes(code, block, limit_up_record_datas,
        #                                                                   code_limit_up_reason_dict)
@@ -796,10 +747,14 @@
                                                                                                    current_open_limit_up_codes),
                                                                                                shsz=True,
                                                                                                limit_up_time=first_limit_up_time)

        # 计算是否需要激进买入
        is_active_buy = cls.__is_need_active_buy(code, block, current_shsz_rank, len(current_open_limit_up_codes))

        if current_shsz_rank < len(current_open_limit_up_codes) + max_rank:
            return True, False, f"【{block}】前排代码：{current_shsz_rank}", is_strong_block, active_buy
            return True, False, f"【{block}】前排代码：{current_shsz_rank}", is_strong_block, is_active_buy
        else:
            return False, False, f"【{block}】前排代码：{front_current_shsz_rank_codes} 超过{len(current_open_limit_up_codes) + max_rank}个", is_strong_block, active_buy
            return False, False, f"【{block}】前排代码：{front_current_shsz_rank_codes} 超过{len(current_open_limit_up_codes) + max_rank}个", is_strong_block, is_active_buy

    # 获取可以买的板块
    # current_limit_up_datas: 今日实时涨停
@@ -842,15 +797,15 @@
        code_limit_up_reasons_dict = {}
        load_code_block()
        for block in keys:
            can_buy, unique, msg, is_strong, active_buy_info = cls.__is_block_can_buy_new(code, block,
                                                                                          current_limit_up_datas,
                                                                                          code_limit_up_reasons_dict,
                                                                                          yesterday_current_limit_up_codes,
                                                                                          limit_up_record_datas,
                                                                                          current_limit_up_block_codes_dict,
                                                                                          high_level_code_blocks=high_level_general_code_blocks,
                                                                                          high_level_block_codes=high_level_general_block_codes)
            fresults.append((block, can_buy, unique, msg, is_strong, active_buy_info))
            can_buy, unique, msg, is_strong, is_active_buy = cls.__is_block_can_buy_new(code, block,
                                                                                        current_limit_up_datas,
                                                                                        code_limit_up_reasons_dict,
                                                                                        yesterday_current_limit_up_codes,
                                                                                        limit_up_record_datas,
                                                                                        current_limit_up_block_codes_dict,
                                                                                        high_level_code_blocks=high_level_general_code_blocks,
                                                                                        high_level_block_codes=high_level_general_block_codes)
            fresults.append((block, can_buy, unique, msg, is_strong, is_active_buy))
        return fresults, keys

    # 是否可以下单
@@ -947,10 +902,9 @@
                    can_buy_strong_blocks.append(r[0])
                if r[3]:
                    msg_list.append(r[3])
                if r[5][0]:
                if r[5]:
                    active_buy_blocks.append(r[0])
                    msg_list.append(f"【{r[0]}】激进买入({r[5][1]})")

                    msg_list.append(f"【{r[0]}】激进买入({r[5]})")
            else:
                if r[3]:
                    msg_list.append(r[3])

 trade/huaxin/huaxin_trade_server.py

@@ -1719,8 +1719,8 @@
            total_datas = l2_data_util.local_today_datas.get(code)

            mode_descs = []
            if big_buy_order_count > 0:
                mode_descs.append("300w")
            # if big_buy_order_count > 0:
            #     mode_descs.append("300w")
            if l2_data_manager_new.L2TradeDataProcessor.get_active_buy_blocks(code):
                mode_descs.append("身位")