feat: 指数成分成交汇总 + 债券/回购价格标度修复 + 美股分时 hour 修复 (0.6.5) (#6)

* feat: 指数成分成交汇总 + 债券/回购价格标度修复 + 美股分时 hour 修复

新增
- get_index_members / get_index_trade_stats / get_index_trade_stats_multi:
  由成分股逐笔累加出指数的每分钟成交量与成交笔数(协议里指数本身没有笔数,
  trade_count 实为均价*1000)
- CLI: tdx index-stats

修复
- price_decimal_digits 补齐债券/回购 4 位小数档:沪市少 100 倍、深市少 10 倍,
  沪市 B 股 900xxx 改为 3 位。已用全量 51982 只标的的 SecurityInfo.decimal_point
  逐条比对,零例外
- MinuteBar.hour 对美股(EX)出现 24~27:改为 hour%=24 + day_offset,
  新增 datetime / trading_date 只读属性;A股/港股零行为变化

测试 217 -> 289

* chore: bump version 0.6.5

---------

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
This commit is contained in:
openbotandopenbot-coder authored and GitHub committed 2026-10-22 13:54:35 +08:00
1 parent ca24521d2c
commit b84a6c8a1b
15 files changed
+1129 -21

No files matched your search

+5 -1
View File
@@ -7,16 +7,18 @@ from .models import (
Adjust,
ExMarket,
FinanceRecord,
IndexTradeStats,
KlinePeriod,
Market,
MinuteBar,
MinuteTradeStat,
SecurityBar,
SecurityQuote,
TransactionRecord,
XdxrRecord,
)
__version__ = "0.6.4"
__version__ = "0.6.5"
__all__ = [
"TdxData",
"Market",
@@ -27,6 +29,8 @@ __all__ = [
"SecurityQuote",
"TransactionRecord",
"MinuteBar",
"MinuteTradeStat",
"IndexTradeStats",
"XdxrRecord",
"FinanceRecord",
"__version__",
+236
View File
@@ -23,7 +23,9 @@ from __future__ import annotations
import asyncio
import logging
import re
import time
import warnings
from collections.abc import Callable
from datetime import date as _date, datetime
from pathlib import Path
from typing import Sequence
@@ -45,11 +47,13 @@ from .models import (
FinancialFileInfo,
FinancialRecord,
IndicatorSet,
IndexTradeStats,
IndustryInfo,
KlinePeriod,
Market,
MemberQuote,
MinuteBar,
MinuteTradeStat,
SecurityBar,
SecurityInfo,
SecurityQuote,
@@ -1291,6 +1295,238 @@ class TdxData:
result.sort(key=lambda x: x["change_pct"], reverse=True)
return result[:top_n]
# ================================================================== #
# 七之二、指数成分成交汇总(成分股逐笔 → 每分钟成交量 / 笔数)
# ================================================================== #
@staticmethod
def _index_pair(index: str) -> tuple[int, str]:
"""解析指数标的 → ``(市场号, 6 位代码)``。
与 :func:`~pytdxdata.symbols.parse_symbol` 的关键区别:**裸 6 位数字
一律按指数语义解析**,不做「``000xxx`` → 深市股票」的推断 ——
在指数接口里 ``000001`` 是**上证指数**,不是平安银行 ``sz000001``。
判定规则(与通达信板块码一致)::
000xxx / 999xxx / 880xxx -> 沪市(上证指数 / A股指数 / 板块指数)
399xxx -> 深市(深证成指 / 创业板指)
899xxx -> 北交所(北证50)
显式前缀 ``sh``/``sz``/``bj`` 优先,例如 ``sz399001``、``sh000300``。
"""
s = str(index).strip().lower().replace(".", "").replace(":", "")
if not s:
raise ValueError("指数标的不能为空")
prefix_table = {"sh": 1, "sz": 0, "bj": 2}
if s[:2] in prefix_table:
code = s[2:]
if not (code.isdigit() and len(code) == 6):
raise ValueError(f"非法指数标的: {index!r}(前缀后需 6 位数字)")
return prefix_table[s[:2]], code
if not (s.isdigit() and len(s) == 6):
raise ValueError(f"非法指数标的: {index!r}(需 6 位代码或 sh/sz/bj 前缀)")
if s.startswith(("000", "999", "880")):
return 1, s
if s.startswith("399"):
return 0, s
if s.startswith("899"):
return 2, s
raise ValueError(f"无法判定指数市场: {index!r}(不是 A股指数代码段)")
async def get_index_members(self, index: str, *, count: int = 100000,
fields: Sequence[int] | None = None
) -> list[SecurityQuote]:
"""指数**成分股**(含实时报价)。
走 MAC ``0x122C`` 板块成分命令,指数代码映射为服务端板块码:``000300`` →
31300、``399001`` → 30001、``899050`` → 32050(见 :meth:`_convert_board_code`)。
实测(2026-10-22):``sh000001`` 2230 只(沪市全部)、``sh000300`` 300 只、
``sh000016`` 50 只、``sh000905`` 500 只、``sh000852`` 1000 只、
``sz399006`` 100 只、``bj899050`` 50 只。
参数:
index: 指数代码,可裸写或带前缀(``"000300"`` / ``"sh000300"``)。
count: 最多取的成分数(分页上限,默认足够覆盖全部)。
fields: 附加报价字段位(同 :meth:`get_board_members`)。
注意:返回的是**当前**成分,指数调仓后历史日期不适用。
用法::
members = await td.get_index_members("000300")
syms = [m.symbol for m in members] # ['sz000001', ...]
"""
_market, code = self._index_pair(index)
board_code = self._convert_board_code(code)
bits = [int(b) for b in fields] if fields else list(_QUOTE_BITS)
items: list[SecurityQuote] = []
start = 0
while start < count:
batch = await self._execute_mac(MacBoardMembersQuotesCmd(
board_code, sort_type=0, start=start,
page_size=_QUOTE_PAGE, bits=bits))
if not batch:
break
items.extend(_quote_from_member(m) for m in batch)
start += len(batch)
if len(batch) < _QUOTE_PAGE:
break
return items[:count]
async def get_index_trade_stats(
self,
index: str,
date: int | None = None,
*,
concurrency: int = 24,
batch_size: int = 50,
members: Sequence[str] | None = None,
skip_errors: bool = True,
on_progress: Callable[[int, int], None] | None = None,
) -> IndexTradeStats:
"""按指数**全部成分股**的逐笔汇总出每分钟成交量与成交笔数。
为什么必须绕这一圈:**通达信协议里指数本身没有成交笔数** —— 指数逐笔的
``trade_count`` 是「当时均价 × 1000」,不是笔数(见
:class:`TransactionRecord` 类注释)。所以「指数笔数」只能用成分股逐笔累加。
口径校验:``total_amount`` 是**成分股**合计。对「成分 = 指数覆盖面」的指数
它与指数快照 ``amount`` 完全相等(``sh000016`` 661.34 亿、``sh000300``
2373.98 亿,比值 1.0000);但深市 ``399xxx`` 的指数 ``amount`` 是**全板块**
口径(``sz399001`` = 深市全部股票 5081 亿、``sz399006`` = 创业板全部),
两者不可直接比。详见 :class:`IndexTradeStats`。
参数:
index: 指数代码(``"000300"`` / ``"sh000300"``,规则见 :meth:`_index_pair`)。
date: ``None`` = 当日;``YYYYMMDD`` = 历史某日(通达信逐笔仅保留最近
若干交易日,实测 2026-10-22 可回溯到 10-14,更早返回空)。
concurrency: 逐笔并发数(受 MAC 连接池上限约束,池满自动排队)。
batch_size: 每批处理的成分数 —— 批内并发拉取、批间串行聚合,
用于压住内存峰值(全量 tick 不驻留)。
members: 直接给成分股列表(跳过 :meth:`get_index_members`,
多日循环时可复用一次成分请求)。
skip_errors: 单只成分失败是否忽略(默认忽略并计入 ``failed_members``)。
on_progress: 进度回调 ``(已处理, 总数)``,每批结束调用一次。
返回:
:class:`IndexTradeStats`;``minutes`` 是**每分钟增量**,
「当日截止该分钟累计」用 ``.cumulative()`` / ``.cum_trade_count()``。
性能(实测 2026-10-22,盘中):
====================== ========== ============
指数 成分数 耗时
====================== ========== ============
``sh000016`` 上证50 50 ~5 s
``sh000300`` 沪深300 300 ~10 s
``sh000001`` 上证指数 2230 ~60-90 s
====================== ========== ============
**北交所成分没有笔数**(实测 ``trade_count`` 恒 0),此时
``trade_count_available`` 为 ``False``,只有成交量可用。
用法::
st = await td.get_index_trade_stats("000300")
for hhmm, cum in st.cum_trade_count():
print(hhmm, cum)
"""
started = time.perf_counter()
market, code = self._index_pair(index)
idx_text = format_symbol(market, code)
if members is None:
members = [m.symbol for m in await self.get_index_members(code)]
syms = [s for s in members if s]
total = len(syms)
if total == 0:
raise ValueError(f"指数 {index!r} 没有取到成分股")
vol_by_min: dict[str, float] = {}
tc_by_min: dict[str, int] = {}
amt_by_min: dict[str, float] = {}
active: set[str] = set()
with_tc: set[str] = set()
failed = 0
step = max(1, int(batch_size))
done = 0
for i in range(0, total, step):
batch = syms[i:i + step]
try:
ticks = await self.get_ticks(batch, date=date, concurrency=concurrency)
except Exception:
if not skip_errors:
raise
# 整批失败 → 退化为逐只重试,避免一只坏股拖垮一批
ticks = []
for one in batch:
try:
ticks.extend(await self.get_ticks(one, date=date))
except Exception:
failed += 1
for t in ticks:
hhmm = t.time[:5]
vol_by_min[hhmm] = vol_by_min.get(hhmm, 0.0) + t.vol
tc_by_min[hhmm] = tc_by_min.get(hhmm, 0) + t.trade_count
amt_by_min[hhmm] = amt_by_min.get(hhmm, 0.0) + t.price * t.vol * 100.0
active.add(t.symbol)
if t.trade_count:
with_tc.add(t.symbol)
done += len(batch)
if on_progress is not None:
on_progress(min(done, total), total)
minutes = [
MinuteTradeStat(time=k, volume=vol_by_min[k],
trade_count=tc_by_min[k], amount=amt_by_min[k])
for k in sorted(vol_by_min)
]
return IndexTradeStats(
index=idx_text,
date=date,
member_count=total,
active_members=len(active),
trade_count_members=len(with_tc),
minutes=minutes,
total_volume=sum(vol_by_min.values()),
total_trade_count=sum(tc_by_min.values()),
total_amount=sum(amt_by_min.values()),
failed_members=failed,
elapsed=time.perf_counter() - started,
)
async def get_index_trade_stats_multi(
self,
index: str,
dates: Sequence[int | None],
*,
concurrency: int = 24,
batch_size: int = 50,
skip_errors: bool = True,
on_progress: Callable[[int, int], None] | None = None,
) -> list[IndexTradeStats]:
"""多日批量版 :meth:`get_index_trade_stats`(成分只取一次)。
用于「近 N 日同时点累计平均笔数」这类基准曲线:一次拿到 N 天数据,
避免每天重复请求成分表。
用法::
# 最近 5 个交易日的笔数曲线(日期自己给,节假日请自行跳过)
stats = await td.get_index_trade_stats_multi(
"000300", [20261016, 20261019, 20261020, 20261021, 20261022])
"""
market, code = self._index_pair(index)
members = [m.symbol for m in await self.get_index_members(code)]
out: list[IndexTradeStats] = []
for d in dates:
out.append(await self.get_index_trade_stats(
code, d, concurrency=concurrency, batch_size=batch_size,
members=members, skip_errors=skip_errors,
on_progress=on_progress))
return out
# ================================================================== #
# 八、服务器文件(原始字节 + 解析)
# ================================================================== #
+49
View File
@@ -8,6 +8,7 @@
tdx transactions sz000001 --count 50 # 逐笔成交
tdx minute sz000001 # 分时(今日/历史--date)
tdx index 000001 --count 30 # 指数K线
tdx index-stats 000300 --top 10 # 指数成分成交汇总(每分钟成交量/笔数)
tdx board list [--type 1] # 板块列表(0全部/1行业/2概念)
tdx board members 881001 --count 20 # 板块成分
tdx board ranking [--top 10] # 板块涨跌幅排行
@@ -204,6 +205,43 @@ async def cmd_board(td: TdxData, args) -> None:
print(" %-12s %+8.2f%%" % (r.get("name", ""), r.get("change_pct", 0)))
async def cmd_index_stats(td: TdxData, index: str, date: int | None,
show_all: bool, top: int, concurrency: int) -> None:
"""指数成分成交汇总:每分钟成交量 / 笔数(笔数=成分股逐笔累加)。"""
total = 0
def on_progress(done: int, all_: int) -> None:
nonlocal total
total = all_
print("\r 拉取成分逐笔 %d/%d ..." % (done, all_), end="", file=sys.stderr,
flush=True)
st = await td.get_index_trade_stats(
index, date, concurrency=concurrency, on_progress=on_progress)
if total:
print("\r" + " " * 40 + "\r", end="", file=sys.stderr, flush=True)
print("%s 成分成交汇总" % st.index)
print(" 成分 %d 只 / 有成交 %d 只 / 有笔数 %d 只%s" % (
st.member_count, st.active_members, st.trade_count_members,
"" if st.trade_count_available else " ★该指数无笔数口径"))
print(" 成交量 %s 手 成交笔数 %s 笔 成交额 %.2f 亿 耗时 %.1fs" % (
_fmt_num(st.total_volume),
_fmt_num(st.total_trade_count) if st.trade_count_available else "-",
st.total_amount / 1e8, st.elapsed))
if st.failed_members:
print(" (%d 只成分逐笔拉取失败,已跳过)" % st.failed_members)
print()
print(" 时间 累计成交量 累计笔数")
rows = st.cumulative()
if not show_all:
rows = rows[-top:]
for m in rows:
print(" %-6s %12s %12s" % (
m.time, _fmt_num(m.volume),
_fmt_num(m.trade_count) if st.trade_count_available else "-"))
async def cmd_info(td: TdxData, sym: str) -> None:
s = parse_symbol(sym)
info = await td.get_symbol_info(Market(s.market), s.code)
@@ -390,6 +428,17 @@ def main() -> None:
ix.set_defaults(func=lambda td, a: cmd_kline(
td, a.code, KlinePeriod.DAY, a.count, 0, Adjust.NONE))
ist = add("index-stats", "指数成分成交汇总(每分钟成交量/笔数)")
ist.add_argument("index", help="指数代码,如 000300 / 000001 / sh000016")
ist.add_argument("--date", type=str, default=None, help="YYYYMMDD,缺省=当日")
ist.add_argument("--top", type=int, default=10, help="只显示最后 N 分钟(默认10)")
ist.add_argument("--all", dest="show_all", action="store_true",
help="显示全部分钟")
ist.add_argument("--concurrency", type=int, default=24, help="逐笔并发数")
ist.set_defaults(func=lambda td, a: cmd_index_stats(
td, a.index, int(a.date) if a.date else None,
a.show_all, a.top, a.concurrency))
b = add("board", "板块")
b.add_argument("action", choices=["list", "members", "ranking", "change"])
b.add_argument("symbol", nargs="?", default="")
+128 -1
View File
@@ -262,7 +262,11 @@ class TransactionRecord:
@dataclass(slots=True)
class MinuteBar:
"""分时(跨市场统一模型;A股 MAC 0x122D / 扩展市场 0x122D 同构)"""
"""分时(跨市场统一模型;A股 MAC 0x122D / 扩展市场 0x122D 同构)。
``hour``/``minute`` 是**真实时钟**(``0 <= hour < 24``),跨日的分时请用
:attr:`datetime` / :attr:`trading_date`,不要自己拿 ``hour`` 拼日期。
"""
price: float
vol: float
avg_price: float = 0.0 # 均价(协议第2字段)
@@ -273,6 +277,50 @@ class MinuteBar:
code: str = ""
date: int = 0 # YYYYMMDD
fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(动量等)
day_offset: int = 0 # 相对 date 的自然日偏移:美股凌晨段为 +1
def __post_init__(self) -> None:
"""美股(EX 通道)分时时间归一化。
EX 分时的 ``minutes`` 字段是**自开盘起的连续分钟数**,不是「当天的分钟数」:
实测 ``usAAPL`` 返回 ``21:30`` ~ ``27:59``(390 条里 240 条的 ``hour`` ≥ 24)。
``27:59`` 实际是次日 ``03:59`` 北京时间。直接 ``minutes // 60`` 会得到
``hour=27`` 这种**非法时钟值**,任何 ``datetime(...)`` 拼接都会抛异常,
按小时聚合也会把凌晨段错误地归到同一天。
这里拆成「真实小时 + 日偏移」:``hour = (minutes // 60) % 24``,
``day_offset = (minutes // 60) // 24``。A股/港股/期货的 ``hour`` 本就合法
(A股合成时间 09:30~15:00、港股 09:30~16:00),**零行为变化**。
"""
if self.hour >= 24:
self.day_offset += self.hour // 24
self.hour %= 24
@property
def datetime(self) -> datetime:
"""该分时点的时刻(北京时间,已含跨日偏移)。"""
base = date(self.date // 10000, self.date // 100 % 100, self.date % 100)
d = base + timedelta(days=self.day_offset)
return datetime(d.year, d.month, d.day, self.hour, self.minute)
@property
def is_us(self) -> bool:
"""是否美股(EX 通道 ``US_STOCK``)。"""
return self.market in _US_EX_MARKETS
@property
def trading_date(self) -> str:
"""该分时点归属的交易日,``YYYY-MM-DD``。
美股:一个交易日横跨两个北京自然日(21:30~次日 04:00),凌晨段
(北京 hour < 12)归属**前一天**的美东交易日,与
:attr:`SecurityBar.trading_date` 口径一致。A股/港股/期货即 ``date`` 本身。
按交易日聚合分时(合成日线、日内统计)**必须用它**。
"""
base = self.datetime
if self.is_us and base.hour < _US_DAY_SPLIT_HOUR:
base -= timedelta(days=1)
return base.date().isoformat()
@dataclass(slots=True)
@@ -514,3 +562,82 @@ class FinancialRecord:
market: int # 0=深 1=沪
report_date: int # 报告期 YYYYMMDD
fields: list[float] = field(default_factory=list)
# ===== 指数成分成交汇总(TdxData.get_index_trade_stats) =====
@dataclass(slots=True)
class MinuteTradeStat:
"""指数**全部成分股**汇总后的单分钟成交**增量**(不是累计)。
累计曲线用 :meth:`IndexTradeStats.cumulative`,不要自己再对同一字段反复累加。
"""
time: str # HH:MM
volume: float # 成交量合计(手,1 手 = 100 股)
trade_count: int # 成交笔数合计
amount: float # 成交额估算(元)= Σ(逐笔价 × 手 × 100)
@dataclass(slots=True)
class IndexTradeStats:
"""某个指数「全部成分股逐笔」汇总出的成交曲线。
为什么需要它:**通达信协议里指数本身没有成交笔数** —— 指数逐笔
(``sh000001``)的 ``trade_count`` 字段实际是「当时均价 × 1000」(见
:class:`TransactionRecord`)。所以「指数笔数」唯一可行的口径是
**把成分股的逐笔笔数累加**,本类即该口径。
口径校验(2026-10-22 实测):
- ``total_amount`` 是**成分股**合计。对「成分恰好就是指数覆盖面」的指数,它与
指数快照 ``amount`` **完全相等**:``sh000016`` 661.34 亿 = 661.34 亿、
``sh000300`` 2373.98 亿 = 2373.98 亿(比值 1.0000)。
- **但深市 ``399xxx`` 的指数成交额字段是「全板块」口径**,不是样本股:
实测 ``sz399001`` 快照 5081.40 亿 = 深市 2908 只股票合计 5081.01 亿、
``sz399006`` 2568.60 亿 = 创业板全部股票合计。所以拿深市指数 ``amount``
与 ``total_amount`` 比会得到 ~0.43 这类无意义比值——不是数据错,是口径不同。
- ``total_volume`` 单位是**手**(与指数逐笔的「百元」单位不同,勿混用)。
- 北交所成分(``bj`` 前缀)**没有笔数字段**(实测 ``trade_count`` 恒为 0):
此时 ``trade_count_members = 0``、:attr:`trade_count_available` 为 ``False``,
只有成交量可用。``sh``/``sz`` 成分均正常返回笔数。
``minutes`` 只包含**实际有成交**的分钟(午休 11:30~13:00 之间无桶),
画累计曲线时请按 ``time`` 自行补齐或直接连线。
"""
index: str # 规范化指数标的(如 sh000300)
date: int | None # None=当日;否则 YYYYMMDD
member_count: int # 指数成分数
active_members: int # 实际有逐笔成交的成分数(停牌/无成交不计)
trade_count_members: int # 返回了笔数的成分数(北交所为 0)
minutes: list[MinuteTradeStat] = field(default_factory=list)
total_volume: float = 0.0
total_trade_count: int = 0
total_amount: float = 0.0
failed_members: int = 0 # 逐笔拉取失败的成分数(skip_errors=True 时)
elapsed: float = 0.0 # 本次汇总耗时(秒)
@property
def trade_count_available(self) -> bool:
"""是否有笔数口径(北交所成分为 ``False``,此时 ``trade_count`` 全 0)。"""
return self.trade_count_members > 0
def cumulative(self) -> list[MinuteTradeStat]:
"""累计曲线:当日**截止该分钟**的累计量,时间升序。
这是「当日截止该分钟累计成交笔数」的直接数据源。
"""
out: list[MinuteTradeStat] = []
vol = 0.0
tc = 0
amt = 0.0
for m in self.minutes:
vol += m.volume
tc += m.trade_count
amt += m.amount
out.append(MinuteTradeStat(time=m.time, volume=vol,
trade_count=tc, amount=amt))
return out
def cum_trade_count(self) -> list[tuple[str, int]]:
"""``[(HH:MM, 累计笔数)]``,画「截止该分钟累计笔数」曲线用。"""
return [(m.time, m.trade_count) for m in self.cumulative()]
+36 -13
View File
@@ -13,23 +13,46 @@ MAX_QUOTES = 80
def price_decimal_digits(market: int, code: str) -> int:
"""推断报价有效小数位:股票 2 位(/100)、ETF/基金 3 位(/1000)。
"""推断报价的小数位:**协议原始整数除以 ``10**该值``** 才是真实价格。
**沪市指数必须是 2 位**,此前把 ``000``/``8`` 一并判成 3 位,导致上证50、
上证指数、科创50 等**价格整体少 10 倍**。实证(2026-10-21):协议原始整数
与分时/逐笔价格比对,6 只沪市指数 + 2 只板块指数(880001/880305)全部是
``×10`` 错误,而 4 只沪市 ETF(510300/510500/588000/511010)、4 只沪市
股票、3 只科创板、3 只深市指数、深市股票/创业板/ETF 全部 ``×1`` 正确。
四档:股票/指数/板块 ``2``、基金/ETF/B股 ``3``、债券/回购 ``4``。
该函数只是**离线推断**(``get_quotes`` 解析时拿不到证券清单)。真正的权威来源
是证券列表里协议自带的 ``SecurityInfo.decimal_point`` 字段——2026-10-22 拉取
全量 51,982 只(沪 27,520 + 深 24,462)逐条比对,本函数与之一一吻合、**零例外**。
能对上是因为「三位前缀 → 小数位」在全量清单里没有任何一个前缀出现混合小数位。
历史修正(两次都是同一类错误:把某段前缀想当然地归错档):
- **2026-10-21**:沪市 ``000``/``8`` 被判成 3 位 → 上证指数/上证50/科创50/
板块指数**价格少 10 倍**(3713 读成 371)。它们实际是 2 位。
- **2026-10-22**:债券与回购全线偏差 —— 沪市 ``010/018/019/020/1xx/2xx``
与深市 ``10x/11x/12x/13x/14x/19x/50x/52x/56x`` 实际是 **4 位**,原先
沪市落到 2 位(**少 100 倍**)、深市落到 3 位(**少 10 倍**)。实测例:
``sh019742`` 110.228 读成 11022.8、``sh204001`` 1.385 读成 138.5、
``sz131810`` 1.38 读成 13.8。同时沪市 B 股 ``900xxx`` 是 3 位(原先 2 位)。
实证方法:拿 ``pre_close``(快照口径)除以上一交易日**日线收盘**(K线口径,
走 ``/1000`` 独立路径),比值即标度误差 —— 1.0 正确、10 少 10 倍、100 少 100 倍。
"""
code = (code or "").strip().rstrip("\x00")
if market == 1: # SH
if market == 1: # 沪市
if code.startswith("5"):
return 3 # ETF/基金
return 2 # 指数(000xxx/880xxx)、股票(60xxxx/688xxx)
if market == 0: # SZ
if code.startswith("1"):
return 3 # 基金/债券
return 2 # 指数(399xxx)、股票(00xxxx/30xxxx)
return 3 # 基金/ETF/LOF(50/51/52/56/58 系)
if code.startswith("900"):
return 3 # B股
if code.startswith(("000", "36", "88", "99", "7", "6")):
return 2 # 指数/板块/优先股/配售/股票(60/601/603/605/688)
return 4 # 债券(01x/1xx/2xx)、回购(204xxx)、ABS
if market == 0: # 深市
if code.startswith(("080", "158", "159", "160", "161", "162", "163",
"164", "165", "166", "167", "168", "169",
"180", "181")):
return 3 # 基金/ETF/LOF/配债
if code.startswith(("000", "001", "002", "003", "070", "140",
"200", "201", "300", "301", "302", "395", "399")):
return 2 # 股票/指数/B股/优先股
return 4 # 债券(10x-14x/19x)、回购(131xxx)、ABS(50x/52x/56x)
return 2