量的代码结构修改/扫入策略修改

Administrator

2024-10-30 173a8ace6fd8142a8e2ff62c3b496940c5f603cd

量的代码结构修改/扫入策略修改

 api/outside_api_command_callback.py

@@ -1017,7 +1017,7 @@
                                    real_place_order_after_num += val["num"]

                            # 获取当日的量比
                            volume_rate = code_volumn_manager.get_volume_rate(code)
                            volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code)

                            # 是否需要注意
                            need_pay_attention = (total_left_count <= 10 or total_left_num * float(
@@ -1327,8 +1327,7 @@
                # 获取买入下单设置
                data = {
                    "radical_buy": {"price": (constant.MIN_CODE_RADICAL_BUY_PRICE, constant.MAX_CODE_RADICAL_BUY_PRICE),
                                    "zyltgb": (constant.MIN_CODE_RADICAL_BUY_ZYLTGB_AS_YI,
                                               constant.MAX_CODE_RADICAL_BUY_ZYLTGB_AS_YI)}}
                                    "zyltgb": constant.RADICAL_BUY_ZYLTGB_AS_YI_RANGES}}
                self.send_response({"code": 0, "data": data, "msg": f""},
                                   client_id,
                                   request_id)
@@ -1338,8 +1337,7 @@
                    radical_buy = json.loads(radical_buy)
                    constant.MIN_CODE_RADICAL_BUY_PRICE = radical_buy["price"][0]
                    constant.MAX_CODE_RADICAL_BUY_PRICE = radical_buy["price"][1]
                    constant.MIN_CODE_RADICAL_BUY_ZYLTGB_AS_YI = radical_buy["zyltgb"][0]
                    constant.MAX_CODE_RADICAL_BUY_ZYLTGB_AS_YI = radical_buy["zyltgb"][1]
                    constant.RADICAL_BUY_ZYLTGB_AS_YI_RANGES = radical_buy["zyltgb"]
                self.send_response({"code": 0, "data": {}, "msg": f""},
                                   client_id,
                                   request_id)

 cancel_strategy/s_l_h_cancel_strategy.py

@@ -170,7 +170,7 @@
        @param code:
        @return:（大单阈值, 800w内大单阈值）
        """
        max60, yesterday = code_volumn_manager.get_histry_volumn(code)
        max60, yesterday = code_volumn_manager.CodeVolumeManager().get_histry_volumn(code)
        if max60:
            num = max60[0]
            limit_up_price = gpcode_manager.get_limit_up_price(code)

 code_attribute/code_volumn_manager.py

@@ -14,178 +14,189 @@
from db import redis_manager_delegate as redis_manager
from log_module.log import logger_day_volumn

__db = 0
__redis_manager = redis_manager.RedisManager(0)

class CodeVolumeManager:
    __db = 0
    __redis_manager = redis_manager.RedisManager(0)
    __instance = None
    __today_volumn_cache = {}
    __reference_volume_as_money_y_dict = {}
    __max_volume_in_5days = {}

# 设置历史量
def set_histry_volumn(code, max60, yesterday, max60_day, max60_day_count):
    redis = __redis_manager.getRedis()
    global_util.max60_volumn[code] = (max60, max60_day, max60_day_count)
    global_util.yesterday_volumn[code] = yesterday
    try:
        RedisUtils.setex_async(0, "volumn_max60-{}".format(code), tool.get_expire(),
                               json.dumps((max60, max60_day, max60_day_count)),
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(CodeVolumeManager, cls).__new__(cls, *args, **kwargs)
            cls.__load_data()
        return cls.__instance

    # 将量从数据库加入内存
    @classmethod
    def __load_data(cls):
        redis = cls.__redis_manager.getRedis()
        try:
            keys = RedisUtils.keys(redis, "volumn_max60-*", auto_free=False)
            if keys is not None:
                for k in keys:
                    code = k.split("-")[1]
                    max60_volumn = RedisUtils.get(redis, k, auto_free=False)
                    if max60_volumn:
                        max60_volumn = json.loads(max60_volumn)
                    global_util.max60_volumn[code] = max60_volumn
            keys = RedisUtils.keys(redis, "volumn_yes-*", auto_free=False)
            if keys is not None:
                for k in keys:
                    code = k.split("-")[1]
                    global_util.yesterday_volumn[code] = RedisUtils.get(redis, k, auto_free=False)
            keys = RedisUtils.keys(redis, "volumn_max_5days-*", auto_free=False)
            if keys is not None:
                for k in keys:
                    code = k.split("-")[1]
                    val = RedisUtils.get(redis, k, auto_free=False)
                    cls.__max_volume_in_5days[code] = int(val)
        finally:
            RedisUtils.realse(redis)

    # 设置历史量
    def set_histry_volumn(self, code, max60, yesterday, max60_day, max60_day_count, max5_volume):
        redis = self.__redis_manager.getRedis()
        global_util.max60_volumn[code] = (max60, max60_day, max60_day_count)
        global_util.yesterday_volumn[code] = yesterday
        self.__save_max_volume_in_5days(code, max5_volume)
        try:
            RedisUtils.setex_async(self.__db, "volumn_max60-{}".format(code), tool.get_expire(),
                                   json.dumps((max60, max60_day, max60_day_count)),
                                   auto_free=False)
            RedisUtils.setex_async(self.__db, "volumn_yes-{}".format(code), tool.get_expire(), yesterday,
                                   auto_free=False)
        finally:
            RedisUtils.realse(redis)

    def __save_max_volume_in_5days(self, code, volume):
        self.__max_volume_in_5days[code] = volume
        RedisUtils.setex_async(self.__db, "volumn_max_5days-{}".format(code), tool.get_expire(), volume,
                               auto_free=False)
        RedisUtils.setex_async(0, "volumn_yes-{}".format(code), tool.get_expire(), yesterday, auto_free=False)
    finally:
        RedisUtils.realse(redis)

    def get_max_volume_in_5days(self, code):
        return self.__max_volume_in_5days.get(code)

# 获取历史量
def get_histry_volumn(code):
    max60 = global_util.max60_volumn.get(code)
    yesterday = global_util.yesterday_volumn.get(code)
    redis = __redis_manager.getRedis()
    try:
        if max60 is None:
            max60 = RedisUtils.get(redis, "volumn_max60-{}".format(code), auto_free=False)
            if max60:
                max60 = json.loads(max60)
        if yesterday is None:
            yesterday = RedisUtils.get(redis, "volumn_yes-{}".format(code), auto_free=False)
        return max60, yesterday
    finally:
        RedisUtils.realse(redis)
    # 获取历史量
    def get_histry_volumn(self, code):
        max60 = global_util.max60_volumn.get(code)
        yesterday = global_util.yesterday_volumn.get(code)
        redis = self.__redis_manager.getRedis()
        try:
            if max60 is None:
                max60 = RedisUtils.get(redis, "volumn_max60-{}".format(code), auto_free=False)
                if max60:
                    max60 = json.loads(max60)
            if yesterday is None:
                yesterday = RedisUtils.get(redis, "volumn_yes-{}".format(code), auto_free=False)
            return max60, yesterday
        finally:
            RedisUtils.realse(redis)

    # 量的变化大保存

__today_volumn_cache = {}


# 量的变化大保存

# 设置今日量
def set_today_volumn(code, volumn):
    async_log_util.info(logger_day_volumn, "code:{} volumn:{}".format(code, volumn))
    global_util.today_volumn[code] = volumn
    # 有1000手的变化才保存
    if code in __today_volumn_cache and volumn - __today_volumn_cache[code] < 100000:
        return
    __today_volumn_cache[code] = volumn
    RedisUtils.setex(__redis_manager.getRedis(), "volumn_today-{}".format(code), tool.get_expire(), volumn)


# datas:[(code, volumn)]
def set_today_volumns(datas):
    for d in datas:
        code, volumn = d
    # 设置今日量
    def set_today_volumn(self, code, volumn):
        async_log_util.info(logger_day_volumn, "code:{} volumn:{}".format(code, volumn))
        global_util.today_volumn[code] = volumn
        # 有1000手的变化才保存
        if code in __today_volumn_cache and volumn - __today_volumn_cache[code] < 100000:
            continue
        __today_volumn_cache[code] = volumn
        RedisUtils.setex_async(__db, "volumn_today-{}".format(code), tool.get_expire(), volumn)
        if code in self.__today_volumn_cache and volumn - self.__today_volumn_cache[code] < 100000:
            return
        self.__today_volumn_cache[code] = volumn
        RedisUtils.setex(self.__redis_manager.getRedis(), "volumn_today-{}".format(code), tool.get_expire(), volumn)

    # datas:[(code, volumn)]
    def set_today_volumns(self, datas):
        for d in datas:
            code, volumn = d
            async_log_util.info(logger_day_volumn, "code:{} volumn:{}".format(code, volumn))
            global_util.today_volumn[code] = volumn
            # 有1000手的变化才保存
            if code in self.__today_volumn_cache and volumn - self.__today_volumn_cache[code] < 100000:
                continue
            self.__today_volumn_cache[code] = volumn
            RedisUtils.setex_async(self.__db, "volumn_today-{}".format(code), tool.get_expire(), volumn)

# 获取今日量
def get_today_volumn(code):
    _volumn = global_util.today_volumn.get(code)
    if _volumn is None:
        _volumn = RedisUtils.get(__redis_manager.getRedis(), "volumn_today-{}".format(code))
    return _volumn
    # 获取今日量
    def get_today_volumn(self, code):
        _volumn = global_util.today_volumn.get(code)
        if _volumn is None:
            _volumn = RedisUtils.get(self.__redis_manager.getRedis(), "volumn_today-{}".format(code))
        return _volumn

    # 获取今日量
    def get_today_volumn_cache(self, code):
        return global_util.today_volumn.get(code)

# 获取今日量
def get_today_volumn_cache(code):
    return global_util.today_volumn.get(code)
    # 获取量比（今日量/max(60天最大量,昨日量)）
    # 将总卖量计算在内
    def get_volume_rate(self, code, total_sell_volume=0, with_info=False):
        today = self.get_today_volumn(code)
        max60, yesterday = self.get_histry_volumn(code)
        if today is None:
            today = 0
        if max60 is None or yesterday is None:
            max60 = [today, '']
            yesterday = today
            if max60[0] < 1:
                max60[0] = 1
        rate = round((int(today) + total_sell_volume) / max(int(max60[0]), int(yesterday)), 2)
        if not with_info:
            return rate
        return rate, (today, max(int(max60[0]), int(yesterday)))

    # 获取量参考日期
    # 返回(参考量日期,距今的交易日个数)
    def get_volume_refer_date(self, code):
        max60, yesterday = self.get_histry_volumn(code)
        if max60 is None or yesterday is None:
            raise Exception("获取失败")
        if int(max60[0]) >= int(yesterday):
            return max60[1], max60[2]
        else:
            return "上个交易日", 0

# 获取量比（今日量/max(60天最大量,昨日量)）
# 将总卖量计算在内
def get_volume_rate(code, total_sell_volume=0, with_info=False):
    today = get_today_volumn(code)
    max60, yesterday = get_histry_volumn(code)
    if today is None:
        today = 0
    if max60 is None or yesterday is None:
        max60 = [today, '']
        yesterday = today
        if max60[0] < 1:
            max60[0] = 1
    rate = round((int(today) + total_sell_volume) / max(int(max60[0]), int(yesterday)), 2)
    if not with_info:
        return rate
    return rate, (today, max(int(max60[0]), int(yesterday)))
    # 获取量比索引
    def get_volume_rate_index(self, volume_rate):
        rates = [0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6]
        for index in range(0, len(rates)):
            if volume_rate <= rates[index]:
                return index
        return len(rates) - 1

    # 保存今日量
    def save_today_volumn(self, code, volumn, volumnUnit):
        _volumn = None
        if volumnUnit == 0:
            _volumn = round(float(volumn) * 100000000)
        elif volumnUnit == 1:
            _volumn = round(float(volumn) * 10000)
        elif volumnUnit == 2:
            _volumn = int(volumn)
        if _volumn is not None:
            self.set_today_volumn(code, _volumn * 100)

# 获取量参考日期
# 返回(参考量日期,距今的交易日个数)
def get_volume_refer_date(code):
    max60, yesterday = get_histry_volumn(code)
    if max60 is None or yesterday is None:
        raise Exception("获取失败")
    if int(max60[0]) >= int(yesterday):
        return max60[1], max60[2]
    else:
        return "上个交易日", 0


# 获取量比索引
def get_volume_rate_index(volume_rate):
    rates = [0.2, 0.4, 0.6, 0.8, 1, 1.2, 1.4, 1.6]
    for index in range(0, len(rates)):
        if volume_rate <= rates[index]:
            return index
    return len(rates) - 1


# 保存今日量
def save_today_volumn(code, volumn, volumnUnit):
    _volumn = None
    if volumnUnit == 0:
        _volumn = round(float(volumn) * 100000000)
    elif volumnUnit == 1:
        _volumn = round(float(volumn) * 10000)
    elif volumnUnit == 2:
        _volumn = int(volumn)
    if _volumn is not None:
        set_today_volumn(code, _volumn * 100)


# 将量从数据库加入内存
def load():
    redis = __redis_manager.getRedis()
    try:
        keys = RedisUtils.keys(redis, "volumn_max60-*", auto_free=False)
        if keys is not None:
            for k in keys:
                code = k.split("-")[1]
                max60_volumn = RedisUtils.get(redis, k, auto_free=False)
                if max60_volumn:
                    max60_volumn = json.loads(max60_volumn)
                global_util.max60_volumn[code] = max60_volumn
        keys = RedisUtils.keys(redis, "volumn_yes-*", auto_free=False)
        if keys is not None:
            for k in keys:
                code = k.split("-")[1]
                global_util.yesterday_volumn[code] = RedisUtils.get(redis, k, auto_free=False)
    finally:
        RedisUtils.realse(redis)


__reference_volume_as_money_y_dict = {}


def get_reference_volume_as_money_y(code):
    """
    返回参考量今日对应的金额（单位为亿）
    @param code:
    @return:
    """
    if code in __reference_volume_as_money_y_dict:
        return __reference_volume_as_money_y_dict.get(code)
    max60, yesterday = get_histry_volumn(code)
    if max60:
        num = max60[0]
        limit_up_price = gpcode_manager.get_limit_up_price(code)
        if limit_up_price:
            money_y = round((num * float(limit_up_price)) / 1e8, 1)
            __reference_volume_as_money_y_dict[code] = money_y
            return money_y
    # 默认为5亿
    return 5
    def get_reference_volume_as_money_y(self, code):
        """
        返回参考量今日对应的金额（单位为亿）
        @param code:
        @return:
        """
        if code in self.__reference_volume_as_money_y_dict:
            return self.__reference_volume_as_money_y_dict.get(code)
        max60, yesterday = self.get_histry_volumn(code)
        if max60:
            num = max60[0]
            limit_up_price = gpcode_manager.get_limit_up_price(code)
            if limit_up_price:
                money_y = round((num * float(limit_up_price)) / 1e8, 1)
                self.__reference_volume_as_money_y_dict[code] = money_y
                return money_y
        # 默认为5亿
        return 5


if __name__ == "__main__":
    print(get_volume_rate("000059"))
    print(CodeVolumeManager().get_volume_rate("000059"))

 code_attribute/first_target_code_data_processor.py

@@ -119,8 +119,10 @@
                                                              code,
                                                              limit_up_price,
                                                              volumes_data[:90]))
                max_volume_in_5_days = init_data_util.parse_max_volume_in_days(volumes_data, 5)

                async_log_util.info(logger_first_code_record, f"{code} 获取到首板60天最大量：{volumes}")
                code_volumn_manager.set_histry_volumn(code, volumes[0], volumes[1], volumes[2], volumes[3])
                code_volumn_manager.CodeVolumeManager().set_histry_volumn(code, volumes[0], volumes[1], volumes[2], volumes[3], max_volume_in_5_days)

                # 保存K线形态
                k_format = code_nature_analyse.get_k_format(code, limit_up_price, volumes_data)

 code_attribute/global_data_loader.py

@@ -51,8 +51,8 @@
    codes = gpcode_manager.get_gp_list()
    for code in codes:
        try:
            max60, yesterday = code_volumn_manager.get_histry_volumn(code)
            today = code_volumn_manager.get_today_volumn(code)
            max60, yesterday = code_volumn_manager.CodeVolumeManager().get_histry_volumn(code)
            today = code_volumn_manager.CodeVolumeManager().get_today_volumn(code)
            global_util.max60_volumn[code] = max60
            global_util.yesterday_volumn[code] = yesterday
            global_util.today_volumn[code] = today

 constant.py

@@ -197,10 +197,9 @@
# 扫入价格区间
MAX_CODE_RADICAL_BUY_PRICE = 40
MIN_CODE_RADICAL_BUY_PRICE = 3
# 扫入的自由流通市值区间
MAX_CODE_RADICAL_BUY_ZYLTGB_AS_YI = 80
MIN_CODE_RADICAL_BUY_ZYLTGB_AS_YI = 5

# 扫入的自由流通市值区间
RADICAL_BUY_ZYLTGB_AS_YI_RANGES = [(5, 40), (200, 10000)]

# L2数据是否载入完成
L2_DATA_IS_LOADED = False

 l2/cancel_buy_strategy.py

@@ -316,9 +316,9 @@
        @param place_order_time_str:下单时间
        @return:（金额（单位:W）,笔数）
        """
        max60, yesterday = code_volumn_manager.get_histry_volumn(code)
        max60, yesterday = code_volumn_manager.CodeVolumeManager().get_histry_volumn(code)
        if max60:
            money_y = code_volumn_manager.get_reference_volume_as_money_y(code)
            money_y = code_volumn_manager.CodeVolumeManager().get_reference_volume_as_money_y(code)
            money = int(200 * money_y + 280)
            if tool.trade_time_sub(place_order_time_str, "10:00:00") <= 0:
                # 10点前下单打7折

 l2/huaxin/huaxin_target_codes_manager.py

@@ -137,7 +137,7 @@
                     "time": "00:00:00",
                     "zyltgb": zyltgb // 10000, "zyltgbUnit": 1}
            flist.append(fitem)
        code_volumn_manager.set_today_volumns(temp_volumns)
        code_volumn_manager.CodeVolumeManager().set_today_volumns(temp_volumns)
        async_log_util.info(logger_l2_codes_subscript, f"{request_id}接受到L1的数据，预处理完成")
        try:
            tick_datas = first_target_code_data_processor.process_first_codes_datas(flist, request_id)

 l2/l2_data_manager_new.py

@@ -483,8 +483,8 @@
            total_sell_volume = 0
            if current_sell and len(current_sell) > 2:
                total_sell_volume = current_sell[2]
            volume_rate = code_volumn_manager.get_volume_rate(code, total_sell_volume=total_sell_volume)
            volume_rate_index = code_volumn_manager.get_volume_rate_index(volume_rate)
            volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code, total_sell_volume=total_sell_volume)
            volume_rate_index = code_volumn_manager.CodeVolumeManager().get_volume_rate_index(volume_rate)
            # 计算分值
            limit_up_time = cls.__LimitUpTimeManager.get_limit_up_time_cache(code)
            if limit_up_time is None:
@@ -576,7 +576,7 @@
                b_need_cancel, b_cancel_data = cls.__HourCancelBigNumComputer.need_cancel(code, _buy_single_index,
                                                                                          _buy_exec_index, start_index,
                                                                                          end_index, total_data,
                                                                                          code_volumn_manager.get_volume_rate_index(
                                                                                          code_volumn_manager.CodeVolumeManager().get_volume_rate_index(
                                                                                              order_begin_pos.buy_volume_rate),
                                                                                          cls.volume_rate_info[code][1],
                                                                                          is_first_code)
@@ -2282,7 +2282,7 @@
                        # 上证安全笔数为3
                        safe_count = 3
            if tool.is_sz_code(code):
                money_y = code_volumn_manager.get_reference_volume_as_money_y(code)
                money_y = code_volumn_manager.CodeVolumeManager().get_reference_volume_as_money_y(code)
                # 大于8亿的安全笔数必须有8笔
                if money_y >= 8:
                    safe_count = 8

 output/code_info_output.py

@@ -88,7 +88,7 @@
    if is_target_code:
        limit_up_price = gpcode_manager.get_limit_up_price(code)
        limit_up_time = limit_up_time_manager.LimitUpTimeManager().get_limit_up_time_cache(code)
        volume_rate, volume_info = code_volumn_manager.get_volume_rate(code, with_info=True)
        volume_rate, volume_info = code_volumn_manager.CodeVolumeManager().get_volume_rate(code, with_info=True)

        ################################买前评分################################

@@ -102,7 +102,7 @@

        # 获取买入意愿
        __L2PlaceOrderParamsManager = l2_trade_factor.L2PlaceOrderParamsManager(code, True, volume_rate,
                                                                                code_volumn_manager.get_volume_rate_index(
                                                                                code_volumn_manager.CodeVolumeManager().get_volume_rate_index(
                                                                                    volume_rate),
                                                                                None)
        # 是否可以买入的信息
@@ -114,7 +114,7 @@

        # 获取量参考日期
        try:
            volume_refer_date, volume_refer_date_distance = code_volumn_manager.get_volume_refer_date(code)
            volume_refer_date, volume_refer_date_distance = code_volumn_manager.CodeVolumeManager().get_volume_refer_date(code)
            params["trade_data"]["volume_refer_date"] = volume_refer_date
        except:
            pass
@@ -125,7 +125,7 @@
            params["trade_data"]["special_info"] = k_format[8]

        __base_L2PlaceOrderParamsManager = l2_trade_factor.L2PlaceOrderParamsManager(code, False, volume_rate,
                                                                                     code_volumn_manager.get_volume_rate_index(
                                                                                     code_volumn_manager.CodeVolumeManager().get_volume_rate_index(
                                                                                         volume_rate),
                                                                                     None)
        if -1 < __L2PlaceOrderParamsManager.score_index < 3:

 servers/huaxin_trade_server.py

@@ -719,7 +719,7 @@
                    # 首次下单，自由流通50亿以下，总卖额500w才能激进下单
                    mode_descs.insert(0, "成交触发")
                    last_index = total_datas[-1]["index"]
                    volume_rate = code_volumn_manager.get_volume_rate(code)
                    volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code)
                    order_begin_pos = OrderBeginPosInfo(buy_single_index=last_index,
                                                        buy_exec_index=last_index,
                                                        buy_compute_index=last_index,
@@ -753,7 +753,7 @@
                        continue
                    result = L2TradeSingleDataManager.is_can_place_order(code, d)
                    if result and result[0]:
                        volume_rate = code_volumn_manager.get_volume_rate(code)
                        volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code)
                        order_begin_pos = OrderBeginPosInfo(buy_single_index=i,
                                                            buy_exec_index=i,
                                                            buy_compute_index=i,
@@ -874,7 +874,7 @@
                    else:
                        async_log_util.info(logger_l2_radical_buy, f"不能下单：{code}-{result_by_volume}")
                else:
                    volume_rate = code_volumn_manager.get_volume_rate(code)
                    volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code)
                    async_log_util.info(logger_l2_radical_buy, f"没有可扫入的板块：{code},量比：{volume_rate}")
            else:
                async_log_util.info(logger_l2_radical_buy, f"目前代码不可交易：{code}-{can_buy_result[1]}")

 servers/server.py

@@ -471,7 +471,7 @@
                        for item in datas:
                            volumn = item["volume"]
                            volumnUnit = item["volumeUnit"]
                            code_volumn_manager.save_today_volumn(item["code"], volumn, volumnUnit)
                            code_volumn_manager.CodeVolumeManager().save_today_volumn(item["code"], volumn, volumnUnit)
                        current_price_process_manager.accept_prices(datas)
                # L2现价更新
                elif type == 41:

 trade/radical_buy_data_manager.py

@@ -33,7 +33,7 @@
                total_sell_volume = 0
                if current_total_sell_data:
                    total_sell_volume = current_total_sell_data[2]
                volume_rate = code_volumn_manager.get_volume_rate(code, total_sell_volume=total_sell_volume)
                volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code, total_sell_volume=total_sell_volume)
                if volume_rate < 0.6:
                    return False, f"昨日炸板，量比（{volume_rate}）<0.6"
        # 获取涨停价
@@ -48,10 +48,13 @@
        zyltgb = global_util.zyltgb_map.get(code)
        if zyltgb:
            zyltgb_as_yi = round(zyltgb / 100000000, 2)
            if zyltgb_as_yi > constant.MAX_CODE_RADICAL_BUY_ZYLTGB_AS_YI:
                return False, "自由流通市值过大"
            elif zyltgb_as_yi < constant.MIN_CODE_RADICAL_BUY_ZYLTGB_AS_YI:
                return False, "自由流通市值过小"
            zylt_can_buy = False
            for zy in constant.RADICAL_BUY_ZYLTGB_AS_YI_RANGES:
                if zy[0] <= zyltgb_as_yi <= zy[1]:
                    zylt_can_buy = True
                    break
            if not zylt_can_buy:
                return False, "自由流通市值不满足扫的范围"
        # 判断昨日是否跌幅过大
        k_format = code_nature_analyse.CodeNatureRecordManager().get_k_format_cache(code)
        if k_format and len(k_format) > 12 and k_format[12]:

 trade/radical_buy_strategy.py

@@ -139,8 +139,9 @@
        rate = round(__deal_active_buy_total_money[code] / total_sell, 2)
        # 获取当前的成交量比
        limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)
        volume_rate = code_volumn_manager.get_volume_rate(code, total_sell_volume=int(total_sell / limit_up_price),
                                                          with_info=False)
        volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code, total_sell_volume=int(
            total_sell / limit_up_price),
                                                                              with_info=False)
        if volume_rate is None:
            volume_rate = 0.5
        # 根据大单判断是否可以扫
@@ -159,7 +160,7 @@
            return BUY_MODE_NONE, f"被动卖成交比例未达到：剩余涨停总卖额-{selling_num * price}，原涨停总卖-{total_sell}，已成交额-{__deal_active_buy_total_money[code]}，成交比例-{rate}/{THRESHOLD_RATE}"
    else:
        # 根据量比与大单成交数量判断是否可扫
        volume_rate = code_volumn_manager.get_volume_rate(code, with_info=False)
        volume_rate = code_volumn_manager.CodeVolumeManager().get_volume_rate(code, with_info=False)
        if volume_rate is None:
            volume_rate = 0.5
        # 根据大单判断是否可以扫
@@ -176,13 +177,19 @@
    @param volume_rate:
    @return:
    """
    money_y = code_volumn_manager.get_reference_volume_as_money_y(code)
    limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)
    refer_volume = code_volumn_manager.CodeVolumeManager().get_max_volume_in_5days(code)
    if refer_volume is None:
        refer_volume = 0

    money_y = int(refer_volume * limit_up_price / 1e8)
    money_y = min(money_y, 50)
    money_y = max(money_y, 5)
    # 计算大单参考数量
    threshold_count = int(round(0.4*money_y))
    threshold_count = int(round(0.4 * money_y))
    current_big_order_deal_count = EveryLimitupBigDealOrderManager.get_big_buy_deal_order_count(code)
    if volume_rate >= 0.5:
    if volume_rate >= 0.5 or True:
        # 按量大于50%算
        # 当换手量＞50%时，则，不需要每次扫入时需要≥2笔大单，而是累计需要≥2笔大单即可
        deal_big_order_count = BigOrderDealManager().get_total_buy_count(code)
        if deal_big_order_count >= threshold_count:

 utils/buy_strategy_util.py

@@ -147,8 +147,8 @@
    # today = get_today_volumn(code)
    # max60, yesterday = get_histry_volumn(code)
    try:
        today_volume = code_volumn_manager.get_today_volumn_cache(code)
        histry_volumn = code_volumn_manager.get_histry_volumn(code)
        today_volume = code_volumn_manager.CodeVolumeManager().get_today_volumn_cache(code)
        histry_volumn = code_volumn_manager.CodeVolumeManager().get_histry_volumn(code)
        if not today_volume or not histry_volumn:
            return False, "尚未获取到量"
        threshhold_volume = (histry_volumn[0][0] - today_volume) // 3
@@ -202,8 +202,8 @@

    # 阈值的取值范围
    THRESHOLD_MONEY_RANGE = 1e5, 3e5
    today_volume = code_volumn_manager.get_today_volumn_cache(code)
    histry_volumn = code_volumn_manager.get_histry_volumn(code)
    today_volume = code_volumn_manager.CodeVolumeManager().get_today_volumn_cache(code)
    histry_volumn = code_volumn_manager.CodeVolumeManager().get_histry_volumn(code)
    if not today_volume or not histry_volumn:
        return False, "尚未获取到量"
    threshhold_volume = (histry_volumn[0][0] - today_volume) // 6 // 100

 utils/init_data_util.py

@@ -22,7 +22,6 @@
        gpcode_manager.CodePrePriceManager.set_price_pre(symbol, pre_close, force)



# 获取近90天的最大量与最近的量
# 获取最近一次涨停/涨停下一个交易日的最大值
def get_volumns_by_code(code, count=60):
@@ -63,6 +62,26 @@
        "%Y-%m-%d"), refer_index


def parse_max_volume_in_days(datas, max_day):
    """
    解析最近几天最大的量
    @param datas:
    @param max_day:
    @return:
    """
    # 解析最近几天的最大量
    datas = datas[:max_day]
    max_volume_info = None
    for d in datas:
        if max_volume_info is None:
            max_volume_info = (d["volume"], d)
        if d["volume"] > max_volume_info[0]:
            max_volume_info = (d["volume"], d)
    if max_volume_info:
        return max_volume_info[0]
    return None


# 返回：(60天最大量,昨日量,量参考日期,参考量据今交易日数)
def __parse_max_volume(code, datas, is_new_or_near_top=False):
    max_volume = 0