陶博士月线反转6.4 python 化代码

陶博士月线反转6.4 python 化代码

量化系统有好几个月没有进度了，之前一直纠结策略问题，无从下手。最近和量化的同学聊了下，还得先把自动交易流程先跑起来后面再慢慢优化策略。

所以先拿陶博士的月线反转6.4 python 化，作为试水的策略把整个流程跑起来。后面开始研究怎么自动化交易。

聊回正题，陶博士月线反转策略(该策略来自陶博士)：

条件

  1. RPS50大于87
  2. RPS120大于90
  3. 当天RPS50或RPS120大于90
  4. 创70日最高收盘价
  5. 创70日新高，且当天RPS50或RPS120大于90。
  6. 50日内最低价大于200日内最低价
  7. 30日内最低价大于120日内最低价
  8. 20日内最低价大于50日内最低价
  9. 满足条件6，7，8 作为结构紧凑的重要条件
  10. 10天内曾创80日新高
  11. 当天创50日最高收盘价或50日最高价，且RPS50或RPS120大于90
  12. 当天收盘价必须站上20天线和200天线
  13. 当天收盘价大于200天线
  14. 当天收盘价大于250天线
  15. 45天内，收盘价站上200天线的天数大于等于2，小于45
  16. 45天内，至少有一天的最低价低于200天线;且至少站上200天线3天以上
  17. 45天内，至少有一天的最低价低于250天线;且至少站上250天线3天以上
  18. 120天线或200天线呈上升趋势
  19. 120天线或200天线呈上升趋势
  20. 120天线和200天线线呈上升趋势
  21. 120天线和200天线线呈上升趋势
  22. 120日线、200日线呈多头排列
  23. 30天内最高价与120日内最低价之比小于1.50，且120天线或200天线呈上升趋势
  24. 30天内最高价与120日内最低价之比小于1.55，且120天线和200天线线呈上升趋势
  25. 30天内最高价与120日内最低价之比小于1.65，且长期均线呈多头排列
  26. 5天内最高价距离120日内的最高价不到15%
  27. 5天内最高价距离120日内的最高价不到20%
  28. 当天收盘价距离10日内的最高价不到10%

python代码

陶博士 6.4 的公式对应 is_mouth_line_reversal 函数，其他方法是选股方法，采用了多进程，速度还行，全 A 选股一次 26 s左右（本机本系统的测试）。

import multiprocessing
import os
import time

import pandas as pd

import database.stockdatabasev2 as sdb
from config.stockconfigv2 import StockConfigV2


def is_mouth_line_reversal(df: pd.DataFrame) -> list:
    """
    陶博士月线反转 6.4
    该方法默认本地已经计算好了 rps50、rps120、rps250
    df: 列 ['open', 'high', 'low', 'close', 'rps50', 'rps120', 'rps250']
    index: 日期
    只是翻译陶博士月线反转6.4 的公式，可以优化均值计算，从本地数据库读取数据，为了通用性，这里就没有优化
    """
    last_time = time.time()
    # {RPS50大于87}
    # FYX11赋值:如果RPS50>=87,返回1,否则返回0
    FYX11 = df['rps50'].apply(lambda x: True if x >= 87 else False)

    # {RPS120大于90}
    # FYX12赋值:如果RPS120>=90,返回1,否则返回0
    FYX12 = df['rps120'].apply(lambda x: True if x >= 90 else False)

    # {当天RPS50或RPS120大于90，在后面被FYX32引用}
    # FYX130赋值:RPS50>=90 OR RPS120>=90
    c1 = df['rps50'].apply(lambda x: True if x >= 90 else False)
    c2 = df['rps120'].apply(lambda x: True if x >= 90 else False)
    FYX130 = c1 | c2

    # {创70日最高收盘价}
    # FYX131赋值:收盘价>=70日内收盘价的最高值
    FYX131 = df['close'] >= df['close'].rolling(70).max()

    # {创70日新高，且当天RPS50或RPS120大于90。在后面被FYX21、FYX22、FYX63、FYX72等引用}
    # FYX13赋值:FYX130 AND FYX131
    FYX13 = FYX130 & FYX131

    # FYX1赋值:FYX11 OR FYX12
    FYX1 = FYX11 | FYX12

    # {50日内最低价大于200日内最低价}
    # FYX21赋值:50日内最低价的最低值>200日内最低价的最低值 AND FYX13
    c1 = df['low'].rolling(50).min() > df['low'].rolling(200).min()
    FYX21 = c1 & FYX13

    # {30 日内最低价大于120日内最低价，且FYX13}
    # FYX22赋值:30日内最低价的最低值>120日内最低价的最低值 AND FYX13
    c1 = df['low'].rolling(30).min() > df['low'].rolling(120).min()
    FYX22 = c1 & FYX13

    # {20日内最低价大于50日内最低价，顺鑫农业2018年4月2日的月线反转信号}
    # FYX23赋值:20日内最低价的最低值>50日内最低价的最低值
    FYX23 = df['low'].rolling(20).min() > df['low'].rolling(50).min()

    # {结构紧凑的重要条件}
    # FYX2赋值:FYX21 OR FYX22 OR FYX23
    FYX2 = FYX21 | FYX22 | FYX23

    # NH80赋值:如果最高价>80日内最高价的最高值,赋值 0,否则赋值1
    c1 = df['high'] > df['high'].rolling(80).max()
    NH80 = c1.apply(lambda x: 0 if x else 1)

    # {10天内曾创80日新高}
    # FYX31赋值:统计NH8010日中满足True的天数
    FYX31 = NH80.rolling(10).sum() > 0

    # {当天创50日最高收盘价或50日最高价，且RPS50或RPS120大于90}
    # FYX32赋值:(收盘价>=50日内收盘价的最高值 OR 最高价>=50日内最高价的最高值) AND FYX130
    c1 = df['close'] >= df['close'].rolling(50).max()
    c2 = df['high'] >= df['high'].rolling(50).max()
    FYX32 = (c1 | c2) & FYX130

    # FYX3赋值:FYX31 OR FYX32
    FYX3 = FYX31 | FYX32

    # {当天收盘价必须站上20天线和200天线}
    # FYX4赋值:收盘价>收盘价的20日简单移动平均 AND 收盘价>收盘价的200日简单移动平均 AND 收盘价的120日简单移动平均/收盘价的200日简单移动平均>0.9
    c1 = df['close'] > df['close'].rolling(20).mean()
    c2 = df['close'] > df['close'].rolling(200).mean()
    c3 = df['close'].rolling(120).mean() / df['close'].rolling(200).mean() > 0.9
    FYX4 = c1 & c2 & c3

    # {当天收盘价大于200天线}
    # NN200赋值:如果收盘价>收盘价的200日简单移动平均,返回1,否则返回0
    c1 = df['close'] > df['close'].rolling(200).mean()
    NN200 = c1.apply(lambda x: 1 if x else 0)

    # AA200赋值:统计45日中满足NN200的天数
    AA200 = NN200.rolling(45).sum()

    # {当天收盘价大于250天线}
    # NN250赋值:如果收盘价>收盘价的250日简单移动平均,返回1,否则返回0
    c1 = df['close'] > df['close'].rolling(250).mean()
    NN250 = c1.apply(lambda x: 1 if x else 0)

    # AA250赋值:统计45日中满足NN250的天数
    AA250 = NN250.rolling(45).sum()

    # {45天内，收盘价站上200天线的天数大于等于2，小于45}
    # FYX51赋值:AA200>=2 AND AA200<45
    FYX51 = (AA200 >= 2) & (AA200 < 45)

    # LNN200赋值:如果最低价<收盘价的200日简单移动平均,返回1,否则返回0
    c1 = df['low'] < df['close'].rolling(200).mean()
    LNN200 = c1.apply(lambda x: 1 if x else 0)

    # LAA200赋值:统计45日中满足LNN200的天数
    LAA200 = LNN200.rolling(45).sum()

    # {45天内，至少有一天的最低价低于200天线;且至少站上200天线3天以上}
    # FYX52赋值:LAA200>0 AND AA200>2
    FYX52 = (LAA200 > 0) & (AA200 > 2)

    # LNN250赋值:如果最低价<收盘价的250日简单移动平均,返回1,否则返回0
    c1 = df['low'] < df['close'].rolling(250).mean()
    LNN250 = c1.apply(lambda x: 1 if x else 0)

    # LAA250赋值:统计45日中满足LNN250的天数
    LAA250 = LNN250.rolling(45).sum()

    # {45天内，至少有一天的最低价低于250天线;且至少站上250天线3天以上}
    # FYX53赋值:LAA250>0 AND AA250>2
    FYX53 = (LAA250 > 0) & (AA250 > 2)

    # FYX5赋值:FYX51 OR FYX52 OR FYX53
    FYX5 = FYX51 | FYX52 | FYX53

    # {120天线或200天线呈上升趋势}
    # FYX6011赋值:收盘价的120日简单移动平均>=10日前的收盘价的120日简单移动平均 OR 收盘价的200日简单移动平均>=10日前的收盘价的200日简单移动平均
    c1 = df['close'].rolling(120).mean() >= df['close'].shift(10).rolling(120).mean()
    c2 = df['close'].rolling(200).mean() >= df['close'].shift(10).rolling(200).mean()
    FYX6011 = c1 | c2

    # {120天线或200天线呈上升趋势}
    # FYX6012赋值:收盘价的120日简单移动平均>=15日前的收盘价的120日简单移动平均 OR 收盘价的200日简单移动平均>=15日前的收盘价的200日简单移动平均
    c1 = df['close'].rolling(120).mean() >= df['close'].shift(15).rolling(120).mean()
    c2 = df['close'].rolling(200).mean() >= df['close'].shift(15).rolling(200).mean()
    FYX6012 = c1 | c2

    # FYX601赋值:FYX6011 OR FYX6012
    FYX601 = FYX6011 | FYX6012

    # {120天线和200天线线呈上升趋势}
    # FYX6021赋值:收盘价的120日简单移动平均>=10日前的收盘价的120日简单移动平均 AND 收盘价的200日简单移动平均>=10日前的收盘价的200日简单移动平均
    c1 = df['close'].rolling(120).mean() >= df['close'].shift(10).rolling(120).mean()
    c2 = df['close'].rolling(200).mean() >= df['close'].shift(10).rolling(200).mean()
    FYX6021 = c1 & c2

    # {120天线和200天线线呈上升趋势}
    # FYX6022赋值:收盘价的120日简单移动平均>=15日前的收盘价的120日简单移动平均 AND 收盘价的200日简单移动平均>=15日前的收盘价的200日简单移动平均
    c1 = df['close'].rolling(120).mean() >= df['close'].shift(15).rolling(120).mean()
    c2 = df['close'].rolling(200).mean() >= df['close'].shift(15).rolling(200).mean()
    FYX6022 = c1 & c2

    # FYX602赋值:FYX6021 OR FYX6022
    FYX602 = FYX6021 | FYX6022

    # {120日线、200日线呈多头排列}
    # FYX603赋值:收盘价的120日简单移动平均>收盘价的200日简单移动平均 AND FYX601
    FYX603 = (df['close'].rolling(120).mean() > df['close'].rolling(200).mean()) & FYX601

    # {30天内最高价与120日内最低价之比小于1.50，且120天线或200天线呈上升趋势，石英股份2022年的平台在120天左右}
    # FYX61赋值:30日内最高价的最高值/120日内最低价的最低值<1.50 AND FYX601
    c1 = df['high'].rolling(30).max() / df['low'].rolling(120).min() < 1.50
    FYX61 = c1 & FYX601

    # {30天内最高价与120日内最低价之比小于1.55，且120天线和200天线线呈上升趋势}
    # FYX62赋值:30日内最高价的最高值/120日内最低价的最低值<1.55 AND FYX602
    c1 = df['high'].rolling(30).max() / df['low'].rolling(120).min() < 1.55
    FYX62 = c1 & FYX602

    # {30天内最高价与120日内最低价之比小于1.65，且长期均线呈多头排列，且满足FYX13}
    # FYX63赋值:30日内最高价的最高值/120日内最低价的最低值<1.65 AND FYX603 AND FYX13
    c1 = df['high'].rolling(30).max() / df['low'].rolling(120).min() < 1.65
    FYX63 = c1 & FYX603 & FYX13

    # FYX6赋值:FYX61 OR FYX62 OR FYX63
    FYX6 = FYX61 | FYX62 | FYX63

    # {5天内最高价距离120日内的最高价不到15 %}
    # FYX71赋值:5日内最高价的最高值/120日内最高价的最高值>0.85
    c1 = df['high'].rolling(5).max() / df['high'].rolling(120).max() > 0.85
    FYX71 = c1

    # {5天内最高价距离120日内的最高价不到20 %，且满足FYX13}
    # FYX72赋值:5日内最高价的最高值/120日内最高价的最高值>0.8 AND FYX13
    c1 = df['high'].rolling(5).max() / df['high'].rolling(120).max() > 0.8
    FYX72 = c1 & FYX13

    # {当天收盘价距离10日内的最高价不到10 %}
    # FYX73赋值:收盘价/10日内最高价的最高值>0.9
    c1 = df['close'] / df['high'].rolling(10).max() > 0.9
    FYX73 = c1

    # FYX7赋值:(FYX71 OR FYX72) AND FYX73
    FYX7 = (FYX71 | FYX72) & FYX73

    # YXFZ赋值:FYX1 AND FYX2 AND FYX3 AND FYX4 AND FYX5 AND FYX6 AND FYX7
    YXFZ = FYX1 & FYX2 & FYX3 & FYX4 & FYX5 & FYX6 & FYX7

    # OUT赋值：当满足条件在15周期内首次YXFZ距今天数=0时
    OUT = YXFZ.apply(lambda x: 1 if x else 0).rolling(15).sum().apply(lambda x: 1 if x > 0 else 0).diff(1)

    # 找出出大于等于1 的日期,并格式化%Y-%m-%d
    OUT = OUT[OUT >= 1]
    BUY_DATE = OUT.index.strftime('%Y-%m-%d').tolist()
    # print(f'耗时：{time.time() - last_time}', '月线反转:', BUY_DATE)
    return BUY_DATE


def _mouth_stock_picking_task(
        task_index,
        part_codes,
        start_time,
        end_time
):
    """
    月线反转选股任务，由于封装好的数据库可以一次性查多个股数据，所以一次性查回来即可
    选出来的时最后一个交易日的股票代码，如果需要一段时间的，修改日期判断范围即可
    @param part_codes: 任务需要处理的股票代码集合
    @param start_time: 开始时间 注意，开始时间必须比结束时间早一年多，否则影响计算结果
    @param end_time: 结束时间 注意，结束时间必须是最近一个交易日，否则影响计算结果
    """

    last_time = time.time()
    # 本地数据库方法，一次性查回所有股票数据股票集合时part_codes
    all_stocks_df = sdb.stock_daily(part_codes, start_time, end_time)
    picking_list = []
    for code in part_codes:
        stock_df = all_stocks_df[all_stocks_df['code'] == code]
        stock_df.sort_index(inplace=True)
        buy_date = is_mouth_line_reversal(stock_df)

        # 如果买点日期包含end_time，说明是最近一个交易日的买点
        if len(buy_date) > 0 and end_time in buy_date:
            picking_list.append(code)
        #
        # if len(buy_date) > 0:
        #     picking_list.append(code)
    print(f'任务{task_index}耗时：{time.time() - last_time}', '月线反转:', picking_list)

    return picking_list


def mouth_line_reversal_stock_picking():
    """
    月线反转选股，多进程提速
    """
    config = StockConfigV2()
    # 本地配置，全 A 的股票代码
    stock_codes = config.get_stock_codes()
    start_time = '2022-06-01'  # 距离最后一个交易日提前一年半
    end_time = '2023-12-02'  # 最近一个交易日
    end_time = config.legal_trade_date(end_time)

    last_time = time.time()

    picking_list = []
    # 根据 cpu 个数拆分股票任务数
    cpu_count = os.cpu_count()
    item_count = int(len(stock_codes) / cpu_count)
    with multiprocessing.Pool(processes=cpu_count) as pool:
        futures = []
        for sumLen in range(cpu_count):
            start_index = sumLen * item_count
            end_index = start_index + item_count
            # 如果是最后一个任务，索引到最后
            if sumLen == cpu_count - 1:
                end_index = len(stock_codes)
            # 切片，分任务
            part_codes = stock_codes[start_index: end_index]
            print(f'任务{sumLen} 开始位置：{start_index} 结束位置：{end_index}')
            # 异步启动任务
            future = pool.apply_async(_mouth_stock_picking_task,
                                      args=(sumLen,
                                            part_codes,
                                            start_time,
                                            end_time)
                                      )
            futures.append(future)

        # 等待所有任务完毕
        pool.close()
        pool.join()

        # 获取所有任务的返回值
        for future in futures:
            picking_list += future.get()
        print(f'总耗时：{time.time() - last_time}', '月线反转财富代码:', picking_list)


if __name__ == '__main__':
    # start_time = '2022-01-01'
    # end_time = '2023-12-02'
    # stocks_df = sdb.stock_daily('000429', start_time, end_time)
    # is_mouth_line_reversal(stocks_df)
    mouth_line_reversal_stock_picking()
    pass

跑代码日志： alt

验证

这 python 化的代码到底准不准？我们验证一下出现买点的时间是否和通达信一直即可。由于我的量化系统已经实现了买点标注的功能，验证相对简单。我对比了很多个票，买点位置都是可以对得上的，所以上面的代码是问题不大的。

代码002575
通达信： alt 我自己的系统标注： alt

代码300058
通达信： alt 我自己的系统标注： alt

写于 2023 年 12 月 03 日 17:16

本文由 mdnice 多平台发布

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/215221.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

LVS-DR+Keepalived+动静分离实验

LVS-DR+Keepalived+动静分离实验

架构图 解释一下架构&#xff0c;大概就是用Keepalived实现两台DR服务器的LVS负载均衡&#xff0c;然后后端服务器是两台Nginx服务器两台Tomcat服务器并且实现动静分离这个实验其实就是把 LVS-DRKeepalived 和 动静分离 给拼起来&#xff0c;真的是拼起来&#xff0c;两个部分…
阅读更多...
【工具使用-Audition】如何使用Audition查看频率

【工具使用-Audition】如何使用Audition查看频率

一&#xff0c;简介 在工作过程中要对处理后的音频进行频率分析&#xff0c;本文以Audition 2020为例进行说明&#xff0c;供参考。 二&#xff0c;操作步骤 2.1 生成测试音源 使用Audition生成左通道为1KHz&#xff0c;右通道为10KHz的音源信号 如图所示&#xff1a; 2.…
阅读更多...
UE学习C++（1）创建actor

UE学习C++（1）创建actor

创建新C类 在 虚幻编辑器 中&#xff0c;点击 文件&#xff08;File&#xff09; 下拉菜单&#xff0c;然后选择 新建C类...&#xff08;New C Class...&#xff09; 命令&#xff1a; 此时将显示 选择父类&#xff08;Choose Parent Class&#xff09; 菜单。可以选择要扩展的…
阅读更多...
学习-java多线程面试题

学习-java多线程面试题

为什么不建议用Executors启动线程池 *队列LinkedBlockingQueue是没有边界的队列,请求多会造成OOM *建议使用ThreadPoolExecutors 线程池中提交一个任务的流程&#xff1f; 1先判断线程池是否有线程&#xff0c;如果与就直接执行&#xff0c;没有就放队列 2如果队列满了&#…
阅读更多...
kubeadm 安装k8s1.28.x 底层走containerd 容器

kubeadm 安装k8s1.28.x 底层走containerd 容器

1. k8s1.28.x 的概述 1.1 k8s 1.28.x 更新 Kubernetes v1.28 是 2023 年的第二个大版本更新&#xff0c;包含了 46 项主要的更新。 而今年发布的第一个版本 v1.27 有近 60 项&#xff0c;所以可以看出来&#xff0c;在发布节奏调整后&#xff0c; 每个 Kubernetes 版本中都会包…
阅读更多...
使用 .NET Upgrade Assistant（升级助手）升级 .NET 老旧版本项目

使用 .NET Upgrade Assistant（升级助手）升级 .NET 老旧版本项目

使用 .NET Upgrade Assistant 升级 .NET 老旧版本项目 .NET Upgrade Assistant 概述.NET Upgrade Assistant 功能1、支持以下代码语言&#xff1a;2、支持的 .NET 升级路径&#xff1a;3、支持的项目类型&#xff1a; .NET Upgrade Assistant 安装1、使用 Visual Studio 扩展安…
阅读更多...
ASP.NET+ACCES视频点播系统设计

ASP.NET+ACCES视频点播系统设计

设计思想 设计方法采用模块划分、面向对象的设计思想&#xff0c;主要划分为以下几个模块&#xff1a;视频窗口模块、界面设计模块、实现搜索/点击排行等功能模块、数据库模块、后台管理模块&#xff0c;本人主要完成前三个模块的设计。 开发步骤&#xff1a;①首先进行需求分…
阅读更多...
四层LVS与七层Nginx负载均衡的区别

四层LVS与七层Nginx负载均衡的区别

一、四层负载均衡与七层负载均衡&#xff1a; &#xff08;1&#xff09;四层负载均衡&#xff1a; 四层负载均衡工作在 OSI 七层模型的第四层&#xff08;传输层&#xff09;&#xff0c;指的是负载均衡设备通过报文中的目标IP地址、端口和负载均衡算法&#xff0c;选择到达的…
阅读更多...
【C语言】字符串函数strlen #strcpy #strcmp #strcat #strstr及其模拟实现

【C语言】字符串函数strlen #strcpy #strcmp #strcat #strstr及其模拟实现

在C语言中&#xff0c;有一种特殊的数据类型&#xff0c;即字符串类型。C 并没有专门定义一个字符串类型&#xff0c;这对我们使用字符串造成了一定的麻烦。但是&#xff0c;C标准库<string.h> 中定义了各种字符串函数&#xff0c;这对于我们来说是一件值得庆幸的事情。…
阅读更多...
springboot 在自定义注解中注入bean,解决注入bean为null的问题

springboot 在自定义注解中注入bean,解决注入bean为null的问题

问题&#xff1a; 在我们开发过程中总会遇到比如在某些场合中需要使用service或者mapper等读取数据库&#xff0c;或者某些自动注入bean失效的情况 解决方法&#xff1a; 1.在构造方法中通过工具类获取需要的bean 工具类代码&#xff1a; import org.springframework.beans…
阅读更多...
深圳找工作的网站

深圳找工作的网站

深圳吉鹿力招聘网是一家在深圳做的比较好的招聘网站&#xff0c;提供一站式的专业人力资源服务&#xff0c;包括网络招聘、校园招聘、猎头服务、招聘外包、企业培训以及人才测评等。深圳吉鹿力招聘网在深圳的口碑相当好&#xff0c;是一个很好的选择。 深圳找工作用 吉鹿力招聘…
阅读更多...
从零构建属于自己的GPT系列1：数据预处理（文本数据预处理、文本数据tokenizer、逐行代码解读）

从零构建属于自己的GPT系列1：数据预处理（文本数据预处理、文本数据tokenizer、逐行代码解读）

&#x1f6a9;&#x1f6a9;&#x1f6a9;Hugging Face 实战系列 总目录 有任何问题欢迎在下面留言 本篇文章的代码运行界面均在PyCharm中进行 本篇文章配套的代码资源已经上传 从零构建属于自己的GPT系列1&#xff1a;文本数据预处理 从零构建属于自己的GPT系列2&#xff1a;语…
阅读更多...
VUE：ESLint如何自动修复代码

VUE：ESLint如何自动修复代码

在vue开发过程中第一步总会遇到一个问题&#xff0c;就是 代码本身没有问题&#xff0c;但是因为这是一个ESLint的错误提示&#xff0c;但是它指出了在文件E:\vscode\vuesua\src\views\HomeView.vue中的第18到33行存在缩进错误。具体来说&#xff0c;第18到25行的缩进应该是2个…
阅读更多...
HarmonyOS4.0系列——03、声明式UI、链式编程、事件方法、以及自定义组件简单案例

HarmonyOS4.0系列——03、声明式UI、链式编程、事件方法、以及自定义组件简单案例

HarmonyOS4.0系列——03、声明式UI、链式编程、事件方法、以及自定义组件简单案例 声明式 UI ArkTS以声明方式组合和扩展组件来描述应用程序的UI&#xff0c;同时还提供了基本的属性、事件和子组件配置方法&#xff0c;帮助开发者实现应用交互逻辑。 如果组件的接口定义没有包…
阅读更多...
iOS代码混淆工具

iOS代码混淆工具

目录 引言 混淆效果 字符串加密 代码插入 其他混淆选项说明 总结 参考资料 &#x1f512; 这是一篇介绍iOS代码混淆工具的技术博客&#xff0c;旨在帮助开发者提高代码安全性。本工具来自于Github的混淆词库和代码&#xff0c;通过差异化处理和代码合并生成数亿种用于混淆…
阅读更多...
什么是SpringMvc、SpringMvc23道常提到问题

什么是SpringMvc、SpringMvc23道常提到问题

1、什么是 SpringMvc&#xff1f; 答&#xff1a;SpringMvc 是 spring 的一个模块&#xff0c;基于 MVC(模型、视图、控制器) 的一个框架&#xff0c;无需中间整合层来整合。 扩展&#xff1a; 在Spring MVC中&#xff0c;各个组件的职责如下&#xff1a; 1.Model&#xff08;模…
阅读更多...
振弦读数模块开发时的要点

振弦读数模块开发时的要点

振弦读数模块开发时的要点 振弦读数模块是振弦采集仪中重要的组成部分&#xff0c;以下是开发时需要注意的要点&#xff1a; 1. 确定采样频率和精度&#xff1a;振弦采集仪必须以足够高的频率和精度采集振弦信号&#xff0c;以确保数据的准确性和完整性。 2. 选择合适的传感器…
阅读更多...
「Verilog学习笔记」占空比50%的奇数分频

「Verilog学习笔记」占空比50%的奇数分频

专栏前言 本专栏的内容主要是记录本人学习Verilog过程中的一些知识点&#xff0c;刷题网站用的是牛客网 根据题意7分频&#xff0c;实际上是第一次电平变化经历了4个上升沿3个下降沿&#xff0c;第二次电平变化是4个下降沿3个上升沿&#xff0c;所以用两个计数器就行了。分别对…
阅读更多...
【Python动漫系列】喜羊羊（完整代码）

【Python动漫系列】喜羊羊（完整代码）

文章目录 喜羊羊环境需求完整代码程序分析系列文章喜羊羊 喜羊羊是中国大陆一部儿童动画片《喜羊羊与灰太狼》中的主角之一。这部动画片自2005年开始播出，成为许多中国儿童最喜欢的动画之一。 喜羊羊是一只体型较小、毛色洁白的绵羊，性格机灵活泼，聪明机智。他是一只勇敢而…
阅读更多...
树_二叉树所有路劲

树_二叉树所有路劲

//给你一个二叉树的根节点 root &#xff0c;按 任意顺序 &#xff0c;返回所有从根节点到叶子节点的路径。 // // 叶子节点 是指没有子节点的节点。 // // 示例 1&#xff1a; // // //输入&#xff1a;root [1,2,3,null,5] //输出&#xff1a;["1->2->5&quo…
阅读更多...
最新文章

Copyright @ 2022~2023