8. Operator 交易员类

Operator(交易员)类，用于生成Operator对象，qteasy的核心对象。

Operator是一个策略容器，它包含一系列交易策略，保存每一个交易策略所需的历史数据，并且可以调用所有交易策略，生成交易信号，同时根据保存的规则把所有交易策略生成的信号混合起来，形成一组最终的交易信号。就像一个交易员在实际交易中的行为一样。

创建一个Operator对象时，需要给出一组交易策略，并设定好交易员的交易模式和信号模式，交易模式和信号模式都是Operator对象最重要的属性，他们共同决定了交易员的行为模式:

class qteasy.Operator(strategies: Optional[Union[str, BaseStrategy, type, list[Union[str, qteasy.strategy.BaseStrategy, type]]]] = None, *, name: Optional[str] = None, signal_type: str = 'pt', op_type: str = 'batch', group_merge_type: str = 'None', run_freq: str = 'd', run_timing: str = 'close')[源代码]

qteasy 中的核心「交易员」对象，用于承载策略组并在统一时间表上生成交易信号。

Operator 负责管理一个或多个策略组，准备并缓存运行所需的历史数据，按照运行频率与时机调用各策略生成信号，并按组内/组间合并规则将信号合成为最终的交易指令，可用于回测、优化和实盘运行。关于 Operator 与 Strategy / Group 的关系、run_freq / run_timing 单一来源等架构细节，详见文档「Operator / Strategy / Group 架构」章节。

add_strategies(strategies: Union[str, list[Union[str, qteasy.strategy.BaseStrategy, type]]], run_freq: str = 'd', run_timing: str = 'close', **kwargs: Any)[源代码]

添加多个Strategy交易策略到Operator对象中

使用这个方法，不能在添加交易策策略的同时修改交易策略的基本属性输入参数strategies可以为一个列表或者一个逗号分隔字符串列表中的元素可以为代表内置策略类型的字符串，或者为一个具体的策略对象字符串和策略对象可以混合给出

参数:

strategies (stg or list of str or list of Strategy) – 交易策略的名称或者交易策略对象
run_freq (str, optional) – run_freq为策略的运行频率，可以为None，表示不指定运行频率
run_timing (str, optional) – run_timing为策略的运行时机，可以为None，表示不指定运行时机
**kwargs (Any) – 添加的交易策略所共享的属性，如 run_timing、run_freq、window_length、 use_latest_data_cycle、freq、asset_type、data_type_ids 等（会传入 add_strategy）

返回类型:

None

示例

>>> op = Operator()
>>> op.add_strategies(['dma', 'macd'])
>>> op.strategies
[RULE-ITER(DMA), RULE-ITER(MACD)]

add_strategy(stg: Union[str, BaseStrategy, type, tuple, list, Any], run_freq: str = 'd', run_timing: str = 'close', **kwargs)[源代码]

添加一个strategy交易策略到operator对象中

如果调用本方法添加一个交易策略到Operator中，可以在添加的时候同时修改或指定交易策略的基本属性

参数:

stg (str or int or Strategy) – 需要添加的交易策略，也可以是内置交易策略的策略id或策略名称
run_freq (str, Optional) – run_freq为策略的运行频率，可以为None，表示不指定运行频率
run_timing (str, Optional) – run_timing为策略的运行时机，可以为None，表示不指定运行时机
kwargs – 任意合法的策略属性，可以在添加策略时直接给该策略属性赋值，必须明确指定需要修改的属性名称，包含 - pars: dict or tuple, 策略可调参数 - opt_tag: int, 策略优化标签 - stg_type: int, 策略类型 - par_count: int, 策略参数个数 - par_types: list, 策略参数类型 - par_ranges: list, 策略参数范围 - data_freq: str, 策略数据频率 - window_length: int, 策略窗口长度 - run_freq: str, 策略采样频率 - data_types: list, 策略数据类型 - data_type_id: str, 策略数据类型 ID（用于 update_data_types） - freq: str or list or dict, 数据类型的频率（修改会替换对应 DataType） - asset_type: str or list or dict, 数据类型的资产类型（修改会替换对应 DataType） - group: str, 策略运行时机 - use_latest_data_cycle: bool, 策略是否使用最新数据周期

返回类型:

None

示例

>>> op = Operator()
>>> op.add_strategy('dma', opt_tag=1, pars=(50, 10, 20))
>>> op.strategies
[RULE-ITER(DMA)]
>>> op.strategies[0].opt_tag
1
>>> op.strategies[0].par_values
(50, 10, 20)

property all_dynamic_dtypes

返回 operator 内“旧式”动态数据类型集合；已废弃，始终返回空。

过程数据现统一通过 get_data(‘proc.xxx’) 访问，不再通过 DataType 声明。保留本属性仅为兼容调用方，返回空字典。

property all_strategy_data_types: 返回operator对象所有策略自对象的回测价格类型和交易清单历史数据类型的集合

check_dynamic_data()[源代码]

检查operator对象是否包含动态数据类型（即依赖交易结果的历史数据）以生成交易信号。

若任意策略在 realize() 中使用了 get_data(‘proc.xxx’)，则视为依赖动态过程数据，需走动态回测分支。

clear_strategies()[源代码]: 清空Operator对象中的所有交易策略

create_data_windows()[源代码]: Create data windows for each strategy and its data types. Also create data window indices for each strategy and its data types. data window indices are created according to group schedules.

disable_tracing()[源代码]

禁用Operator对象中所有strategy的跟踪功能

禁用跟踪功能后，Operator对象在运行过程中不会记录调试信息，从而提高运行效率

返回类型:: None

property empty: 检查operator是否包含任何策略

enable_tracing()[源代码]

启用Operator对象中所有strategy的跟踪功能

启用跟踪功能后，Operator对象在运行过程中会记录更多的调试信息，便于后续分析和调试

返回类型:: None

get_blender(group_name=None)[源代码]

返回operator对象中的多空蒙板混合器, 如果不指定group_name的话，输出完整的blender字典

参数:: group_name (str) – 一个可用的group_name
返回:: blender – 如果group_name为None，则返回一个字典，其中包含所有的run_timing的blender 如果group_name不为None，则返回一个列表，其中包含该run_timing的blender
返回类型:: dict or list

get_group(group_idx: Union[str, int]) → Group[源代码]

根据group_idx获取一个Group对象，等同于get_group_by_id方法

参数:: group_idx (int or str) – 策略组的序号
返回类型:: Group,

示例

>>> op = Operator('dma, macd')
>>> op.get_group(0)
Group(name=Group_1, members=[RULE-ITER(DMA), RULE-ITER(MACD)])
>>> op.get_group_by_id('Group_1')
Group(name=Group_1, members=[RULE-ITER(DMA), RULE-ITER(MACD)])

get_group_by_id(group_id: Union[str, int]) → Group[源代码]

根据group_id获取一个Group对象

参数:: group_id (str or int) – 策略组的名称ID或序号
返回类型:: Group,

备注

1，当group_id为int时，返回的是序号为group_id的策略组 2，当group_id为str时，返回的是ID为group_id的组

示例

>>> op = Operator('dma, macd')
>>> op.get_group_by_id(0)
Group(name=Group_1, members=[RULE-ITER(DMA), RULE-ITER(MACD)])
>>> op.get_group_by_id('Group_1')
Group(name=Group_1, members=[RULE-ITER(DMA), RULE-ITER(MACD)])

get_max_window_length_by_dtype_id(dtype: str) → int[源代码]

计算并返回operator对象某个datatype最长的窗口长度。

参数:: dtype (str) – 需要查询的历史数据类型的dtype_id
返回类型:: int, operator对象中所有子策略中某个dtype最长的窗口长度

get_share_idx(share)[源代码]

给定一个share（字符串）返回它对应的index

参数:: share (str) – share为一个字符串，表示股票代码
返回:: 返回一个整数，表示share对应的index
返回类型:: int

get_signal_count(steps=None) → int[源代码]

获取当前运行时间表中所有策略组生成的交易信号数量

参数:: steps (list of int, optional) – 如果给出steps，则只计算这些步骤对应的交易信号数量如果为None，则计算所有步骤的交易信号数量
返回:: int
返回类型:: 交易信号的数量

get_stg(stg_id)[源代码]

获取一个strategy对象, Operator[item]的另一种用法

参数:: stg_id (int or str) – 策略的名称或序号
返回类型:: Strategy, 子策略

备注

1，当stg_id为int时，返回的是第stg_id个策略 2，当stg_id为str时，返回的是名称为stg_id的策略 3，当stg_id不符合要求时，返回最后一个策略

示例

>>> op = Operator('dma, macd')
>>> op[0]
RULE-ITER(DMA)
>>> op['dma']
RULE-ITER(DMA)
>>> op[999]
RULE-ITER(MACD)
>>> op['invalid_strategy_name']
UserWarning: No such strategy with ID (invalid_strategy_name)!

参见

get_strategy_by_id

get_strategies_by_group(group_id: str)[源代码]

返回operator对象中的strategy对象, timing为一个可选参数，如果给出timing时，返回使用该timing的交易策略

参数:: group_id (str) – 一个可用的timing, by default None

get_strategy_by_id(stg_id)[源代码]

获取一个strategy对象, Operator[item]的另一种用法

参数:: stg_id (int or str) – 策略的名称或序号
返回类型:: Strategy, 子策略

参见

get_stg

get_strategy_count_by_group(group_id: str)[源代码]: 返回策略组group_id中的所有策略数量

get_strategy_id_by_group(group_id: str)[源代码]: 返回策略组group_id中的所有策略ID

get_strategy_id_pairs()[源代码]

返回一个generator，包含op中所有strategy和id对：

返回类型:: generator, 包含op中所有strategy和id对

示例

>>> op = Operator('dma, macd')
>>> list(op.get_strategy_id_pairs())
[('dma', RULE-ITER(DMA)), ('macd', RULE-ITER(MACD))]

get_strategy_names_by_group(group_id: str)[源代码]: 返回策略组group_id中的所有策略名称

property group_ids: 返回operator对象所有策略子对象的运行时间类型

property group_merge_type: 返回operator对象的策略组合并方式

property group_names: 返回operator对象所有策略子对象的运行时间类型

property groups: 返回operator的所有策略组，返回以策略组的名称为索引的字典

property groups_by_index: 返回operator的所有策略组，返回以策略组的序号为索引的字典

info(verbose=False)[源代码]

打印Operator对象的信息，包括策略组、组内策略，策略混合方式等等信息

如果策略包含更多的信息，还会打印出策略的一些具体信息

参数:: verbose (bool, Default False) – 是否打印出策略的详细信息, 如果为True, 则会打印出策略的详细信息

is_ready(tell_me_why: bool = False, raise_error: bool = False) → bool[源代码]

检查 Operator 是否已具备生成交易信号所需的最小条件。

典型就绪条件包括：已挂载策略、各策略组已配置 blender、历史数据类型与运行时间表等关键字段已就绪（更细的合法性校验在后续流程完成）。

参数:

tell_me_why (bool, default False) – 如果Operator对象不满足准备好的条件，是否打印出具体原因, 默认不打印
raise_error (bool, default False) – 如果Operator对象不满足准备好的条件，是否抛出异常, 默认不抛出

返回类型:

bool, Operator对象是否已经准备好，可以开始生成交易信号

property max_window_length

计算并返回operator对象所有子策略中最长的窗口长度。在准备回测或优化历史数据时，以此确保有足够的历史数据供策略形成

返回类型:: int, operator对象中所有子策略中最长的窗口长度

property op_data_freq: dict: 返回operator对象所有策略子对象所需数据的采样频率如果所有strategy的data_freq相同时，给出这个值，否则给出一个排序的列表

property op_data_type_count: 返回operator对象生成交易清单所需的历史数据类型数量

property op_data_type_ids: 返回operator对象所有策略子对象所需历史数据类型的ID

property op_data_types: 返回operator对象所有策略子对象所需历史数据类型对象

property op_signal_index: Optional[Index]: 返回operator对象生成交易信号的index

property op_signal_types: list

生成的交易清单的signal_types。因为生成的交易信号可能是由不同的策略组生成的而不同的策略组有自己的信号类型（PT/ST/VT)，因此每一行交易信号都有可能有不同的交易信号类型，本属性返回一个list，其中包含了op_signal_list中每一行的signal_list

返回类型:: list, 生成的交易清单的price_types，回测交易价格类型

property op_type: 返回operator对象的运行类型

property opt_space_par

返回参与优化的子策略参数空间信息，用于构造 Space。

遍历各子策略的 opt_tag，汇总其 par_range / par_types 等字段，输出 (ranges, types) 二元组，可直接作为 Space 构造输入。

返回:: ranges 与 types 两个列表，分别对应各参与优化维度的取值范围与类型标记。
返回类型:: tuple[list, list]

property opt_tags: 返回所有策略的优化类型标签该属性返回值是一个列表，按顺序列出所有交易策略的优化类型标签

prepare_data_buffer(*, start_date: Union[str, Timestamp], end_date: Union[str, Timestamp], data_package: dict) → None[源代码]

准备数据缓冲区，加载所有策略需要的数据

数据缓冲区是一个字典，键为数据类型，值为对应的数据DataFrame，输入参数包括数据包的开始和结束日期，根据这两个日期从数据包中的每一个DataFrame中切片出相应的时间段，保存到数据缓冲区中。

保存数据缓冲时，还要检查并确保数据有足够的前置量以创建数据滑窗

参数:

start_date (str or pd.Timestamp) – 数据的开始日期，默认为None，表示从数据包的起始日期开始
end_date (str or pd.Timestamp) – 数据的结束日期，默认为None，表示到数据包的结束日期为止
data_package (dict[]) – 一个字典，包含所有需要的数据，键为数据类型，值为对应的数据DataFrame 例如：{‘price’: price_df, ‘volume’: volume_df, …} 其中每个DataFrame的索引为时间戳，列为不同的标的代码

prepare_dynamic_data_buffer(*, trade_records: ndarray, trade_prices: ndarray, own_cashes: ndarray, available_cashes: ndarray, holding_positions: ndarray, available_positions: ndarray) → None[源代码]: 预留接口：过程数据已统一通过 proc.* 注入，本方法不再执行逻辑。

prepare_running_schedule(start_date=None, end_date=None, **kwargs) → None[源代码]

Running Schedule也就是策略运行时间表，包含每个策略的运行时间和频率等信息

在运行策略之前，必须先准备好运行时间表，这个时间表根据交易员中每个策略组的运行时机参数确定。运行时间表包括N行，每一行代表一个时间点，列数为策略组的数量，每个单元格表示该策略组在该时间点是否运行，0表示不运行，1表示运行。

在这个方法中，将设置以下两个属性的值： - group_schedules: 一个字典，键为策略组名称，值为该组的运行时间表 - group_timing_table: 一个DataFrame，包含所有策略组的运行时间表

参数:

start_date (str or pd.Timestamp, optional) – 开始日期，默认为None，表示从数据源的起始日期开始
end_date (str or pd.Timestamp, optional) – 结束日期，默认为None，表示到数据源的结束日期为止
kwargs (dict, optional) – 其他参数，包括生成交易时间序列过程中所需的参数，如交易开始时间、结束时间等等。详见qteasy.trading_util.trade_time_index()函数的参数说明

返回类型:

None

property ready: 属性，operator.is_ready()的另一种写法

remove_strategy(id_or_pos: Optional[Union[str, int]] = None) → None[源代码]: 从Operator对象中移除一个交易策略, 删除时可以给出策略的id或者策略在Operator中的位置

reset()[源代码]

重置Operator对象的运行状态，使其可以重新开始生成交易信号

备注

该方法会重置Operator对象的所有运行数据，包括历史数据缓存、数据窗口视图、数据窗口索引、交易信号等。重置后，Operator对象可以重新开始生成交易信号。

示例

>>> op = Operator('dma, macd')
>>> op.reset()

run(config, datasource=None, logger=None)[源代码]

根据配置参数运行operator，支持实盘和回测两种模式

参数:

config (dict) – 运行配置参数字典
datasource (DataSource, optional) – 数据源对象，默认为None，表示使用全局默认数据源
logger (Logger, optional) – 日志记录器对象，默认为None，表示不使用日志记录器

返回:

backtest_result – 如果运行模式为回测，则返回回测结果对象，包含回测的各种结果数据如果运行模式为实盘，则不返回任何结果

返回类型:

BacktestResult, optional

run_backtest(config, datasource=None, logger=None) → dict[源代码]

在回测模式下运行operator, 使用历史数据进行交易策略的回测并生成回测结果

参数:

config (dict) – 回测配置参数字典
datasource (DataSource, optional) – 数据源对象，默认为None，表示使用全局默认数据源
logger (Logger, optional) – 日志记录器对象，默认为None，表示不使用日志记录器

返回:

backtest_result – 回测结果对象，包含回测的各种结果数据

返回类型:

BacktestResult

run_live_trade(config, datasource=None, logger=None)[源代码]: 在实盘模式下运行operator

run_optimization(config, datasource=None, logger=None) → dict[源代码]: 在优化模式下运行operator

run_prediction(config, datasource=None, logger=None) → dict[源代码]: 在与测模式下运行operator

run_strategies(steps: Iterable) → Iterable[源代码]

运行 Operator，返回运行结果；语义接近 qt.run(self, ...) 传入的关键字参数形式。

参数:: steps (Iterable) – 一个可迭代对象，包含需要运行的步骤索引
生成器:: generator ((signal_type, step_index, signal)) – 返回一个生成器，包含每个步骤的交易信号 signal_type: str, 策略组的信号类型 step_index: int, 当前步骤的索引 signal: np.ndarray, 交易信号，一组数字，在不同信号类型模式下表示不同的含义

run_strategy(step_index) → Generator[Union[tuple[Any, int, Any], tuple[Optional[Any], int, Union[int, Any]]], Any, None][源代码]

运行当前步骤的所有策略组，生成交易信号

本函数是一个生成器函数，返回每个策略组在当前步骤的交易信号。

参数:: step_index (int) – 当前步骤的索引，表示在运行时间表中的位置
返回:: generator – 返回一个生成器，包含每个策略组在当前步骤的交易信号 signal_type: str, 策略组的信号类型 step_index: int, 当前步骤的索引 signal: np.ndarray, 交易信号，一组数字，在不同信号类型模式下表示不同的含义
返回类型:: (signal_type, step_index, signal)

set_blender(blender: Union[str, list[str], dict[str, str]], group_id: Optional[str] = None)[源代码]

统一的blender混合器属性设置入口

参数:

blender (str or list of str or dict of str, optional) – 一个合法的交易信号混合表达式当group为None时，可以接受list为参数，同时为所有的group设置混合表达式
group_id (str, optional) – 指定策略组 id 时仅更新该组；为 None 时更新全部策略组。后者在 blender 为字符串时表示所有组使用同一表达式；为列表时按组顺序逐项设置，长度不足则复用最后一项。

返回类型:

None

抛出:

TypeError – 如果给出的price_type不是正确的类型

警告

如果给出的price_type不存在，则给出warning并返回

示例

>>> op = Operator()
>>> op.add_strategy('dma', run_timing='close')  # 添加策略时指定run_timing，自动分配到第一个策略组Group_1
>>> op.add_strategy('trix', run_timing='close')  # 添加策略时指定run_timing，自动分配到第一个策略组Group_1
>>> op.add_strategy('macd', run_timing='open')  # 添加策略时指定run_timing，自动分配到第二个策略组Group_2
>>> op.add_strategy('bband', run_timing='open')  # 添加策略时指定run_timing，自动分配到第二个策略组Group_2

>>> # 设置策略组1的混合模式
>>> op.set_blender('s0+s1', 'Group_1')
>>> op.get_blender()
>>> {'Group_1': ['+', 's1', 's2']}

>>> # 给所有的交易价格策略设置同样的混合表达式
>>> op.set_blender('s0 + s1')
>>> op.get_blender()
>>> {'Group_1': ['+', 's2', 's1'], 'Group_2':  ['+', 's2', 's1']}

>>> # 通过一个列表给不同的策略组设置不同的混合表达式（策略组按顺序排列）
>>> op.set_blender(['s1 + s2', 's3*s4'], None)
>>> op.get_blender()
>>> {'close': ['+', 's2', 's1'], 'open':  ['*', 's4', 's3']}

set_group_parameters(group: Union[str, int], run_timing: Optional[str] = None, run_freq: Optional[str] = None, signal_type: Optional[str] = None, blender_str: Optional[str] = None, **kwargs)[源代码]

设置或修改一个策略组的参数 :param group: 策略组的ID :type group: str :param run_timing: 策略组的运行时机，修改运行时机时，修改策略组中所有交易策略的运行时机 :type run_timing: str, optional :param run_freq: 策略组的运行频率，修改运行频率时，修改策略组 :type run_freq: str, optional :param signal_type: 策略组的交易信号类型，默认为’PT’，即百分比持仓目标 :type signal_type: str, optional :param blender_str: 策略组的交易信号混合表达式，可以是一个字符串或一个字符串列表 :type blender_str: str, optional :param kwargs: 其他参数，可以是任意合法的策略组参数，如group_name, run_timing, run_freq等 :type kwargs: dict, optional

返回类型:

None

抛出:

TypeError – 如果group不是字符串或整数类型
ValueError – 如果group不存在或无法找到

set_opt_par_values(par_values)[源代码]

优化器侧入口：将一条参数向量按各子策略 opt_tag 切片写回。

与 set_parameter 不同，本方法面向「一条向量对应多个策略子块」的优化流程；调用方需保证 par_values 与 opt_space_par 展平顺序一致。

参数:: par_values (tuple) – 优化器当前候选点对应的参数元组。
返回类型:: None

备注

内部调用 Strategy.update_par_values，不在此处做参数合法性校验。

set_parameter(stg_id: Union[str, int], pars: Optional[Union[Parameter, tuple, list, dict]] = None, opt_tag: Optional[int] = None, data_types: Optional[Union[DataType, list[qteasy.datatypes.DataType], dict[str, qteasy.datatypes.DataType]]] = None, data_type_id: Optional[str] = None, window_length: Optional[Union[int, tuple[int, ...], list[int], dict[str, int]]] = None, use_latest_data_cycle: Optional[Union[bool, list[bool], tuple[bool, ...], dict[str, bool]]] = None, freq: Optional[Union[str, list[str], tuple[str, ...], dict[str, str]]] = None, asset_type: Optional[Union[str, list[str], tuple[str, ...], dict[str, str]]] = None, par_values: Optional[Union[tuple, list, dict[str, Any]]] = None, par_range: Optional[Union[tuple, list, dict[str, tuple]]] = None, run_freq: Optional[str] = None, run_timing: Optional[str] = None, **kwargs)[源代码]

统一的策略参数设置入口，stg_id标识接受参数的具体成员策略，将函数参数中给定的策略参数赋值给相应的策略

参数:

stg_id (str,) – 策略的名称（ID），根据ID定位需要修改参数的策略
pars (tuple or dict, optional) – 可调策略参数，格式为tuple 在创建一个策略的时候，可以设置部分策略参数为”可调参数”，这些参数的取值范围可以在策略优化过程中进行调整，通过调整这些参数的组合，可以找到最优的策略参数组合，从而找到最优的策略
opt_tag (int, optional) – 优化类型： 0: 不参加优化，在策略优化过程中不调整该策略的可调参数 1: 参加优化，在策略优化过程中根据优化算法主动调整策略参数以寻找最佳参数组合 2: 以枚举类型参加优化，在策略优化过程中仅从给定的参数组合种选取最优的参数组合
data_types (DataType or list of DataType or dict of str, optional) – 策略计算所需历史数据的数据类型，如果给出，则更新这个数据类型的参数
data_type_id (str, optional) – 策略计算所需历史数据的数据类型的ID，给出该ID表明更新这个数据类型的参数
window_length (int or list of int or tuple of int,) – 窗口长度：策略计算的前视窗口长度
use_latest_data_cycle (bool or list of bool or tuple of bool,) – 是否使用最新的数据周期
freq (str or list of str or tuple of str or dict of str,) – 数据类型的频率，若给出则用新 DataType 替换对应项（dtype_id 会随之变化）
asset_type (str or list of str or tuple of str or dict of str,) – 数据类型的资产类型，若给出则用新 DataType 替换对应项（dtype_id 会随之变化）
par_values (tuple or list,) – 策略参数的具体取值
par_range (tuple or list, or dict of tuples,) – 策略参数的取值范围
run_freq (str, optional) – 如果给出该参数，则修改策略的运行频率，修改运行频率会导致将策略从策略组中移除，并重新分配到一个新的策略组中
run_timing (str, optional) – 如果给出该参数，则修改策略的运行时机，修改运行时机会导致将策略从策略组中移除，并重新分配到一个新的策略组中
kwargs (dict,) – 其他参数

set_shares(shares: list[str])[源代码]

设置operator对象的交易标的列表

参数:: shares (list of str) – 一个字符串列表，表示交易标的代码列表
返回类型:: None

property strategies: 以列表的形式返回operator对象的所有Strategy对象

property strategy_count: 返回operator对象中的所有Strategy对象的数量

property strategy_group_count

计算operator对象中所有交易策略组的数量

返回类型:: int, operator对象中所有交易策略组的数量

property strategy_groups: 返回operator的所有策略组，返回以策略组的名称为索引的字典

property strategy_ids: 返回operator对象中所有交易策略对象的ID

view_blender(group: Optional[Union[str, int]] = None) → Union[dict, str][源代码]

返回operator对象中的多空蒙板混合器的可读版本, 即返回blender的原始字符串的更加可读的: 版本，将s0等策略代码替换为策略ID，并进行适当格式化。如果不给出group参数，则返回所有策略组的blender可读版本

参数:: group (str) – 一个可用的group的ID或index

Group 策略组类

class qteasy.group.Group(name: str, signal_type: str = 'pt', blender: Optional[str] = None, run_freq: str = 'd', run_timing: str = 'close')[源代码]

策略组，包含多个策略成员，定义了成员策略的信号类型、混合方式、运行频率和时机等属性。

add_strategy(strategy: BaseStrategy) → None[源代码]

添加一个策略到组中，策略将成为该组的成员。

新增的策略必须是 BaseStrategy 的实例，并且不能已经是该组的成员，否则将引发 ValueError。新增策略的 group_id 将被设置为该组的 group_id，以便在策略中访问所属组的信息。

参数:

strategy (BaseStrategy) – 需要添加到组中的策略实例，必须是 BaseStrategy 的子类实例。

返回类型:

None

抛出:

ValueError – 当 strategy 已经是该组的成员时，抛出 ValueError，提示策略已存在于组中。
TypeError – 当 strategy 不是 BaseStrategy 的实例时，抛出 TypeError，提示策略类型错误。

blend(signals: Iterable)[源代码]: 使用当前 blender 将同组策略信号混合为一组信号。

clear_strategies()[源代码]: 清空组中的所有策略，所有成员策略将不再是该组的成员。

property group_id: Group 的 ID，与 name 相同，用于 Strategy.group_id 兼容

remove_strategy(strategy: BaseStrategy)[源代码]

从组中移除一个策略，策略将不再是该组的成员。

被移除的策略必须是该组的成员，否则将引发 ValueError。被移除策略的 group_id 将被设置为 None，以表示不再属于任何组。

参数:

strategy (BaseStrategy) – 需要从组中移除的策略实例，必须是该组的成员。

返回类型:

None

抛出:

ValueError – 当 strategy 不是该组的成员时，抛出 ValueError，提示策略不在组中。
TypeError – 当 strategy 不是 BaseStrategy 的实例时，抛出 TypeError，提示策略类型错误。