これで、次の課題に取り組む準備が整いました。点推定入力の一部を確率分布に置き換えることです。この時点までの手順は、Excelで同じモデルを作成する場合に比べてやや面倒に思えるかもしれませんが、次の数行で、Pythonがいかに強力であるかを垣間見ることができます。

最初のステップは、シミュレーションで実行する反復回数を決定することです。開始点として1,000を使用すると、適切な出力プロットを取得するのに十分なデータポイントを取得することと、適切な時間枠内でシミュレーションを終了することのバランスが取れます。次に、実際の分布を生成します。簡単にするために、ここでは3つの正規分布を生成しましたが、NumPyライブラリには多数の分布から選択でき、Python標準ライブラリなど他の場所もあります。使用する分布を決定したら、平均や標準偏差、望ましい結果の数など、形状を記述するために必要なパラメーターを指定する必要があります。

iterations = 1000
sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations)
ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations)
nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations)
plt.hist(sales_growth_dist, bins=20)
plt.show()

ここで、EBITDAは売上高から独立した別個の確率変数ではなく、ある程度売上高と相関しているべきであると主張することができます。私はこれに同意し、コスト構造（可変、半可変、固定コスト）のダイナミクスと主要なコスト要因（一部には独自の確率分布がある場合があります）をしっかりと理解することによって推進されるべきであると付け加えます。たとえば、入力商品の価格など）ですが、スペースと明確さのために、これらの複雑さはここでは脇に置いておきます。

分布とパラメーターの選択を通知する必要のあるデータが少なければ少ないほど、さまざまなデューデリジェンスワークストリームの結果と経験を組み合わせて、さまざまな可能性のあるシナリオに関するコンセンサスビューを形成する必要があります。この例では、キャッシュフロー予測では、主観的な要素が大きくなります。つまり、確率分布を視覚化することが重要になります。ここでは、2行の短いコードで、売上成長の分布を示す基本的な視覚化を取得できます。このようにして、チームの集合的な見解を最もよく反映する眼球への分布をすばやく表示できます。

これで、シミュレーションを実行するために必要なすべてのビルディングブロックができましたが、シミュレーションを実行するのに便利な形式ではありません。これまでに使用したものと同じコードを次に示しますが、すべてを1つのセルにまとめ、便宜上関数に再配置しました。

def run_mcs():
    
    # Create probability distributions
    sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations)
    ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations)
    nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations)
    
    # Calculate DCF value for each set of random inputs
    output_distribution = []
    for i in range(iterations):
        for year in range(1, 6):
            sales[year] = sales[year - 1] * (1 + sales_growth_dist[0])
        ebitda = sales * ebitda_margin_dist[i]
        depreciation = (sales * depr_percent)
        ebit = ebitda - depreciation
        nwc = sales * nwc_percent_dist[i]
        change_in_nwc = nwc.shift(1) - nwc 
        capex = -(sales * capex_percent)
        tax_payment = -ebit * tax_rate
        tax_payment = tax_payment.apply(lambda x: min(x, 0))
        free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc
        
        # DCF valuation
        terminal_value = (free_cash_flow[-1] * 1.02) / (cost_of_capital - 0.02)
        free_cash_flow[-1] += terminal_value
        discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)]
        dcf_value = sum(free_cash_flow[1:] * discount_factors )
        output_distribution.append(dcf_value)
    
    return output_distribution

これで、シミュレーション全体を実行し、出力分布をプロットできます。これは、次のコードを使用して、1,000回の反復ごとのこの会社の割引キャッシュフロー値になります。 %time コマンドはPythonコードではなく、何かを実行する時間を測定するノートブックの省略形です（代わりに、標準ライブラリのPython関数を使用できます）。実行するコンピューターによって異なりますが、このバージョンでは、1,000回の反復を実行して結果を視覚化するのに1〜2秒かかります。

%time plt.hist(run_mcs(), bins=20, color='r')
plt.show()

2。プロトタイプの改良

何かを単純化できるという疑念が潜んでいるのは、やりがいのある課題の世界で最も豊富な情報源です。 -エドガー・ダイクストラ

リファクタリングとは、既存のコードを書き直して、機能を変更せずに構造を改善するプロセスのことであり、コーディングの最も楽しくやりがいのある要素の1つです。これを行うにはいくつかの理由があります。次のような場合があります：

1. さまざまな部分をより賢明な方法で整理します。
2. 変数と関数の名前を変更して、目的と動作を明確にします。
3. 将来の機能を許可して準備します。
4. 実行速度、メモリフットプリント、またはその他のリソース使用率を改善します。

そのプロセスの1つのステップがどのように見えるかを示すために、プロトタイプスクリプトのように全体に散らばるのではなく、すべての初期変数を1つの場所に収集することで、ウォークスルーしたプロトタイプをクリーンアップし、次のプロセスを通じて実行速度を最適化しました。 ベクトル化 。

NumPy配列を使用すると、さまざまな種類のデータ処理タスクを、ループの記述が必要になる可能性のある簡潔な配列式として表現できます。明示的なループを配列式に置き換えるこの方法は、一般にベクトル化と呼ばれます。ウェス・マッキニー

見た目がすっきりとわかりやすくなりました：

# Key inputs from DCF model
years = 5
starting_sales = 31.0
capex_percent = depr_percent = 0.032
sales_growth = 0.1
ebitda_margin = 0.14
nwc_percent = 0.24
tax_rate = 0.25
# DCF assumptions
r = 0.12
g = 0.02
# For MCS model
iterations = 1000
sales_std_dev = 0.01
ebitda_std_dev = 0.02
nwc_std_dev = 0.01

def run_mcs():
    
    # Generate probability distributions
    sales_growth_dist = np.random.normal(loc=sales_growth, 
                                         scale=sales_std_dev, 
                                         size=(years, iterations))
    ebitda_margin_dist = np.random.normal(loc=ebitda_margin, 
                                          scale=ebitda_std_dev, 
                                          size=(years, iterations))
    nwc_percent_dist = np.random.normal(loc=nwc_percent, 
                                        scale=nwc_std_dev, 
                                        size=(years, iterations))
    
    # Calculate free cash flow
    sales_growth_dist += 1
    for i in range(1, len(sales_growth_dist)):
        sales_growth_dist[i] *= sales_growth_dist[i-1]
    sales = sales_growth_dist * starting_sales
    ebitda = sales * ebitda_margin_dist
    ebit = ebitda - (sales * depr_percent)
    tax = -(ebit * tax_rate)
    np.clip(tax, a_min=None, a_max=0)
    nwc = nwc_percent_dist * sales
    starting_nwc = starting_sales * nwc_percent
    prev_year_nwc = np.roll(nwc, 1, axis=0)
    prev_year_nwc[0] = starting_nwc
    delta_nwc = prev_year_nwc - nwc
    capex = -(sales * capex_percent)
    free_cash_flow = ebitda + tax + delta_nwc + capex
    # Discount cash flows to get DCF value
    terminal_value = free_cash_flow[-1] * (1 + g) / (r - g)
    discount_rates = [(1 / (1 + r)) ** i for i in range (1,6)]
    dcf_value = sum((free_cash_flow.T * discount_rates).T) 
    dcf_value += terminal_value * discount_rates[-1]
        
    return dcf_value

The main difference you will notice between this version and the previous one is the absence of the for i in range(iterations) loop. Using NumPy’s array operation, this version runs in 18 milliseconds compared to the 1.35 seconds for the prototype version - roughly 75x faster.

%time plt.hist(run_mcs(), bins=20, density=True, color="r")
plt.show()

I’m sure that further optimization is possible, since I put together both the prototype and refined version in a short time solely for the purpose of this tutorial.

Taking it Further

This tutorial showed some of the powerful features of Python, and if you were to develop this further the opportunities are almost endless. You could for example:

• Scrape or download relevant company or sector statistics from web pages or other data sources, to help inform your choice of assumptions and probability distributions.
• Use Python in quantitative finance applications, such as in an automated trading algorithm based on fundamental and/or macroeconomic factors.
• Build exporting capabilities that generate output in a spreadsheet and/or presentation format, to be used as part of your internal transaction review and approval process, or for external presentations.

I haven’t even touched upon what you could also do with the various web, data science, and machine learning applications that have contributed to Python’s success.

In Summary:A Useful Language for Your Financial Toolbox

This article gave an introduction to the Python programming language, listed some of the reasons why it has become so popular in finance and showed how to build a small Python script. In a step-by-step tutorial, I walked through how Python can be used for iterative prototyping, interactive financial analysis, and for application code for valuation models, algorithmic trading programs and more.

For me, at the end of the day, the killer feature of Python technology is that it is simply fun to work with! If you enjoy problem-solving, building things and making workflows more efficient, then I encourage you to try it out. I would love to hear what you have done with it or would like to do with it.

Recommended Resources for Finance Professionals to Learn Python

• O’Reilly books. I can especially recommend:
  • Python for Finance by Yves Hilpisch
  • Learning Python by Mark Lutz
  • Fluent Python by Luciano Ramalho
• The Python Quants
• PyCon talks on YouTube
• Udemy