2.2.1.2-网格交易(python网格交易附实战交易记录)

news2024/10/7 16:25:08

跳转到根目录：知行合一：投资篇

已完成：
1、投资&技术
  1.1.1 投资-编程基础-numpy
  1.1.2 投资-编程基础-pandas
  1.2 金融数据处理
  1.3 金融数据可视化
2、投资方法论
  2.1.1 预期年化收益率
  2.1.2 一个关于y=ax+b的故事
  2.1.3-数据标准化
  2.1.4-相关性分析
  2.2.1.1-一个关于定投的故(姿)事(势)
  2.2.1.2-网格交易
  2.2.1.3-移动平均线

3、投资实证
  [3.1 2023这一年] 被鸽

文章目录

  • 1. 网格策略说明
    • 1.1. 策略说明
    • 1.2. 策略数据样例
  • 2. 策略实现
    • 2.1. 数据结构定义
    • 2.2. 加载数据
    • 2.3. 主代码
      • 2.3.1. 先看看 want_buy
      • 2.3.2. 买入！today_buy
      • 2.3.3. want_sell
      • 2.3.4. 卖出！today_sell
    • 2.4. 完整代码
  • 3. 收益如何？

1. 网格策略说明

网格交易，说最简单的，就是跌了买，涨了卖。

为了少说废话，这里就举1个例子：

nameopenclosedate操作操作价格
券商ETF0.980.982016/9/14买0.98
券商ETF0.9830.9622016/9/26买0.97
券商ETF0.9821.0052016/10/18卖1
券商ETF1.0011.0252016/10/24卖1.01
券商ETF1.0011.0252016/10/24卖1.02
券商ETF1.0211.0312016/11/1卖1.03
券商ETF1.0251.052016/11/3卖1.04
券商ETF1.0251.052016/11/3卖1.05
券商ETF1.0551.0882016/11/11卖1.06
券商ETF1.0551.0882016/11/11卖1.07
券商ETF1.0551.0882016/11/11卖1.08
券商ETF1.091.0972016/11/14卖1.09
券商ETF1.0641.0342016/12/5买1.06
券商ETF1.0641.0342016/12/5买1.05
券商ETF1.0641.0342016/12/5买1.04
券商ETF1.0381.0262016/12/8买1.03
券商ETF1.0291.0012016/12/12买1.02
券商ETF1.0291.0012016/12/12买1.01
券商ETF1.0010.9882016/12/14买1
券商ETF1.0010.9882016/12/14买0.99
券商ETF0.9810.9762016/12/19买0.98
券商ETF0.9750.9632016/12/23买0.97
券商ETF0.9951.0022017/2/20卖1
券商ETF0.9740.9622017/3/22买0.97
券商ETF0.9730.962017/3/29买0.96
券商ETF0.950.9442017/4/19买0.95
券商ETF0.9420.9372017/5/2买0.94

1.1. 策略说明

  • 网格的大小，可以自己定义，我定义的是0.01作为一个网格

  • 买入一笔后，如果后面价格涨了x*0.01（这里x可以自己定，我定的是3），那么就卖出

  • 买入一笔后，如果后面价格跌了y*0.01（y一般就是1，也就是1网），那么就继续买入

  • 卖出一笔后，如果后面价格跌了x*0.01（这里x可以自己定，我定的是3），那么就买入

  • 卖出一笔后，如果后面价格涨了y*0.01（y一般就是1，也就是1网），那么就继续卖出

  • 第一天，默认就是买入

  • 后续是按照收盘价和之前买入或卖出的价格进行比较，看是否进行买或卖的操作

1.2. 策略数据样例

2016/9/14买入价0.98，那么，我们预期要么是在1.01卖出，要么是在0.97买入

到了2016/9/26，收盘价是0.962，是>0.97的，那我们就直接认为我们挂单了0.97买入

在2016/9/26以0.97买入之后，我们预期要么是在1.00卖出，要么是在0.96买入

到了2016/10/18，收盘价是1.005，是>1.00的，我们可以成交1笔卖出。

2. 策略实现

2.1. 数据结构定义

    def __init__(self, security, start_date=None, end_date=None) -> None:
        super().__init__()
        # security：是这次执行的代码，一般类似512000，510300之类
        # start_date、end_date：会在所有的数据行中，截取对应的时间片段。不传值，那默认就是None，就会用全量数据进行测算。
        # step_price：每个网格的大小，比如我们测算的是512000，是1左右净值的，1%作为网格，是合适的。
        # steps：买入一笔后，如果后面价格涨了x*0.01（这里x可以自己定，我定的是3），那么就卖出。这里的x，就是我们这里的steps
        self.args = {'security': security, 'start_date': start_date, 'end_date': end_date, 'step_price': 0.01, 'steps': 3}
        # 加载数据，后面会具体解释加载过程
        self.daily_df = self.load_data_2_df()
        # 保留本次交易的行数据，方便后面的使用（比如判断上一笔，是买入还是卖出操作）
        self.last_transaction = None
        # 交易历史，最后输出到csv，方便查看
        self.transactions = []

2.2. 加载数据

    def load_data_2_df(self):
        # 这个案例，是通过既有数据来跑的，512000，包含了从 2016-09-14 ~ 2024-03-29 的日线数据。
        # 如果想要自己获取数据，可以参考之前的文章：https://blog.csdn.net/sdfiiiiii/article/details/135289226，包含了从qstock获取、处理、存储数据等
        df = pd.read_csv("https://gitee.com/kelvin11/public-resources/raw/master/512000.csv")
        # 如果指定了start_date、end_date，就进行数据的切割
        if self.args['start_date']:
            df = df[df["date"] >= self.args['start_date']]
        if self.args['end_date']:
            df = df[df["date"] <= self.args['end_date']]
        # 转换为日期类型
        df['date'] = df['date'].apply(pd.to_datetime, format='%Y-%m-%d')
        # 按照日期的正序排序（防止数据错位）
        df.sort_values(by="date", ascending=True)
        # 设置dataframe的索引，后面取数比较简便一些.
        df = df.set_index("date")
        # 设置了date为索引之后，dataframe里面就没有date这一列了，有时候为了方便处理，还是把date给加上
        df['date'] = df.index.tolist()
        return df

2.3. 主代码

主代码，意味着，这里是执行流程的核心。

其实也比较简单，就是遍历dataframe，逐行处理数据即可。

    def process(self):
        # dataframe的遍历，逐行处理数据
        for index, row in self.daily_df.iterrows():
            # index是索引，就是日期；row是Series类型，一行完整的数据
            if index != self.daily_df.iloc[0]['date']:
                # 非第一天
                # 1.1 今日收盘价如果 < 上次操作的价格，那么可能要买。
                if row['close'] < self.last_transaction['价格']:
                    # want_buy，为什么可能要买，因为在网格中，如果之前是买入，当天价格下跌没有达到下一网，是不买的。这个逻辑在want_buy内部实现
                    self.want_buy(row=row)
                # 1.2 今日收盘价如果 > 上次操作的价格，那么可能要卖，want_sell
                elif row['close'] > self.last_transaction['价格']:
                    # want_sell其实和want_buy是同样的解释。因为在网格中，如果收盘价大于上次交易价格，但没有达到实际要卖出的价格，那也是不卖的。这个逻辑在want_sell内部实现
                    self.want_sell(row=row)
                else:
                    # hold方法，其实什么都没做，return None。意思就是持有不操作。
                    self.hold(row=row)
                print()
            else:
                # 是第一天，默认就是买入
                # want_buy方法，是指可能要买，为什么可能要买，因为在网格中，如果之前是买入，当天价格下跌没有达到下一网，是不买的。这个逻辑在want_buy内部实现
                self.want_buy(row=row)
        # 遍历完所有的数据之后，将所有的交易记录通过pandas存储到csv文件中
        df = pd.DataFrame(self.transactions)
        df.to_csv('%s交易记录.csv' % self.args['security'], index=None)

2.3.1. 先看看 want_buy

    def want_buy(self, row):
        if row['date'] == self.daily_df.iloc[0]['date']:
            # 这个是第一天的逻辑，直接执行买入。today_buy就真的是买入操作了，主要是记录买入价格和当前行数据
            this_trans = self.today_buy(row, row['close'])
            # 将买入行相关的信息，存储到self.transactions操作历史中，方便整体输出
            self.transactions.append(this_trans)
        else:
            # 这里就不是第一天了，要去判断是否能买的到（比如价格下跌没到下一网位置，就不买的。）
            if self.last_transaction['操作'] == '买':
                # 如果上一次的操作是'买'，那么要构造1个买入价格的阶梯 [上次买入价格, 今日收盘价]，按照'网格大小'构建一个阶梯price_stairs。
                # 用到的是numpy的arange方法，举例:print(np.arange(10,1,-2)) # 输出[10  8  6  4  2]
                start_buy_price = self.last_transaction['价格']
                price_stairs = np.arange(start_buy_price, row['close'], -self.args['step_price'])
                print('前一天是买入，价格%s。收盘价下跌, 构造的买入阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
                if len(price_stairs) >= 1:
                    # 因为，第一个价格是上次买入价格，所以不要包含在本次的买入阶梯里面，做一些切割[1:]
                    price_stairs = price_stairs[1:]
                    for price in price_stairs:
                        # 一般保留3位小数即可
                        price = round(price, 3)
                        # today_buy，是真正的做买入动作了。
                        this_trans = self.today_buy(row, price)
                        # 将买入信息，集中存储到transactions列表中，后续输出到文件
                        self.transactions.append(this_trans)
                else:
                    print('未达到买入阶梯价，今日不执行买入')
            elif self.last_transaction['操作'] == '卖':
                # 构造买入阶梯价，2. 如果"上一次"是卖出，那么要从"-3*网格"开始买
                start_buy_price = self.last_transaction['价格'] - self.args['steps'] * self.args['step_price']
                # 构造价格区间的方法，跟上面是一样的。
                price_stairs = np.arange(start_buy_price, row['close'], -self.args['step_price'])
                print('前一天是卖出，价格%s。收盘价下跌，构造的买入阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
                if start_buy_price == row['close']:
                    # 如果期望开始买的价格，正好是当天收盘价，其实就是此次要买入的价格
                    price_stairs = np.array([start_buy_price])
                if len(price_stairs) >= 1:
                    # 下面的逻辑，跟上面是一样的。
                    for price in price_stairs:
                        price = round(price, 3)
                        this_trans = self.today_buy(row, price)
                        self.transactions.append(this_trans)
                else:
                    print('未达到买入阶梯价，今日不执行买入')

2.3.2. 买入！today_buy

上面方法，用到的today_buy方法，其实就几行代码：

    def today_buy(self, row, price):
        # 扩充行数据元素，增加2列：操作 = 买，价格 = price
        self.daily_df.loc[row['date'], '操作'] = '买'
        self.daily_df.loc[row['date'], '价格'] = price
        # 将买入这个操作的信息，保存在临时变量 self.last_transaction 中，方便后面处理，能快速定位到上次交易是买入还是卖出，以及其价格
        self.last_transaction = self.daily_df.loc[row['date']]
        return self.last_transaction

2.3.3. want_sell

want_sell和want_buy方法及其相似，就不逐行解释了。

    def want_sell(self, row):
        # 构造卖出阶梯价，1. 如果"前一天"是卖出，那么构造卖出就是按照下一个"网格"卖
        if self.last_transaction['操作'] == '卖':
            start_sell_price = self.last_transaction['价格']
            price_stairs = np.arange(start_sell_price, row['close'], self.args['step_price'])
            print('前一天是卖出，价格%s。收盘价上涨, 构造的卖出阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
            if len(price_stairs) >= 1:
                price_stairs = price_stairs[1:]
                for price in price_stairs:
                    price = round(price, 3)
                    this_trans = self.today_sell(row, price)
                    self.transactions.append(this_trans)
            else:
                print('未达到卖出阶梯价，今日不执行卖出')
        # 构造卖出阶梯价，2. 如果"前一天"是买入出，那么要从"+3*网格"开始卖
        elif self.last_transaction['操作'] == '买':
            start_sell_price = self.last_transaction['价格'] + self.args['steps'] * self.args['step_price']
            price_stairs = np.arange(start_sell_price, row['close'], self.args['step_price'])
            print('前一天是买入，价格%s。收盘价上涨，构造的买卖出阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
            print(price_stairs)
            if start_sell_price == row['close']:
                price_stairs = np.array([start_sell_price])
            if len(price_stairs) >= 1:
                for price in price_stairs:
                    price = round(price, 3)
                    this_trans = self.today_sell(row, price)
                    self.transactions.append(this_trans)
            else:
                print('未达到卖出阶梯价，今日不执行卖出')

2.3.4. 卖出！today_sell

也是跟today_buy大同小异，没什么要特别说明的地方。

    def today_sell(self, row, price):
        # 扩充行数据元素，增加2列：操作 = 卖，价格 = price
        self.daily_df.loc[row['date'], '操作'] = '卖'
        self.daily_df.loc[row['date'], '价格'] = price
        # 将卖出这个操作的信息，保存在临时变量 self.last_transaction 中，方便后面处理，能快速定位到上次交易是买入还是卖出，以及其价格
        self.last_transaction = self.daily_df.loc[row['date']]
        return self.last_transaction

2.4. 完整代码

完整的代码已经全部都解释完了，就是上面的几个方法组合起来，就结束，整体代码量，加上充分的注释，163行。

废话少说，上干货，直接就能跑~

import pandas as pd
import numpy as np


class FixedGrid:

    def __init__(self, security, start_date=None, end_date=None) -> None:
        super().__init__()
        # security：是这次执行的代码，一般类似512000，510300之类
        # start_date、end_date：会在所有的数据行中，截取对应的时间片段。不传值，那默认就是None，就会用全量数据进行测算。
        # step_price：每个网格的大小，比如我们测算的是512000，是1左右净值的，1%作为网格，是合适的。
        # steps：买入一笔后，如果后面价格涨了x*0.01（这里x可以自己定，我定的是3），那么就卖出。这里的x，就是我们这里的steps
        self.args = {'security': security, 'start_date': start_date, 'end_date': end_date, 'step_price': 0.01, 'steps': 3}
        # 加载数据，后面会具体解释加载过程
        self.daily_df = self.load_data_2_df()
        # 保留本次交易的行数据，方便后面的使用（比如判断上一笔，是买入还是卖出操作）
        self.last_transaction = None
        # 交易历史，最后输出到csv，方便查看
        self.transactions = []

    def load_data_2_df(self):
        # 这个案例，是通过既有数据来跑的，512000，包含了从 2016-09-14 ~ 2024-03-29 的日线数据。
        # 如果想要自己获取数据，可以参考之前的文章：https://blog.csdn.net/sdfiiiiii/article/details/135289226，包含了从qstock获取、处理、存储数据等
        df = pd.read_csv("https://gitee.com/kelvin11/public-resources/raw/master/512000.csv")
        # 如果指定了start_date、end_date，就进行数据的切割
        if self.args['start_date']:
            df = df[df["date"] >= self.args['start_date']]
        if self.args['end_date']:
            df = df[df["date"] <= self.args['end_date']]
        # 转换为日期类型
        df['date'] = df['date'].apply(pd.to_datetime, format='%Y-%m-%d')
        # 按照日期的正序排序（防止数据错位）
        df.sort_values(by="date", ascending=True)
        # 设置dataframe的索引，后面取数比较简便一些.
        df = df.set_index("date")
        # 设置了date为索引之后，dataframe里面就没有date这一列了，有时候为了方便处理，还是把date给加上
        df['date'] = df.index.tolist()
        return df

    def today_buy(self, row, price):
        # 扩充行数据元素，增加2列：操作 = 买，价格 = price
        self.daily_df.loc[row['date'], '操作'] = '买'
        self.daily_df.loc[row['date'], '价格'] = price
        # 将买入这个操作的信息，保存在临时变量 self.last_transaction 中，方便后面处理，能快速定位到上次交易是买入还是卖出，以及其价格
        self.last_transaction = self.daily_df.loc[row['date']]
        return self.last_transaction

    def today_sell(self, row, price):
        # 扩充行数据元素，增加2列：操作 = 卖，价格 = price
        self.daily_df.loc[row['date'], '操作'] = '卖'
        self.daily_df.loc[row['date'], '价格'] = price
        # 将卖出这个操作的信息，保存在临时变量 self.last_transaction 中，方便后面处理，能快速定位到上次交易是买入还是卖出，以及其价格
        self.last_transaction = self.daily_df.loc[row['date']]
        return self.last_transaction

    def want_buy(self, row):
        if row['date'] == self.daily_df.iloc[0]['date']:
            # 这个是第一天的逻辑，直接执行买入。today_buy就真的是买入操作了，主要是记录买入价格和当前行数据
            this_trans = self.today_buy(row, row['close'])
            # 将买入行相关的信息，存储到self.transactions操作历史中，方便整体输出
            self.transactions.append(this_trans)
        else:
            # 这里就不是第一天了，要去判断是否能买的到（比如价格下跌没到下一网位置，就不买的。）
            if self.last_transaction['操作'] == '买':
                # 如果上一次的操作是'买'，那么要构造1个买入价格的阶梯 [上次买入价格, 今日收盘价]，按照'网格大小'构建一个阶梯price_stairs。
                # 用到的是numpy的arange方法，举例:print(np.arange(10,1,-2)) # 输出[10  8  6  4  2]
                start_buy_price = self.last_transaction['价格']
                price_stairs = np.arange(start_buy_price, row['close'], -self.args['step_price'])
                print('前一天是买入，价格%s。收盘价下跌, 构造的买入阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
                if len(price_stairs) >= 1:
                    # 因为，第一个价格是上次买入价格，所以不要包含在本次的买入阶梯里面，做一些切割[1:]
                    price_stairs = price_stairs[1:]
                    for price in price_stairs:
                        # 一般保留3位小数即可
                        price = round(price, 3)
                        # today_buy，是真正的做买入动作了。
                        this_trans = self.today_buy(row, price)
                        # 将买入信息，集中存储到transactions列表中，后续输出到文件
                        self.transactions.append(this_trans)
                else:
                    print('未达到买入阶梯价，今日不执行买入')
            elif self.last_transaction['操作'] == '卖':
                # 构造买入阶梯价，2. 如果"上一次"是卖出，那么要从"-3*网格"开始买
                start_buy_price = self.last_transaction['价格'] - self.args['steps'] * self.args['step_price']
                # 构造价格区间的方法，跟上面是一样的。
                price_stairs = np.arange(start_buy_price, row['close'], -self.args['step_price'])
                print('前一天是卖出，价格%s。收盘价下跌，构造的买入阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
                if start_buy_price == row['close']:
                    # 如果期望开始买的价格，正好是当天收盘价，其实就是此次要买入的价格
                    price_stairs = np.array([start_buy_price])
                if len(price_stairs) >= 1:
                    # 下面的逻辑，跟上面是一样的。
                    for price in price_stairs:
                        price = round(price, 3)
                        this_trans = self.today_buy(row, price)
                        self.transactions.append(this_trans)
                else:
                    print('未达到买入阶梯价，今日不执行买入')

    def want_sell(self, row):
        # 构造卖出阶梯价，1. 如果"前一天"是卖出，那么构造卖出就是按照下一个"网格"卖
        if self.last_transaction['操作'] == '卖':
            start_sell_price = self.last_transaction['价格']
            price_stairs = np.arange(start_sell_price, row['close'], self.args['step_price'])
            print('前一天是卖出，价格%s。收盘价上涨, 构造的卖出阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
            if len(price_stairs) >= 1:
                price_stairs = price_stairs[1:]
                for price in price_stairs:
                    price = round(price, 3)
                    this_trans = self.today_sell(row, price)
                    self.transactions.append(this_trans)
            else:
                print('未达到卖出阶梯价，今日不执行卖出')
        # 构造卖出阶梯价，2. 如果"前一天"是买入出，那么要从"+3*网格"开始卖
        elif self.last_transaction['操作'] == '买':
            start_sell_price = self.last_transaction['价格'] + self.args['steps'] * self.args['step_price']
            price_stairs = np.arange(start_sell_price, row['close'], self.args['step_price'])
            print('前一天是买入，价格%s。收盘价上涨，构造的买卖出阶梯是：%s' % (self.last_transaction['价格'], price_stairs))
            print(price_stairs)
            if start_sell_price == row['close']:
                price_stairs = np.array([start_sell_price])
            if len(price_stairs) >= 1:
                for price in price_stairs:
                    price = round(price, 3)
                    this_trans = self.today_sell(row, price)
                    self.transactions.append(this_trans)
            else:
                print('未达到卖出阶梯价，今日不执行卖出')

    def hold(self, row):
        return None

    def process(self):
        # dataframe的遍历，逐行处理数据
        for index, row in self.daily_df.iterrows():
            # index是索引，就是日期；row是Series类型，一行完整的数据
            if index != self.daily_df.iloc[0]['date']:
                # 非第一天
                # 1.1 今日收盘价如果 < 上次操作的价格，那么可能要买。
                if row['close'] < self.last_transaction['价格']:
                    # want_buy，为什么可能要买，因为在网格中，如果之前是买入，当天价格下跌没有达到下一网，是不买的。这个逻辑在want_buy内部实现
                    self.want_buy(row=row)
                # 1.2 今日收盘价如果 > 上次操作的价格，那么可能要卖，want_sell
                elif row['close'] > self.last_transaction['价格']:
                    # want_sell其实和want_buy是同样的解释。因为在网格中，如果收盘价大于上次交易价格，但没有达到实际要卖出的价格，那也是不卖的。这个逻辑在want_sell内部实现
                    self.want_sell(row=row)
                else:
                    # hold方法，其实什么都没做，return None。意思就是持有不操作。
                    self.hold(row=row)
                print()
            else:
                # 是第一天，默认就是买入
                # want_buy方法，是指可能要买，为什么可能要买，因为在网格中，如果之前是买入，当天价格下跌没有达到下一网，是不买的。这个逻辑在want_buy内部实现
                self.want_buy(row=row)
        # 遍历完所有的数据之后，将所有的交易记录通过pandas存储到csv文件中
        df = pd.DataFrame(self.transactions)
        df.to_csv('%s交易记录.csv' % self.args['security'], index=None)


if __name__ == '__main__':
    # this = FixedGrid(security='512000', start_date='2020-09-14', end_date='2023-09-14')
    this = FixedGrid(security='512000', start_date=None, end_date=None)
    this.process()

3. 收益如何？

其实这里还是要说的，网格这个东西，我们还缺了一个前置条件：

  1. 你得有足够的持仓在手里，你才能在想卖的时候卖出，对吧？
  2. 你得有足够的money在手机，你才能在想买入的时候买，对吧？

所以，这个策略，是为了告诉我们，如果我都ok，那理论上，一年下来，我能卖出多少回？也就是做了多少次的T，能赚多少钱？

我把这个统计的结果文件，放在了：512000交易记录

为了对这个策略有信心，我只看，每年，卖出了多少回？

插个题外话，这个策略有很多改进的地方，比如：

  1. 可以不按照close收盘价来算，而是按照当天的最高或最低价来算
  2. 网格，可以有增强，比如，增加网格数量，或者增加买入、卖出份额等

我自己已经非常忠实的执行了网格交易有一段时间，对结果还是比较满意的，贴一下记录，有兴趣的可以交流。

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

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

相关文章

源浩流体设备与您相约2024年第13届生物发酵展

源浩流体设备与您相约2024年第13届生物发酵展

参展企业介绍 温州源浩流体设备科技有限公司是一家集设计、开发、制造、销售、服务于一体的高科技企业&#xff0c;公司主要生产各种不锈钢阀门、管件、卫生级流体设备(卫生级换向阀,卫生级减压阀,卫生级罐底阀)等。现为温州市泵阀协会会员&#xff0c;ISO9000 2008版质量质量…
阅读更多...
Leaflet使用多面（MultiPolygon）进行遥感影像掩膜报错解决之道

Leaflet使用多面（MultiPolygon）进行遥感影像掩膜报错解决之道

目录 前言 一、问题初诊断 1、山重水复 2、柳暗花明 3、庖丁解牛 4、问题定位 二、解决多面掩膜问题 1、尝试数据修复 2、实际修复 3、最终效果 三、总结 前言 之前一篇讲解遥感影像掩膜实现&#xff1a;基于SpringBoot和Leaflet的行政区划地图掩膜效果实战&#xff0…
阅读更多...
解锁金融数据中心场景，实现国产化AD替代，宁盾身份域管为信创电脑、应用提供统一管理

解锁金融数据中心场景，实现国产化AD替代，宁盾身份域管为信创电脑、应用提供统一管理

随着信创国产化改造持续推进&#xff0c;越来越多的金融机构不断采购信创服务器、PC、办公软件等&#xff0c;其 IT 基础设施逐渐迁移至国产化 IT 架构下。为支撑国产化 IT 基础设施的正常使用和集中管理运维&#xff0c;某金融机构数据中心的微软Active Directory&#xff08;…
阅读更多...
Java入门教程||Java 多线程编程

Java入门教程||Java 多线程编程

Java 多线程编程 Java 给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程&#xff0c;并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。 这里定义和线程…
阅读更多...
WEB 工程路径

WEB 工程路径

WEB 工程路径 相对路径 使用相对路径来解决&#xff0c; 一个非常重要的规则&#xff1a;页面所有的相对路径&#xff0c;在默认情况下&#xff0c;都会参考当前浏览器地址栏的路径 http://ip:port/工程名/ 资源来进行跳转。 相对路径带来的问题 如上图&#xff0c;若在a.h…
阅读更多...
Shell脚本介绍及基本功能

Shell脚本介绍及基本功能

目录 一、什么是Shell 二、什么是Shell脚本 三、echo 四、Hello World 五、Bash的基本功能 1.别名 2.常用快捷键 3.输入输出 4.输出重定向 5.多命令执行 6.管道符 7.通配符和特殊符合 一、什么是Shell Shell是一种命令行解释器&#xff0c;它是操作系统的一部分&a…
阅读更多...
N5182A安捷伦N5182A信号发生器

N5182A安捷伦N5182A信号发生器

181/2461/8938产品概述&#xff1a; 信号特征 100 kHz至3或6 GHz使用高度可靠的快速开关电子衰减器时&#xff0c;最高可达3 GHz》23 dBmW-CDMA动态范围:≤-73 dBc&#xff0c;输出功率为5 dBm列表模式下≤900 μs的同步频率、幅度和波形切换 调制和扫描 调幅、调频、调频和…
阅读更多...
OpenHarmony实战开发-如何通过Stage模型实现一个简单的游戏卡片

OpenHarmony实战开发-如何通过Stage模型实现一个简单的游戏卡片

介绍 本示例展示了如何通过Stage模型实现一个简单的游戏卡片。 通过卡片支持的点击事件进行交互&#xff0c;让用户通过点击的先后顺序把一个乱序的成语排列成正确的成语。使用了C和TS的混合编程方式&#xff0c;将获取随机数的能力下沉到C实现&#xff0c;并通过NAPI的能力将…
阅读更多...
高德定位 SDK 到底提供了什么服务？

高德定位 SDK 到底提供了什么服务？

最近我被高德的销售烦到不行&#xff0c;说是我用了他们的 SDK&#xff0c;现在 SDK 要收费。 表达是很绕的&#xff0c;什么授权啦&#xff0c;什么企业认证风险啦&#xff0c;讲了一堆&#xff0c;还跟我开始搬出协议了。感觉高德的销售真够垃圾的&#xff0c;编个话术都不会…
阅读更多...
【EI检索会议】电子、通信与智能科学国际会议二轮征稿中

【EI检索会议】电子、通信与智能科学国际会议二轮征稿中

【会议名称】电子、通信与智能科学国际会议 【会议简称】ECIS 2024 【会议官网】www.icecis.org 【会议时间】2024年5月24日~27日 【二轮截稿时间】2024年4月20日 【会议地点】中国长沙 【征稿主题】集中但不限于“电子、通信、智能科学”等其他相关主题。 【官方邮箱】…
阅读更多...
3.java openCV4.x 入门-数据类型（CvType）与Scalar

3.java openCV4.x 入门-数据类型（CvType）与Scalar

专栏简介 &#x1f492;个人主页 &#x1f4f0;专栏目录 点击上方查看更多内容 &#x1f4d6;心灵鸡汤&#x1f4d6;我们唯一拥有的就是今天&#xff0c;唯一能把握的也是今天 &#x1f9ed;文章导航&#x1f9ed; ⬆️ 2.hello openCV ⬇️ 4.待更新 数据类型&#xff…
阅读更多...
【leetcode】双指针（二）

【leetcode】双指针（二）

标题&#xff1a; 【leetcode】双指针&#xff08;二&#xff09; 水墨不写bug 正文开始&#xff1a; &#xff08;一&#xff09;总和为目标值的两个数 购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况&#…
阅读更多...
支持各种不同系列nvdia显卡和amd显卡，DeepFaceLab安装与使用，附完整的软件打包下载一键安装

支持各种不同系列nvdia显卡和amd显卡，DeepFaceLab安装与使用，附完整的软件打包下载一键安装

支持各种不同系列nvdia显卡和amd显卡&#xff0c;DeepFaceLab安装与使用&#xff0c;附完整的软件打包下载一键安装。 主要使用的技术&#xff1a; 1. 深度学习&#xff08;Deep Learning&#xff09; 深度学习是人工智能领域的一个重要分支&#xff0c;它通过模拟人脑的神经…
阅读更多...
面试经典150题【131-140】

面试经典150题【131-140】

文章目录 面试经典150题【131-140】123.买卖股票的最佳时机III188.买卖股票的最佳时机IV二分查找的板子&#xff1a;35.搜索插入位置74.搜索二维矩阵162.寻找峰值33.搜索旋转排序数组34.在排序数组中查找元素的第一个和最后一个位置153.寻找旋转排序数组中的最小值4.寻找两个正…
阅读更多...
C++之类和对象的中篇

C++之类和对象的中篇

&#x1d649;&#x1d65e;&#x1d658;&#x1d65a;!!&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦ &#x1f44f;&#x1f3fb;‧✧̣̥̇:Solitary_walk ⸝⋆ ━━━┓ - 个性标签 - &#xff1a;来于“云”的“羽球人”。…
阅读更多...
函数参数缺省和内联函数【C++】

函数参数缺省和内联函数【C++】

文章目录 函数参数缺省函数参数缺省的条件和要求 内联函数内联函数的工作原理内联函数的定义方法内联函数的要求解决方法&#xff1a;直接在.h中定义内联函数的函数体 内联函数再Debug模式下默认是不展开的 函数参数缺省 顾名思义&#xff1a;可以少传一个/多个参数给函数&…
阅读更多...
归并排序和分治

归并排序和分治

归并排序 归并排序是利用归并的思想实现的排序方法&#xff0c;该算法采用经典的分治策略&#xff08;分治法将问题分成一些小的问题然后递归求解&#xff0c;而治的阶段则将分的阶段得到的各答案"修补"在一起&#xff0c;即分而治之)。 分而治之 可以看到这种结构…
阅读更多...
前端实现菜单搜索搜索（功能模版）

前端实现菜单搜索搜索（功能模版）

目录 前言正文 前言 总体界面如下所示&#xff1a; 正文 <template><div class"avue-searchs"click.self"handleEsc"><div class"avue-searchs__title">菜单搜索</div><div class"avue-searchs__content"…
阅读更多...
游戏运营分析：如何在新游戏上线初期实现精细化运营？

游戏运营分析：如何在新游戏上线初期实现精细化运营？

一、背景介绍 在当今的手游市场中&#xff0c;每一款新游戏的发布都如同踏上一段充满未知与挑战的探险之旅。游戏刚上线时&#xff0c;运营情况往往如同飘摇的小船&#xff0c;随时可能受到风浪的侵袭。此时&#xff0c;如何准确地找到问题所在&#xff0c;为游戏的健康运营和持…
阅读更多...
网络安全运营思维导图（企业层面）

网络安全运营思维导图（企业层面）

阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023