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

最新推荐文章于 2025-03-05 08:36:34 发布
最新推荐文章于 2025-03-05 08:36:34 发布
阅读量4.9k 收藏 46
点赞数 18
分类专栏： 投资 文章标签： python 投资 网格交易 交易记录 实证
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdfiiiiii/article/details/137351951
版权

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

已完成：
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个例子：

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. 网格，可以有增强，比如，增加网格数量，或者增加买入、卖出份额等

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

python：网格交易法
走向CTO的路上...
01-30 549
在乌龟量化上找一支宽基指数（比如上证指数），随便哪一只，然后： 1.每当指数下跌至机会位（过去5年PE 30%低位点）时开始加仓，并且PE分位点每下降3%，就加仓，且加仓数量是之前的2倍；如果PE百分位点上升，则停止加仓 2.每当指数上升至卖出位（过去5年PE 70%高位点）时开始减仓，并且PE分位点每上升3%，就减仓，且减仓数量是之前的1/2倍；PE低位时适度加仓，PE高位时适度减仓，旨在追求在市场估值较低时买入，较高时卖出，获取超额收益。这样的投资策略基于市场估值，理论上能够在市场波动中获得超额收益。
【第六部分：项目实战与部署】【21.强化学习实战：从Q-Learning到AlphaGo】
最新发布
04-08 590
智能体（Agent）如何通过与环境（Environment）的持续交互，找到最大化长期收益的最优策略。马尔可夫决策过程（Markov Decision Process, MDP）正是描述这一过程的数学框架。状态集合（S）：环境可能存在的所有状态动作集合（A）：智能体可以执行的所有动作转移概率（P）：P(s’|s,a)表示在状态s执行动作a后转移到状态s’的概率奖励函数（R）：R(s,a,s’)表示在状态s执行动作a后转移到状态s’时获得的即时奖励折扣因子（γ）
真正手把手教会你：用 Python 构建网格交易策略
weixin_70955880的博客
10-21 2615
我打算撰写一篇能够让大家跟着操作就能完成的手把手指导文。我将按照环境配置、创建网格、创建交易信号、准备回溯测试、进行回溯测试以及结果分析这 6 个必要的顺序环节，指导大家运用 Python 构建并回溯测试一个简单的网格交易策略，而且该策略能够呈现出资产净值的稳定增长（夏普比率接近 5.7）。而券商和机构不会告诉你的是，他们就是拿网格交易策略去做持仓深套的底层解决逻辑。
python网格交易法详解_什么是网格交易？一文教会你网格交易策略
weixin_39793319的博客
12-10 1580
一、网格交易法设定价值中枢，利用“档位”的模式对投资标的进行机械式操作，下跌时，进行分档买入，上涨时，进行分档卖出。网格法由于不依赖人为的思考,完全是一种程序行为,像渔网一样,利用行情的波动在网格区间内低买高卖，可以合理控制仓位，避免追涨杀跌,拥有较强的抗风险能力。例如国外一个经典的仓位管理系统，某只蓝筹股现价10元，本金是20万。则第一次买入10万元，另外每下跌1元买入1万元，每上涨1元卖出1万...
迅投miniQMT量化交易之【网格交易】的实现（三）——GridTrade类
tzzqn2008的专栏
03-05 948
和大家一起分享如何使用miniQMT实现我们自己的网格交易系统。如果您对量化交易感兴趣，欢迎一起交流。
python网格交易法详解_期货交易技巧：等分网格交易法详解
weixin_39683769的博客
12-10 718
期货交易技巧：等分网格交易法详解网格交易法的基本原理就是把行情的所有日间上下的波动全部囊括，它不会放过任何一次的行情上下波动。不管市场价格如何上下波动，不外3种形态：上涨，盘整，下跌。由于不同的操作方法而有不同的结果表现，依据历史经验，由于盘整行情的神出鬼没，用普通习惯的操作方法在盘整行情中是很难赚到钱的，经常是高买低卖，左右挨耳光。而网格法由于不依赖人为的思考，完全是一种程序行为，像渔网一样，可...
python 写网格交易代码
csdn学子
08-03 781
【代码】python 写网格交易代码。
【转载】网格交易 python
u010659877的专栏
07-20 1830
平台：发明者量化 转载自：https://blog.csdn.net/qq_25863231/article/details/103976490 import json # reference: https://blog.csdn.net/qq_25863231/article/details/103976490 # 参数 beginPrice = 5000 # 网格区间开始价格 endPrice = 8000 # 网格区间结束价格 distance = 20 # 每个网格节点的价格距离 pointPr.
python 网格交易源码_GitHub - zhiaozhou/grid-trading: 网格交易(期货) ，基于网格交易方法的交易策略...
weixin_39967598的博客
11-29 905
# coding=utf-8from __future__ import print_function, absolute_import, unicode_literalsimport numpy as npimport pandas as pdfrom gm.api import *'''本策略首先计算了过去300个价格数据的均值和标准差并根据均值加减1和2个标准差得到网格的区间分界线,并分别配...
python写网格交易代码
weixin_35757531的博客
12-30 1217
好的，那我们首先来简单了解一下什么是网格交易。 网格交易是一种交易策略，它通过在不同价格水平下设置多个交易订单，来达到获取收益的目的。网格交易的一个关键是如何确定每个交易订单的价格水平。 在 Python 中，我们可以使用类似于下面的代码来实现网格交易： # 假设我们要在价格在 50 到 100 之间设置网格交易订单 # 首先我们需要定义一个价格列表，其中包含我们要设置订单的价格 prices =...
Python量化交易入门
曲折旅程，艰难人生
04-13 3889
Python量化交易知识归纳
python金融数据分析与挖掘实战_[套装书]Python数据分析与挖掘实战（第2版）+Python金融大数据挖掘与分析全流程详解+Python金融数据分析（3册）...
weixin_39644021的博客
12-06 8220
---------------------------Python数据分析与挖掘实战(第2版)---------------------------前言基础篇第1章　数据挖掘基础 21.1　某知名连锁餐饮企业的困惑 21.2　从餐饮服务到数据挖掘 41.3　数据挖掘的基本任务 51.4　数据挖掘建模过程 51.4.1　定义挖掘目标 61.4.2　数据取样 61.4.3　数据探索 7...
基于Python实现的简单网格策略交易源码+使用说明.zip
11-06
【资源说明】 基于Python实现的简单网格策略交易源码+使用说明.zip 策略说明 开仓：在盘口挂出买N和卖N，当你的买单或卖单完成后，再重新开启相应的仓位，保持你始终有买N和卖N的订单。 **KuCoin**拥有**level3交易数据、强大的撮合引擎、针对api用户提供的手续费折扣**，同时提供**sandbox环境**作为数据测试支撑，帮助你规避风险。 我们仅提供一个简单且不完备的交易策略，使用时**请注意规避风险**，我们希望你能够**在sandbox环境配合其他参数或是策略进行测试调整，我们也不想你成为一个慈善家！！！ 如何使用 * 安装Python * Windows系统请前往[Python](https://www.python.org/downloads/windows/)官网自行安装，64位请选择1，32位请选择2。 <img src="./img/python_download.png" style="zoom:50%" /> * 在开始安装时请注意将以下选项勾选： <img src="./img/python_win.png" style="zoom:40%" /> * MAC OS X安装 * 打开命令终端，输入以下命令安装Homebrew（安装过程中需要输入**电脑密码**）： ```shell /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" ``` * 在命令终端输入以下命令，安装Python3： ```shell brew install python ``` * 在命令终端输入以下命令，确认是否安装成功： ```shell python3 --version ``` Mac/Linux **在项目目录下**打开命令终端： ```shell cd simple-grid ``` * 用以下命令让你的合约策略运行起来： ```shell ./simple_grid_future.py ``` * 用以下命令让你的现货策略运行起来： ```shell ./simple_grid_kucoin.py ``` * Windows **在项目目录下**打开命令终端： ```shell cd simple-grid ``` * 用以下命令让你的合约策略运行起来： ```shell py simple_grid_future.py ``` * 用以下命令让你的现货策略运行起来： ```shell py simple_grid_kucoin.py ``` 【备注】 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。 欢迎下载，沟通交流，互相学习，共同进步！
交易策略优化实战：如何精通网格大小的动态调整
首先概述了网格交易的概念和重要性，随后深入分析了网格大小对策略性能的影响，并探讨了动态调整网格的理论基础。第三章重点介绍了动态调整网格大小的实践方法，包括自适应策略设计、参数优化测试以及应用市场数据的...
Python量化交易实战：从数据到实时系统
[Python量化交易实战：从数据到实时系统](https://img-blog.csdnimg.cn/4eac4f0588334db2bfd8d056df8c263a.png) 参考资源链接：[Python量化交易全面指南：从入门到实战]...
用python写一个网格交易策略代码
weixin_35756637的博客
02-17 1902
网格交易策略的python代码大致如下： 导入需要的库 import pandas as pd 加载数据 data = pd.read_csv("data.csv") 定义一个函数，用于计算最优买入和卖出价格 def calculate_optimal_buy_sell_price(data, grid_size): # 计算最低价和最高价 low_price = dat...
python网格交易法详解_给大家科普一下网格交易法
weixin_39841709的博客
12-10 1456
网格交易法相信很多人都知道，其思路来源于信息论之父申农。上世纪40年代的某一天，申农在黑板上给大家演示了他的投资理论：1、在任意一个价位上，用50%的资金买入股票。即资金数量：股票市值=50%：50%。例如，我有10万块钱，当前股价是10元/股。我花5万块钱，买了5000股(股票市值5万元)，我还剩5万元。此时，我的资金数量：股票市值=50%：50%。2、股票价格上涨一定幅度就卖出一部分股票，保持...
python网格交易_网格交易(期货)
weixin_39676348的博客
12-04 944
网格交易(期货)分享阅读 30668更新 2020-12-03 15:44:39网格交易法(期货)1. 原理什么是网格交易法？网格交易法是一种利用行情震荡进行获利的策略。在标的价格不断震荡的过程中，对标的价格绘制网格，在市场价格触碰到某个网格线时进行加减仓操作尽可能获利。网格交易法属于左侧交易的一种。与右侧交易不同，网格交易法并非跟随行情，追涨杀跌，而是逆势而为，在价格下跌时买入，价格上涨时卖出。...
网格交易 python代码_网格交易原理和代码
weixin_36300491的博客
01-13 3509
# coding=utf-8from __future__ import print_function, absolute_import, unicode_literalsimport numpy as npimport pandas as pdfrom gm.api import *'''本策略标的为：SHFE.rb1901价格中枢设定为：前一交易日的收盘价从阻力位到压力位分别为：1.03 * ...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值