1#!/usr/bin/env python3
2"""
3A股估值计算器
4提供DCF、DDM、相对估值等多种估值方法
5 
6依赖: pip install pandas numpy
7"""
8 
9import argparse
10import json
11import sys
12from datetime import datetime
13from typing import Optional, Dict
14 
15try:
16    import pandas as pd
17    import numpy as np
18except ImportError:
19    print("错误: 请先安装依赖库")
20    print("pip install pandas numpy")
21    sys.exit(1)
22 
23 
24class ValuationCalculator:
25    """估值计算器"""
26 
27    def __init__(self, stock_data: Dict = None):
28        self.stock_data = stock_data or {}
29        self.results = {}
30 
31    def load_data(self, file_path: str):
32        """从JSON文件加载股票数据"""
33        with open(file_path, 'r', encoding='utf-8') as f:
34            self.stock_data = json.load(f)
35 
36    def dcf_valuation(self, discount_rate: float = 10,
37                      forecast_years: int = 5,
38                      terminal_growth: float = 3) -> Dict:
39        """
40        DCF现金流折现估值
41 
42        参数:
43            discount_rate: 折现率 (%)
44            forecast_years: 预测期年数
45            terminal_growth: 永续增长率 (%)
46        """
47        result = {
48            "method": "DCF现金流折现",
49            "parameters": {
50                "discount_rate": discount_rate,
51                "forecast_years": forecast_years,
52                "terminal_growth": terminal_growth
53            },
54            "calculation": {},
55            "intrinsic_value": None,
56            "per_share_value": None
57        }
58 
59        # 获取现金流数据
60        cash_flow = self.stock_data.get('financial_data', {}).get('cash_flow', [])
61        basic_info = self.stock_data.get('basic_info', {})
62 
63        if not cash_flow:
64            result["error"] = "无法获取现金流数据"
65            return result
66 
67        try:
68            # 计算历史自由现金流
69            fcf_history = []
70            for cf in cash_flow[:4]:  # 最近4个季度
71                ocf = self._safe_float(cf.get('经营活动产生的现金流量净额', 0))
72                capex = abs(self._safe_float(cf.get('购建固定资产、无形资产和其他长期资产支付的现金', 0)))
73                if ocf is not None:
74                    fcf = ocf - capex
75                    fcf_history.append(fcf)
76 
77            if not fcf_history:
78                result["error"] = "无法计算自由现金流"
79                return result
80 
81            # 年化FCF (简单年化)
82            annual_fcf = sum(fcf_history)
83            result["calculation"]["当前年化FCF"] = annual_fcf
84 
85            # 估算增长率 (使用历史净利润增长率)
86            indicators = self.stock_data.get('financial_indicators', [])
87            growth_rate = 10  # 默认10%
88            if indicators:
89                hist_growth = self._safe_float(indicators[0].get('净利润增长率'))
90                if hist_growth and -50 < hist_growth < 100:
91                    growth_rate = min(max(hist_growth, 0), 30)  # 限制在0-30%之间
92 
93            result["calculation"]["预计增长率"] = growth_rate
94 
95            # 预测未来现金流
96            r = discount_rate / 100
97            g = growth_rate / 100
98            tg = terminal_growth / 100
99 
100            pv_fcf = 0
101            future_fcf = []
102            for year in range(1, forecast_years + 1):
103                fcf = annual_fcf * ((1 + g) ** year)
104                pv = fcf / ((1 + r) ** year)
105                pv_fcf += pv
106                future_fcf.append({"year": year, "fcf": fcf, "pv": pv})
107 
108            result["calculation"]["预测期现金流现值"] = pv_fcf
109            result["calculation"]["future_fcf"] = future_fcf
110 
111            # 终值计算 (Gordon模型)
112            terminal_fcf = annual_fcf * ((1 + g) ** forecast_years) * (1 + tg)
113            terminal_value = terminal_fcf / (r - tg)
114            pv_terminal = terminal_value / ((1 + r) ** forecast_years)
115 
116            result["calculation"]["终值"] = terminal_value
117            result["calculation"]["终值现值"] = pv_terminal
118 
119            # 总价值
120            total_value = pv_fcf + pv_terminal
121            result["intrinsic_value"] = total_value
122 
123            # 每股价值
124            total_shares = self._parse_shares(basic_info.get('total_shares', ''))
125            if total_shares:
126                per_share = total_value / total_shares
127                result["per_share_value"] = per_share
128 
129        except Exception as e:
130            result["error"] = str(e)
131 
132        return result
133 
134    def ddm_valuation(self, required_return: float = 10,
135                      dividend_growth: float = None) -> Dict:
136        """
137        DDM股息折现估值 (Gordon模型)
138 
139        参数:
140            required_return: 要求回报率 (%)
141            dividend_growth: 股息增长率 (%)，如果为None则自动计算
142        """
143        result = {
144            "method": "DDM股息折现",
145            "parameters": {
146                "required_return": required_return
147            },
148            "calculation": {},
149            "intrinsic_value": None,
150            "per_share_value": None
151        }
152 
153        # 获取分红数据
154        dividend = self.stock_data.get('dividend', {})
155        dividend_history = dividend.get('dividend_history', [])
156        basic_info = self.stock_data.get('basic_info', {})
157 
158        if not dividend_history:
159            result["error"] = "无分红历史数据"
160            result["note"] = "该公司可能分红较少或不稳定，不适合DDM估值"
161            return result
162 
163        try:
164            # 计算最近股息
165            recent_dividends = []
166            for d in dividend_history[:5]:  # 最近5年
167                div = self._safe_float(d.get('每股股利', d.get('派息', 0)))
168                if div and div > 0:
169                    recent_dividends.append(div)
170 
171            if len(recent_dividends) < 2:
172                result["error"] = "分红数据不足，无法使用DDM"
173                return result
174 
175            current_dividend = recent_dividends[0]
176            result["calculation"]["当前每股股息"] = current_dividend
177 
178            # 计算股息增长率
179            if dividend_growth is None:
180                if len(recent_dividends) >= 2:
181                    # 计算复合增长率
182                    years = len(recent_dividends) - 1
183                    cagr = (recent_dividends[0] / recent_dividends[-1]) ** (1 / years) - 1
184                    dividend_growth = cagr * 100
185                else:
186                    dividend_growth = 3  # 默认3%
187 
188            # 限制增长率
189            dividend_growth = min(max(dividend_growth, 0), required_return - 1)
190            result["parameters"]["dividend_growth"] = dividend_growth
191            result["calculation"]["股息增长率"] = dividend_growth
192 
193            # Gordon模型: P = D1 / (r - g)
194            r = required_return / 100
195            g = dividend_growth / 100
196            d1 = current_dividend * (1 + g)
197 
198            if r <= g:
199                result["error"] = "增长率不能大于或等于要求回报率"
200                return result
201 
202            per_share_value = d1 / (r - g)
203            result["per_share_value"] = per_share_value
204            result["calculation"]["下期预期股息(D1)"] = d1
205 
206            # 总价值
207            total_shares = self._parse_shares(basic_info.get('total_shares', ''))
208            if total_shares:
209                result["intrinsic_value"] = per_share_value * total_shares
210 
211        except Exception as e:
212            result["error"] = str(e)
213 
214        return result
215 
216    def _assess_percentile(self, percentile: float) -> str:
217        """根据分位数评估估值水平"""
218        if percentile < 20:
219            return "处于历史低位，可能被低估"
220        elif percentile < 40:
221            return "处于历史较低水平"
222        elif percentile < 60:
223            return "处于历史中等水平"
224        elif percentile < 80:
225            return "处于历史较高水平"
226        return "处于历史高位，估值偏贵"
227 
228    def relative_valuation(self) -> Dict:
229        """相对估值法，与行业均值和历史均值对比"""
230        result = {
231            "method": "相对估值",
232            "current_valuation": {},
233            "comparison": {},
234            "assessment": {}
235        }
236 
237        valuation = self.stock_data.get('valuation', {})
238        price = self.stock_data.get('price', {})
239        basic_info = self.stock_data.get('basic_info', {})
240 
241        try:
242            current_pe = self._safe_float(basic_info.get('pe_ttm'))
243            current_pb = self._safe_float(basic_info.get('pb'))
244 
245            if not current_pe and valuation.get('latest'):
246                current_pe = self._safe_float(valuation['latest'].get('pe'))
247                current_pb = self._safe_float(valuation['latest'].get('pb'))
248 
249            result["current_valuation"] = {
250                "PE_TTM": current_pe,
251                "PB": current_pb,
252                "当前价格": price.get('latest_price')
253            }
254 
255            pe_percentile = valuation.get('pe_percentile')
256            pb_percentile = valuation.get('pb_percentile')
257 
258            result["comparison"]["PE历史分位数"] = pe_percentile
259            result["comparison"]["PB历史分位数"] = pb_percentile
260 
261            # 估值评估
262            if pe_percentile is not None:
263                result["assessment"]["PE评估"] = self._assess_percentile(pe_percentile)
264            if pb_percentile is not None:
265                result["assessment"]["PB评估"] = self._assess_percentile(pb_percentile)
266 
267            # 计算基于历史均值的合理价格
268            current_price = price.get('latest_price', 0)
269            if current_pe and pe_percentile and pe_percentile > 0 and current_price and current_pe > 0:
270                fair_pe = current_pe * (50 / pe_percentile)
271                fair_price_pe = current_price * (fair_pe / current_pe)
272                result["comparison"]["基于PE的合理价格"] = round(fair_price_pe, 2)
273 
274        except Exception as e:
275            result["error"] = str(e)
276 
277        return result
278 
279    def calculate_margin_of_safety(self, intrinsic_value: float,
280                                    current_price: float,
281                                    margin_pct: float = 30) -> Dict:
282        """计算安全边际"""
283        result = {
284            "intrinsic_value": intrinsic_value,
285            "current_price": current_price,
286            "margin_of_safety_required": margin_pct
287        }
288 
289        if not (intrinsic_value and current_price):
290            return result
291 
292        actual_margin = (intrinsic_value - current_price) / intrinsic_value * 100
293        safety_price = intrinsic_value * (1 - margin_pct / 100)
294 
295        result["actual_margin_of_safety"] = round(actual_margin, 2)
296        result["safety_price"] = round(safety_price, 2)
297 
298        if current_price < safety_price:
299            result["conclusion"] = "低估 - 当前价格低于安全边际价格，具有投资价值"
300        elif current_price < intrinsic_value:
301            result["conclusion"] = "合理偏低 - 当前价格低于内在价值，但未达到安全边际"
302        else:
303            result["conclusion"] = "高估 - 当前价格高于内在价值"
304 
305        return result
306 
307    def comprehensive_valuation(self, discount_rate: float = 10,
308                                 terminal_growth: float = 3,
309                                 margin_of_safety: float = 30) -> Dict:
310        """综合估值，结合多种方法得出估值结论"""
311        result = {
312            "code": self.stock_data.get('code', ''),
313            "name": self.stock_data.get('basic_info', {}).get('name', ''),
314            "valuation_date": datetime.now().isoformat(),
315            "methods": {},
316            "summary": {}
317        }
318 
319        # 获取当前价格
320        current_price = self.stock_data.get('price', {}).get('latest_price')
321 
322        # DCF估值
323        dcf = self.dcf_valuation(discount_rate=discount_rate,
324                                  terminal_growth=terminal_growth)
325        result["methods"]["DCF"] = dcf
326 
327        # DDM估值
328        ddm = self.ddm_valuation()
329        result["methods"]["DDM"] = ddm
330 
331        # 相对估值
332        relative = self.relative_valuation()
333        result["methods"]["相对估值"] = relative
334 
335        # 汇总估值结果
336        valuations = []
337        if dcf.get('per_share_value'):
338            valuations.append(("DCF", dcf['per_share_value']))
339        if ddm.get('per_share_value'):
340            valuations.append(("DDM", ddm['per_share_value']))
341        if relative.get('comparison', {}).get('基于PE的合理价格'):
342            valuations.append(("相对估值", relative['comparison']['基于PE的合理价格']))
343 
344        if valuations:
345            avg_value = sum(v[1] for v in valuations) / len(valuations)
346            result["summary"]["平均内在价值"] = round(avg_value, 2)
347            result["summary"]["估值方法数"] = len(valuations)
348            result["summary"]["各方法估值"] = {k: round(v, 2) for k, v in valuations}
349 
350            # 安全边际计算
351            if current_price:
352                margin = self.calculate_margin_of_safety(
353                    avg_value, current_price, margin_of_safety
354                )
355                result["summary"]["安全边际分析"] = margin
356                result["summary"]["当前价格"] = current_price
357                result["summary"]["建议买入价"] = margin.get('safety_price')
358                result["summary"]["投资结论"] = margin.get('conclusion')
359 
360        return result
361 
362    def _safe_float(self, value) -> Optional[float]:
363        """安全转换为浮点数"""
364        if value is None or value == '' or value == '--':
365            return None
366        try:
367            if isinstance(value, str):
368                value = value.replace('%', '').replace(',', '').replace('亿', '')
369            return float(value)
370        except (ValueError, TypeError):
371            return None
372 
373    def _parse_shares(self, shares_str: str) -> Optional[float]:
374        """解析股份数"""
375        if not shares_str:
376            return None
377        try:
378            if '亿' in str(shares_str):
379                return float(shares_str.replace('亿', '')) * 100000000
380            elif '万' in str(shares_str):
381                return float(shares_str.replace('万', '')) * 10000
382            else:
383                return float(shares_str)
384        except (ValueError, TypeError):
385            return None
386 
387 
388def main():
389    parser = argparse.ArgumentParser(description="A股估值计算器")
390    parser.add_argument("--input", type=str, help="输入数据文件 (JSON)")
391    parser.add_argument("--code", type=str, help="股票代码 (如果不提供input)")
392    parser.add_argument("--methods", type=str, default="all",
393                       help="估值方法: dcf/ddm/relative/all")
394    parser.add_argument("--discount-rate", type=float, default=10,
395                       help="折现率 (%)")
396    parser.add_argument("--terminal-growth", type=float, default=3,
397                       help="永续增长率 (%)")
398    parser.add_argument("--margin-of-safety", type=float, default=30,
399                       help="安全边际要求 (%)")
400    parser.add_argument("--output", type=str, help="输出文件路径 (JSON)")
401 
402    args = parser.parse_args()
403 
404    calculator = ValuationCalculator()
405 
406    if args.input:
407        calculator.load_data(args.input)
408    elif args.code:
409        # 如果只提供代码，需要先获取数据
410        print("请先使用 data_fetcher.py 获取数据，然后使用 --input 参数")
411        sys.exit(1)
412    else:
413        print("请提供 --input 或 --code 参数")
414        sys.exit(1)
415 
416    # 执行估值
417    valuation_methods = {
418        "dcf": lambda: calculator.dcf_valuation(
419            discount_rate=args.discount_rate,
420            terminal_growth=args.terminal_growth
421        ),
422        "ddm": calculator.ddm_valuation,
423        "relative": calculator.relative_valuation,
424    }
425 
426    if args.methods in valuation_methods:
427        result = valuation_methods[args.methods]()
428    else:
429        result = calculator.comprehensive_valuation(
430            discount_rate=args.discount_rate,
431            terminal_growth=args.terminal_growth,
432            margin_of_safety=args.margin_of_safety
433        )
434 
435    # 输出
436    output_json = json.dumps(result, ensure_ascii=False, indent=2, default=str)
437 
438    if args.output:
439        with open(args.output, 'w', encoding='utf-8') as f:
440            f.write(output_json)
441        print(f"估值结果已保存到: {args.output}")
442    else:
443        print(output_json)
444 
445 
446if __name__ == "__main__":
447    main()
448