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

news2025/1/20 3:52:10

陶博士月线反转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 多平台发布

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

最常用的Linux命令#程序员

最常用的Linux命令#程序员

最常用的Linux命令 #程序员 #linux 1. 文件和目录管理 icon2. 文件查看和编辑 3.流程管理 4. 系统信息 5. 用户和组管理 6. 网络配置与监控 7. 包管理
阅读更多...
产品学习之路（一）

产品学习之路（一）

在做好开发的同时&#xff0c;还需要熟悉产品业务逻辑&#xff0c;不能为了功能而做功能&#xff0c;要从产品经理的角度去看待每个需求和客户痛点所在&#xff0c;这样针对产品设计出来的东西自己也有发言权&#xff1b; 目前作为一名前端开发人员&#xff0c;也在自学产品知识…
阅读更多...
史上最全低代码平台盘点！三分钟盘点2023年顶尖二十个低代码平台！

史上最全低代码平台盘点！三分钟盘点2023年顶尖二十个低代码平台！

史上最全低代码平台盘点&#xff01;三分钟盘点2023年顶尖二十个低代码平台&#xff01; 什么是低代码平台&#xff1f;2023年顶尖二十大低代码平台&#xff0c;哪个值得一试&#xff1f;低代码平台应该如何选择&#xff1f;本篇&#xff0c;我们将为大家盘点顶尖的十大低代码平…
阅读更多...
tcexam 本地容器化搭建

tcexam 本地容器化搭建

PS: 参考[使用docker搭建tcexam在线考试平台-CSDN博客]&#xff0c;只记录和总结容器创建和install步骤 1. Git下载 tcexam_docker 工程源码至宿主机的 ~/git/ 目录 mkdir ~/git && cd ~/git git clone https://gitee.com/39627020/tcexam_docker.git mv tcexam_doce…
阅读更多...
计算机网络体系的形成

计算机网络体系的形成

目录 1、开放系统互连参考模型OSI/RM 2、两种国际标准 3、协议与划分层次 4、网络协议的三要素 5、划分层次 &#xff08;1&#xff09;文件发送模块使两个主机交换文件 &#xff08;2&#xff09;通信服务模块 &#xff08;3&#xff09;接入网络模块 6、分层带来的好…
阅读更多...
Redis--14--BigKey 和 热点Key

Redis--14--BigKey 和 热点Key

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 BigKey1.什么是bigkey2.bigkey的危害3.发现bigkeyscan 4.解决bigkey 什么是热点Key&#xff1f;该如何解决1. 产生原因和危害原因危害 2.发现热点key预估发现客户端…
阅读更多...
leetcode：232. 用栈实现队列

leetcode：232. 用栈实现队列

一、题目 原题链接&#xff1a;232. 用栈实现队列 - 力扣&#xff08;LeetCode&#xff09; 函数原型&#xff1a; typedef struct //我的队列结构定义 { } MyQueue; MyQueue* myQueueCreate() //我的队列创建及其初始化 void myQueuePush(MyQueue* obj, int x) //我的队…
阅读更多...
【Python】tensorflow学习的个人纪录（1）

【Python】tensorflow学习的个人纪录（1）

def learn(self, s, r, s_):s, s_ s[np.newaxis, :], s_[np.newaxis, :]v_ self.sess.run(self.v, {self.s: s_})td_error, _ self.sess.run([self.td_error, self.train_op],{self.s: s, self.v_: v_, self.r: r})return td_error代码步入&#xff1a; v_ self.ses…
阅读更多...
华为攻击防范简介

华为攻击防范简介

定义 攻击防范是一种重要的网络安全特性。它通过分析上送CPU处理的报文的内容和行为&#xff0c;判断报文是否具有攻击特性&#xff0c;并配置对具有攻击特性的报文执行一定的防范措施。 攻击防范主要分为畸形报文攻击防范、分片报文攻击防范和泛洪攻击防范。 目的 目前&…
阅读更多...
qt-C++笔记之QStringList

qt-C++笔记之QStringList

qt-C笔记之QStringList —— 杭州 2023-12-03 文章目录 qt-C笔记之QStringList1.1.官方文档第一部分翻译&#xff1a;继承自QList\<QString\>-初始化-添加字符串1.2.迭代字符串1.3.join()和split()1.4.filter()1.5.lastIndexOf()1.6.indexOf()1.7.replaceInStrings()以及…
阅读更多...
react之封装有无Token(路由权限控制)的高阶组件

react之封装有无Token(路由权限控制)的高阶组件

TOC 前景 有些路由页面内的内容信息比较敏感&#xff0c;如果用户没有经过登录获取到有效Token&#xff0c;是没有权限跳转的&#xff0c;根据Token的有 无控制当前路由是否可以跳转就是路由的权限控制 技术方案 实现步骤 1.在 components 目录中&#xff0c;创建 AuthRoute/in…
阅读更多...
微机原理——定时器8253(8254)学习1

微机原理——定时器8253(8254)学习1

目录 定时类型 8253内部结构框图 8253命令字 六种工作方式及输出波形 计数初值的计算与装入 8253的初始化 定时类型 可编程定时器8253&#xff1a;&#xff08;内部采用的是16位 减法计数器&#xff09; 8253内部结构框图 8253命令字 8253有三个命令字&#xff1a;方式命…
阅读更多...
flutter使用动态路由传参的最小案例

flutter使用动态路由传参的最小案例

flutter中使用动态路由传递参数的封装案例&#xff0c;子组件页面只需要接收arguments参数即可&#xff0c;参数是一个map&#xff0c;里面包含有所需要的参数&#xff0c;类似于json。在MaterialApp中配置onGenerateRoute&#xff0c;然后动态判断传递参数&#xff1a; route…
阅读更多...
Python程序员入门指南：就业前景

Python程序员入门指南：就业前景

文章目录 标题Python程序员入门指南&#xff1a;就业前景Python 就业数据Python的就业前景SWOT分析法Python 就业分析 标题 Python程序员入门指南&#xff1a;就业前景 Python是一种流行的编程语言&#xff0c;它具有简洁、易读和灵活的特点。Python可以用于多种领域&#xff…
阅读更多...
Mininet学习记录（常用命令+创建网络拓扑+OpenDaylight显示拓扑结构)

Mininet学习记录（常用命令+创建网络拓扑+OpenDaylight显示拓扑结构)

目录 1.Mininet简介2.Mininet常用命令2.1创建网络拓扑常用参数2.2常用的内部交换命令3.创建网络拓扑的三种方式3.1通过命令行创建3.2通过miniedit可视化界面创建3.3通过python脚本创建4.问题总结1.Mininet简介 Mininet 是由一些虚拟的终端节点 (end-hosts) 、交换机、路由器连接…
阅读更多...
PPT设置背景颜色

PPT设置背景颜色

问题描述&#xff1a;PPT如何设置背景颜色&#xff1f; 问题解决&#xff1a;设计→设置背景格式→颜色→蓝色&#xff08;最好选择看着比较舒服的颜色&#xff09;
阅读更多...
「C++」位图和布隆过滤器

「C++」位图和布隆过滤器

&#x1f4bb;文章目录 位图概念位图的实现位图的应用 布隆过滤器概念布隆过滤器的哈希函数布隆过滤器的插入布隆过滤器的查找布隆过滤器的删除 &#x1f4d3;总结 位图 概念 所谓位图&#xff0c;就是在每一位bit位上存放某种状态&#xff0c;1就代表存在&#xff0c;0就代表…
阅读更多...
linux常用命令-grep命令与ps命令详解（超详细）

linux常用命令-grep命令与ps命令详解（超详细）

文章目录 前言一、grep命令介绍1. grep命令简介2. grep命令的基本语法3. 常用的grep命令选项 二、grep命令示例用法1. 在文件中搜索匹配模式的行2. 忽略大小写地搜索匹配模式的行3. 反转匹配&#xff0c;只打印不匹配模式的行4. 显示匹配行的行号5. 统计匹配的行数6. 打印包含匹…
阅读更多...
C++：C++11新特性--lambda表达式和包装器

C++：C++11新特性--lambda表达式和包装器

文章目录 lambda表达式lambda表达式的使用规则lambda表达式的用法lambda表达式的理解函数对象和lambda表达式 包装器bind lambda表达式 首先介绍什么是lambda表达式&#xff0c;在介绍这个情景前&#xff0c;可以回忆一下算法库中的sort排序&#xff1a; // lambda表达式 voi…
阅读更多...
HADOOP：：Fsimage和Edits解析

HADOOP：：Fsimage和Edits解析

NameNode被格式化之后&#xff0c;将在/opt/module hadoop-3.1.3/data/tmp/dfs/name/curent目录 中产生如下文件 fsimage_ 0000000000000000000 fsimage_ 0000000000000000000.md5 seen_txid VERSION (1) Fsimage文件: HDFS文件系统元数据的一个永久性的检查点&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023