<p>AI を活用したサービスでは、AI の呼び出し自体に数秒かかることが珍しくありません。それに加えて、AI を呼び出す前に、複数のデータソースから情報を集める必要がある場合がほとんどです。</p><p>例えば、社内の AI アシスタントがユーザーの技術的な質問に答えるためには、</p><ul><li>社内ドキュメントを全文検索（3秒）</li><li>ベクトルデータベースで類似検索（3秒）</li><li>社内チャットの過去ログを検索（3秒）</li><li>集めた情報を LLM に渡して回答生成（4秒）</li></ul><p>というように、時間のかかる処理を複数実行していかなくてはなりません。</p><p>これを<strong>ナイーブな実装</strong>で、そのまま1つずつ順に実行すると、合計13秒もかかってしまいます。どうにかならんでしょうか。</p><p>よく考えてみると、<strong>最初の3つの検索は互いに依存していないので、並行して実行できるはず</strong>です。ここに、<strong>非同期処理</strong>によるパフォーマンス改善の余地があります。</p><p>本記事では、Python の <code>asyncio</code> で非同期処理に入門し、AI を活用したサービスにおけるパフォーマンス改善の例を簡単にご紹介します。</p><p></p><h2 id="h0669eefa7c">目次</h2><ol><li>そもそも非同期処理とは？<ol><li>同期処理の世界</li><li>非同期処理の考え方</li></ol></li><li><code>asyncio</code> の基本概念<ol><li>コルーチン</li><li>await (待機)</li><li>イベントループ</li></ol></li><li><code>asyncio</code> のコードサンプル<ol><li>同期処理の問題</li><li><code>asyncio</code> による非同期処理化</li><li>コードの解説</li></ol></li><li><code>asyncio</code> でよくある間違い<ol><li><code>await</code> を付け忘れる</li><li>通常の関数内で <code>await</code> を使う</li></ol></li><li>まとめ</li></ol><h2 id="h9df9fe4a28">そもそも非同期処理とは？</h2><h3 id="hcee18f32e4">同期処理の世界</h3><p>通常のPythonコードは<strong>同期的</strong>に実行されます。つまり、1行ずつ順番に実行され、前の処理が完全に終わるまで次の処理は始まりません。</p><p>例えば、1秒かかる処理A、2秒かかる処理B、3秒かかる処理Cがあるとして、これらを同期的に実行すると…</p><pre><code class="language-python"># 同期処理のイメージ
処理A  # まずは1秒待つ
処理B  # 続いて2秒待つ
処理C  # さらに3秒待つ
# 合計6秒</code></pre><p>このように、 <code>1 + 2 + 3</code> で合計6秒かかります。</p><h3 id="h147988a23c">非同期処理の考え方</h3><p>非同期処理とは、ある処理の完了を待たずに次の処理を開始するような仕組みのことをいいます。</p><p>従来の同期処理では、データベースへのアクセスやAPIの呼び出しなど、時間のかかるI/O処理の間、プログラムは何もせずに待機しています。この待ち時間は<strong>「ブロッキング」</strong>と呼ばれ、CPUは有効活用されていません。</p><p><strong>非同期処理では、I/O処理の完了を待っている間に、他の処理を進めることができます。</strong>例えば、3つのAPIを呼び出す必要がある場合、1つ目のAPIの応答を待っている間に、2つ目、3つ目のAPIへのリクエストを送信できます。これにより、全体の処理時間を大幅に短縮できます。</p><p>同期処理と非同期処理の違いは、パン屋さんで例えてみるとわかりやすいです。</p><p>同期処理の店員は、クロワッサンをオーブンに入れて、焼きあがるまでの15分間ずっとオーブンの前で立ち尽くします。雇用主は解雇を検討するかもしれません。</p><p>一方、非同期処理の店員は、クロワッサンをオーブンに入れたら、すぐにメロンパンとカレーパンの準備を始め、タイマーがなったらクロワッサンを取り出す動きをします。</p><figure><img src="https://images.microcms-assets.io/assets/145b371faece4417bfaf63302a2f6c77/bc2048ec50fa4df5a65a0105a6af1794/%E3%82%B9%E3%82%AF%E3%83%AA%E3%83%BC%E3%83%B3%E3%82%B7%E3%83%A7%E3%83%83%E3%83%88%202025-05-26%2022.26.45.png" alt="" width="769" height="755"><figcaption>非同期処理をパン屋で例える</figcaption></figure><p>このように非同期処理では、ある処理が「待ち」に入ったら、その間に他の処理を進めることができます。</p><pre><code class="language-python"># 非同期処理のイメージ
処理A開始  # 完了を待たず次へ
処理B開始  # 完了を待たず次へ
処理C開始  # 完了を待たず次へ

# 3つの処理が並行で実行されている
A, B, C 全ての完了を待つ # 最も重い処理Cと同じくらいの時間（3秒）で全て完了</code></pre><h2 id="h720bbe71bd"><code>asyncio</code> の基本概念</h2><p>それでは、Python で非同期処理を実装するために、<code>asyncio</code> を学んでいきましょう。</p><p>まずは基本的な概念を整理します。</p><h3 id="he373776bdb">1. コルーチン</h3><p><code>async def</code>で定義された関数は<strong>コルーチン関数</strong>と呼ばれます。通常の関数と違い、実行を一時停止・再開できる特殊な関数です。</p><pre><code class="language-python"># 通常の関数
def normal_function():
    return &quot;結果&quot;

# コルーチン関数
async def coroutine_function():
    return &quot;結果&quot;</code></pre><p>重要な点は、コルーチン関数を呼び出すと、すぐに実行されるのではなく<strong>コルーチンオブジェクト</strong>が返されることです。</p><pre><code class="language-python"># 通常の関数：呼び出すと即座に実行され、結果が返る
result = normal_function()# &quot;結果&quot;# コルーチン関数：呼び出すとコルーチンオブジェクトが返る（まだ実行されない）
coro = coroutine_function()# &lt;coroutine object coroutine_function at 0x...&gt;# コルーチンオブジェクトを実行するにはawaitが必要
result = await coro# &quot;結果&quot;</code></pre><h3 id="hbe1db43b10">2. await（待機）</h3><p><code>await</code>は2つの役割を持ちます：</p><ol><li>コルーチンオブジェクトを実際に実行する</li><li>I/O処理の間、他の処理に実行を譲る</li></ol><pre><code class="language-python">async def fetch_data():
# awaitでコルーチンオブジェクトを実行し、# I/O待機中は他の処理に実行を譲る
    result = await some_io_operation()
    return result</code></pre><p><code>await</code>は<strong>「ここで一時停止して、他の処理に順番を譲ってもいいよ」</strong>という印です。I/O処理（ネットワーク通信、ファイル読み書きなど）の前に付けます。</p><h3 id="h64247b2d0d">3. イベントループ</h3><p><code>asyncio</code> の心臓部です。どのコルーチンを実行するか管理し、<strong>I/O待機中のコルーチンと実行可能なコルーチンを切り替えます</strong>。通常は<code>asyncio.run()</code>が自動的にイベントループを作成・管理します。</p><h2 id="hc7888a8ddd">同期処理の問題</h2><p>まず、同期的な（ナイーブな）コードを見てみましょう。</p><p>冒頭での例を簡単なコードで表しました。AIアシスタントの質問に13秒かかるケースです。</p><pre><code class="language-python">import time

def search_documents(query):
    print(&quot;社内ドキュメントを検索中...&quot;)
    time.sleep(3.0)  # 数TB規模のドキュメントから全文検索
    return &quot;関連ドキュメント: API設計ガイドライン、エラーハンドリング規約&quot;

def search_vectors(query):
    print(&quot;ベクトルDBで類似検索中...&quot;)
    time.sleep(3.0)  # 数百万件のベクトルから意味的に類似した文書を検索
    return &quot;類似コンテンツ: 過去のトラブルシューティング事例&quot;

def search_chat_logs(query):
    print(&quot;社内チャットログを検索中...&quot;)
    time.sleep(3.0)  # 大量のメッセージ履歴から関連する議論を抽出
    return &quot;チャット履歴: 開発チームでの解決策の議論&quot;

def generate_answer(query, context):
    print(&quot;LLMで回答を生成中...&quot;)
    time.sleep(4.0)  # 詳細で正確な回答の生成
    return f&quot;回答: {query}について、{context}を基に説明します&quot;

# ユーザーの質問を処理
start = time.time()
query = &quot;APIのレート制限エラーの解決方法を教えて&quot;

# 順番に情報を収集
doc = search_documents(query)
similar = search_vectors(query)
chat = search_chat_logs(query)

# 収集した情報を結合
context = f&quot;{doc}, {similar}, {chat}&quot;

# LLMで回答生成
answer = generate_answer(query, context)

print(f&quot;\\n{answer}&quot;)
print(f&quot;処理時間: {time.time() - start:.1f}秒&quot;)
# 出力: 処理時間: 13.0秒</code></pre><h2 id="h8a136577ee"><code>asyncio</code> による非同期処理化</h2><p>同じ処理を <code>asyncio</code> を用いて、非同期処理に書き直してみましょう。</p><pre><code class="language-python">import asyncio
import time

# async defでコルーチンを定義
async def search_documents_async(query):
    print(&quot;社内ドキュメントを検索中...&quot;)
    # awaitで非同期的に待機（この間、他の処理が実行可能）
    await asyncio.sleep(3.0)
    return &quot;関連ドキュメント: API設計ガイドライン、エラーハンドリング規約&quot;

async def search_vectors_async(query):
    print(&quot;ベクトルDBで類似検索中...&quot;)
    await asyncio.sleep(3.0)
    return &quot;類似コンテンツ: 過去のトラブルシューティング事例&quot;

async def search_chat_logs_async(query):
    print(&quot;社内チャットログを検索中...&quot;)
    await asyncio.sleep(3.0)
    return &quot;チャット履歴: 開発チームでの解決策の議論&quot;

async def generate_answer_async(query, context):
    print(&quot;LLMで回答を生成中...&quot;)
    await asyncio.sleep(4.0)
    return f&quot;回答: {query}について、{context}を基に説明します&quot;

async def process_query(query):
    start = time.time()

    # asyncio.gather()で複数のコルーチンを並行して実行
    # 3つの検索が並行に実行される
    doc, similar, chat = await asyncio.gather(
        search_documents_async(query),
        search_vectors_async(query),
        search_chat_logs_async(query)
    )

    # 収集した情報を結合
    context = f&quot;{doc}, {similar}, {chat}&quot;

    # LLMで回答生成（これは前の処理が終わってから実行）
    answer = await generate_answer_async(query, context)

    print(f&quot;\\n{answer}&quot;)
    print(f&quot;処理時間: {time.time() - start:.1f}秒&quot;)

    return answer

# asyncio.run()でイベントループを起動し、コルーチンを実行
query = &quot;APIのレート制限エラーの解決方法を教えて&quot;
asyncio.run(process_query(query))
# 出力: 処理時間: 7.0秒</code></pre><p><strong>処理時間が13秒から7秒に短縮されました！</strong>ほぼ半分の時間で処理が完了します。</p><h3 id="hb3e4ba189d">コードサンプルの解説</h3><p>ざっくり、下図のような挙動をしています。</p><figure><img src="https://images.microcms-assets.io/assets/145b371faece4417bfaf63302a2f6c77/8d53036e87b1437bbebed4a36da16b1e/%E3%82%B9%E3%82%AF%E3%83%AA%E3%83%BC%E3%83%B3%E3%82%B7%E3%83%A7%E3%83%83%E3%83%88%202025-05-26%2022.20.05.png" alt="" width="769" height="976"><figcaption>非同期処理化</figcaption></figure><p>重要な部分のコードをそれぞれ確認していきましょう。</p><h4 id="h71e4735725">1. <code>async def</code> - コルーチンの定義</h4><pre><code class="language-python">async def search_documents_async(query):
    # この関数はコルーチン
    await asyncio.sleep(3.0)
    return &quot;結果&quot;</code></pre><p><code>async def</code>で定義された関数は、呼び出しただけでは実行されません。コルーチンオブジェクトを返します。</p><h4 id="h9eecbafd02">2. <code>await</code> - 非同期的な待機</h4><pre><code class="language-python">await asyncio.sleep(3.0)  # 3秒間、他の処理に実行を譲る</code></pre><p><code>await</code>があると、その処理が完了するまで一時停止し、イベントループは他のコルーチンを実行できます。</p><h4 id="hfa62ef61c1">3. <code>asyncio.gather()</code> - 複数のコルーチンを並行して実行</h4><pre><code class="language-python">doc, similar, chat = await asyncio.gather(
    search_documents_async(query),
    search_vectors_async(query),
    search_chat_logs_async(query)
)</code></pre><p><code>asyncio.gather()</code>は複数のコルーチンを受け取り、それらを並行に実行します。全てが完了すると、結果をタプルで返します。</p><h4 id="h2a30e88fd9">4. <code>asyncio.run()</code> - エントリーポイント</h4><pre><code class="language-python">asyncio.run(process_query(query))</code></pre><p>これがプログラムのエントリーポイントです。イベントループを作成し、指定されたコルーチンを実行し、完了したらイベントループを閉じます。</p><h2 id="hdc5403ccbe">実行の流れ</h2><ol><li><code>asyncio.run()</code>がイベントループを起動</li><li><code>process_query()</code>が実行開始</li><li><code>asyncio.gather()</code>で3つの検索が並行してスタート</li><li>各検索が<code>await asyncio.sleep(3.0)</code>に到達すると、イベントループは他の検索に処理を切り替える</li><li>約3秒後、全ての検索が完了</li><li>LLMの処理を実行（4秒）</li><li>結果を返して終了</li></ol><h2 id="he2df006bfc"><code>asyncio</code> でよくある間違い</h2><h3 id="he331f6ffdd"><code>await</code> を付け忘れる</h3><pre><code class="language-python"># 間違い
async def main():
    result = search_documents_async(&quot;test&quot;)  # awaitがない！
    print(result)  # &lt;coroutine object ...&gt; が表示される

# 正しい
async def main():
    result = await search_documents_async(&quot;test&quot;)
    print(result)  # &quot;関連ドキュメント: API設計ガイドライン...&quot; が表示される

</code></pre><h3 id="h573ef61603">通常の関数内で <code>await</code> を使う</h3><pre><code class="language-python"># エラー：通常の関数内でawaitは使えない
def normal_function():
    result = await some_async_function()  # SyntaxError!

# 正しい：async関数内でのみawaitが使える
async def async_function():
    result = await some_async_function()  # OK

</code></pre><h2 id="ha214098e44">まとめ</h2><p><code>asyncio</code> を使うことで、1つのリクエスト内で発生する複数のI/O処理を効率化できます。</p><p>覚えるべきことは4つだけ！</p><ol><li><code>async def</code>でコルーチン（非同期関数）を定義</li><li><code>await</code>でI/O処理を非同期的に待機</li><li><code>asyncio.gather()</code>で複数のコルーチンを並行して実行</li><li><code>asyncio.run()</code>でイベントループを起動</li></ol><p>特にRAGシステムのように、複数のデータソースから情報を集めて LLM に渡すようなアプリケーションでは、<code>asyncio</code> による非同期処理化が必須の技術となります。実際、LLM を活用したサービスの API コードサンプルを確認すると <code>asyncio</code>を併用しているケースが少なからず見受けられます。</p><p></p><p>＼ 宣伝 ／</p><p>株式会社Biz Freak は、AI の社会実装を積極的に推し進めながら、<strong>新規事業に特化した伴走型アジャイル開発サービス</strong>『バクソク』を展開しています。</p><p><a href="https://prtimes.jp/main/html/rd/p/000000015.000139584.html" target="_blank" rel="noopener noreferrer">👉 【特許取得のお知らせ】アジャイル開発を支援する “ストーリーポイント自動推定AI”</a></p>

プログラミング

近年、AI の社会実装が急激に進む中、AI 呼び出しに伴う「I/O バウンドな処理」は避けられません。これらの「待機時間」をただ眠らせるのではなく有効活用することが、AI を活用したサービスのパフォーマンス改善の鍵となります。本記事では Python の asyncio に入門し、AI を活用したサービスを非同期処理によってどのように効率化できるのか、簡単に解説します。

【Python】非同期処理で支える AI の社会実装 | asyncio 入門

<p>こんにちは！</p><p>Biz Freakでバックエンド開発をしているエンジニアのTNと申します。</p><p>早速、私事で申し訳ないですが、最近異動がありました。</p><p>そして、今までBiz Freakでブログを書いてきているエンジニアのメンバーと</p><p>同じプロジェクトにアサインされることとなりました！（かなり嬉しいです）</p><p>直近までTypeScript、Node.jsあたりを使って開発をしていましたが、</p><p>ガラッと環境が変わってPythonをメインに扱うようになり、Pythonでバックエンド開発をしています。</p><p>私のエンジニアの始まりはPythonだったので、故郷に帰ったような気分です。笑</p><p>そして、水面下でBubbleでのキャッチアップも進めています！</p><p>ローコードのスキルも身につけて、エンジニアとしてPlus Ultraしていきますよー！</p><p></p><h2 id="h8d027c8ed3">はじめに</h2><p>てなわけで、勝手にシリーズ化させている「元インフラ系の人と学ぶシリーズ」ですが、</p><p>前回の第一回「<strong>元インフラ系の人と学ぶオブジェクト指向</strong>」では、</p><p>オブジェクト指向プログラミングについて説明させていただきました。</p><p>人によっては内容的に結構難しかったかもしれませんが、</p><p>今回は難易度がグッと下がった内容になると思います。</p><p>プログラミングには様々なスタイル（パラダイム）がありますが、</p><p>その中でも今回お話をする手続き型プログラミングは、命令を順番に実行していく最も基本的なスタイルです。</p><p>そのため、大体の方はこのプログラミングの手法から始める方が多いのではないかと。</p><p>では、今回も学んでいきましょう！</p><p></p><h2 id="h3121aa391d">手続き型プログラミングとは？</h2><p>手続き型プログラミングは、プログラムを「手続き」（procedure）の集まりとして記述するプログラミングパラダイムです。手続きとは、一連の命令をまとめたもので、プログラムはこれらの手続きを順番に実行することで目的を達成します。</p><p>Pythonでは、以下のように関数を定義し、それを呼び出すことで手続き型プログラミングを実現します。</p><div data-filename="greet.py"><pre><code class="language-python">def greet(name): 
    &quot;&quot;&quot;挨拶を表示する関数&quot;&quot;&quot; 
    print(f&quot;こんにちは、{name}さん！&quot;) 

def main(): 
    &quot;&quot;&quot;メイン関数&quot;&quot;&quot;
    greet(&quot;太郎&quot;) 
    greet(&quot;花子&quot;) 

if __name__ == &quot;__main__&quot;: 
    main()</code></pre></div><p>この例では、 <code>greet</code> 関数が挨拶を表示する手続き、 <code>main</code> 関数がプログラム全体の流れを制御する手続きとなっています。</p><p></p><h3 id="hbdb2d78603">OpenAIライブラリでの例</h3><p>OpenAIライブラリを使って、文章生成を行う例を見てみましょう。</p><div data-filename="call_openai.py"><pre><code class="language-python">import openai

openai.api_key = &quot;YOUR_API_KEY&quot; # 自身のAPIキーを設定

def generate_text(prompt):
  &quot;&quot;&quot;文章生成を行う関数&quot;&quot;&quot;
  response = openai.Completion.create(
      engine=&quot;text-davinci-003&quot;,
      prompt=prompt,
      max_tokens=100
  )
  return response.choices[0].text.strip()

def main():
  &quot;&quot;&quot;メイン関数&quot;&quot;&quot;
  prompt = &quot;Pythonでプログラミングをするメリットは？&quot;
  generated_text = generate_text(prompt)
  print(generated_text)

if __name__ == &quot;__main__&quot;:
  main()</code></pre></div><p>この例では、 <code>generate_text</code> 関数がOpenAIのAPIを呼び出して文章生成を行う手続き、 <code>main</code> 関数がプロンプトを設定し、生成された文章を表示する手続きとなっています。</p><h3 id="h3241a338b8">手続き型プログラミングのメリット</h3><ul><li><strong>実装が容易</strong>: シンプルな問題であれば、比較的簡単に実装できる。</li><li><strong>逐次デバッグが容易</strong>: 命令が順番に実行されるため、プログラムの動作を追いやすい。</li><li><strong>最適化が効きやすい</strong>: CPUでで実行されるコードが手続き型を前提としていることが多く、コンパイラによる最適化が効きやすい</li></ul><h3 id="hfbeeba7eed">手続き型プログラミングのデメリット</h3><ul><li><strong>大規模開発には不向き</strong>: プログラムが複雑になると、コードの見通しが悪くなり、保守が難しくなる。</li><li><strong>再利用性が低い</strong>: 処理が特定のコンテキストに依存しやすく、他の場所で再利用しにくい。</li><li><strong>並列処理が難しい</strong>: 状態の変化を伴うため、並列処理が難しい場合がある。</li></ul><h3 id="h10d3571a04">関数型プログラミングとの違い</h3><p>手続き型プログラミングが命令の実行順序を重視するのに対し、関数型プログラミングは関数の組み合わせによってプログラムを構築します。</p><ul><li><strong>状態の変化</strong>: 手続き型プログラミングは状態の変化（変数の値の変更など）を伴いますが、関数型プログラミングは基本的に状態の変化を許容しません。</li><li><strong>副作用</strong>: 手続き型プログラミングは副作用（関数外の状態への影響）を伴うことがありますが、関数型プログラミングは副作用を局所化し、状態を変更するようなコードがどこなのか分かりやすくします。</li><li><strong>データの扱い</strong>: 手続き型プログラミングはデータを変更可能なものとして扱いますが、関数型プログラミングはデータを変更不能なものとして扱います。</li></ul><h3 id="hb6cc095485">宣言型プログラミングとの違い</h3><p>手続き型プログラミングは、どのように問題を解決するかという「解法」を記述するのに対し、宣言型プログラミングは、何を解決したいかという「問題の定義」を記述します。</p><ul><li><strong>解法 vs 定義</strong>: 手続き型は「問題を解くための手順」を記述し、宣言型は「解決したい問題そのもの」を記述します。</li><li><strong>制御フロー vs 事実</strong>: 手続き型は命令の実行順序（制御フロー）を重視しますが、宣言型は順序や条件分岐のない事実の記述を重視します。</li><li><strong>可読性</strong>: 宣言型は事実を宣言的に記述するため、コードが読みやすくなる傾向があります。一方、手続き型は状態や制御フローを追う必要があるため、複雑になると可読性が低下する可能性があります。</li></ul><h3 id="h0c65a18d6d">手続き型言語における宣言的アプローチ</h3><p>手続き型言語でも、部分的に宣言型の利点を取り入れることができます。</p><ul><li><strong>アノテーション</strong>: コードにメタデータを付与し、宣言的な情報を追加します。</li><li><strong>DSL (Domain Specific Language)</strong>: 特定の領域に特化した言語を作成し、宣言的な記述を可能にします。<ul><li>データベース操作言語である <strong>SQL</strong> や、IaCツールとして有名なTerraform用の記述言語である <strong>HCL </strong>もDSLの一種です。</li></ul></li></ul><p>手続き型プログラミングと宣言型プログラミングは、それぞれ異なる特性を持つプログラミングパラダイムです。問題の性質や開発の規模に応じて、適切なパラダイムを選択することが重要です。</p><p></p><p>プログラミングの学習を始めたばかりの方は、まずは手続き型プログラミングから始めて、</p><p>徐々に他のパラダイムも学んでいくことをお勧めします！</p><p></p><p>最後に…</p><p>私たちのチームでは、業界最高のスピード感で新規事業開発に携わることができ、</p><p>テクノロジーの力で圧倒的な成長を実感することができます。</p><p>株式会社Biz Freakで一緒に成長したい方は、ぜひ以下のリンクからご応募ください。</p><p>チーム一同、あなたと一緒に未来を創ることを楽しみにしています！</p><p>👉 <a href="https://bizfreak.co.jp/recruit">https://bizfreak.co.jp/recruit</a></p><p></p><p></p>

手続き型プログラミングの概要と、関数型・宣言型のアプローチとの違いを説明します

【プログラミング基礎】元インフラ系の人と学ぶ手続き型プログラミング

Node.jsとは何かを初心者にもわかりやすく解説！JavaScriptをサーバーサイドで実行できる環境として人気な Node.js の特徴や内部の仕組み、得意・不得意な分野までを徹底紹介。JavaScript やJavaとの違いについても整理します。

【Node.js 入門 #1】 Node.js とは？ JavaScript をサーバーサイドで実行しよう！

Pydanticでデータバリデーションを行い、アプリケーションの外とデータを安全にやり取りしよう

【Python #2】はじめてのPydantic

<p>はじめまして！</p><p>Biz Freakで主にBubbleを使った開発の方々とは別の事業で</p><p>バックエンド開発をしているエンジニアのTNと申します。</p><p><br></p><p>Biz FreakはBubbleとAIのイメージが強い方が多いかと思いますが、</p><p>私たちのような従来の開発を行っているエンジニアのメンバーも存在します！<br><br></p><p>弊社では「コードを書く」際でもAIの使用を推奨しており、</p><p>私たちのような従来のイメージのエンジニアでも日常的にAIを使いながら開発を行えている点や、</p><p>社内ツールが充実しているおかげでスムーズ且つバクソクで開発できる環境が整っています！<br><br></p><p>話は変わりますが、私自身のことを軽く自己紹介させていただきますと・・・</p><p>元々は広告代理店で働いていていましたが、少し転機がありIT業界へ突入。</p><p>最初はインフラ系のエンジニアでした。<br><br></p><p>興味本位で html やら Python で開発に触れ始め、開発そのものに魅入られてしまいました。<br><br></p><p>そして、開発を仕事にできるように色々と行動していたら、</p><p>バックエンドのエンジニアとなり、現在に至ります！<br><br></p><p>この記事を読んでいるあなたも何かに対してFreakできるようなものがあれば、</p><p>もしかしたら、弊社で最高のパフォーマンスを発揮できるかもしれません！<br><br></p><p>どの領域のエンジニアの方も問わず、です！<br></p><h2 id="h0669eefa7c">目次</h2><p>■ はじめに</p><p>■ オブジェクト指向の主要な概念</p><ul><li>クラス</li><li>オブジェクト</li><li>継承</li><li>ポリモーフィズム</li><li>カプセル化</li><li>Pythonでの実装例</li><li>手続き型と関数型でOOPのコードを比較</li></ul><p>■ ここが謎だよ、OOPくん</p><ul><li>インスタンス</li><li>ポリモーフィズム：オーバーライド</li><li>カプセル化</li></ul><p>■ おわりのご挨拶</p><p></p><h2 id="h8d027c8ed3">はじめに</h2><p>さて、記事の冒頭で私の簡単な経歴をお伝えしましたが、</p><p>元々はインフラ系のエンジニアということをお伝えしました。<br><br></p><p>なので正直、まだまだ知識量も足りてないことを実感していますし、</p><p>今でもコマンドライン上でコマンドを打ち込んでいる方が得意だったりします。笑<br><br></p><p>そんな私が開発をするにあたって理解するのに苦労した</p><p>オブジェクト指向プログラミングについてお話しようと思います。<br><br></p><p>そもそも、オブジェクト指向プログラミング（OOP）は、</p><p>データとそのデータを操作するメソッド（関数）を「オブジェクト」としてまとめ、</p><p>それらのオブジェクト同士の関係性を考慮しながらプログラムを設計する手法です。<br><br></p><p>私が興味本位でプログラミングを始めた際に触れたPythonは、</p><p>マルチパラダイムの言語でオブジェクト指向的な書き方の出来る言語のひとつです。<br><br></p><p>そのPythonのクラスとオブジェクトを使ってOOPの概念を実装することができます。<br><br></p><p>今回の記事では簡潔にオブジェクト指向の主要な概念のご説明と</p><p>簡単なPythonのコードを用いて解説していこうと思います。<br><br></p><h2 id="h1e6fdeff95">オブジェクト指向の主要な概念</h2><h3 id="hdf56d6fc76">クラス（Class）</h3><p>クラスは、オブジェクトの設計図のようなものです。</p><p>クラスを定義することで、オブジェクトの属性を指定できます。</p><p>「属性」はオブジェクトに関連付けられたデータや処理（メソッド）を表します。<br><br></p><h3 id="h63dc910172">オブジェクト（Object）</h3><p>オブジェクトは、クラスから生成されたインスタンスです。</p><p>実際に使われるデータを持ち、クラスで定義されたメソッドを使って操作します。<br><br></p><h3 id="h41f09d921f">継承（Inheritance）</h3><p>あるクラスが他のクラスの属性を引き継ぐことです。</p><p>再利用性を高め、新しいクラスを効率的に作ることができます。<br><br></p><h3 id="hf0733c11ea">ポリモーフィズム（Polymorphism）</h3><p>同じ名前のメソッドが異なるクラスで異なる動作をすることです。</p><p>オーバーライドという概念を含みます。</p><p>※ オーバーライドの詳細は後述にて<br><br></p><h3 id="heb0745ac07">カプセル化（Encapsulation）</h3><p>属性を直接アクセスできないようにします。</p><p>クラスの外部からはメソッドを通してのみデータにアクセスできます。</p><p>※ カプセル化の詳細も後述にて<br><br></p><h3 id="h5c5e4351cd">Pythonでの実装例</h3><pre><code class="language-python"># クラスの定義
class Animal:
    # コンストラクタ（インスタンス生成時に呼び出されるメソッド）
    def __init__(self, name):
        self.name = name  # インスタンス変数の定義

    # メソッドの定義
    def speak(self):
        return f&quot;{self.name} makes a sound&quot;  # 基本的な音を返す

# クラスの継承
class Dog(Animal):
    def speak(self):
        return super().speak() + &quot; - Woof!&quot;

class Cat(Animal):
    def speak(self):
        return super().speak() + &quot; - Meow!&quot;

# オブジェクトの生成
animal = Animal(&quot;Generic Animal&quot;)
dog = Dog(&quot;Rex&quot;)
cat = Cat(&quot;Whiskers&quot;)

# メソッドの呼び出し
print(dog.speak())     # Rex makes a sound - Woof!
print(cat.speak())     # Whiskers makes a sound - Meow!
</code></pre><h4 id="hcf83e1357e"></h4><p>Animal クラスは基底クラスで、speak メソッドを持っていますが、</p><p>このメソッドはサブクラスでオーバーライドされることを前提としています。<br><br></p><p>Dog と Cat は Animal クラスを継承し、それぞれの speak メソッドをオーバーライドしています。</p><p>dog と cat はそれぞれ Dog クラスと Cat クラスのオブジェクトで、メソッドを使って動作を示します。</p><p>この例では、継承とポリモーフィズムの概念が使用されています。<br><br></p><h3 id="h87ce1efa49">手続き型と関数型でOOPのコードを比較</h3><p>先ほどのコードの例を「手続き型」と「関数型」という手法を使って表現しようと思います。</p><p>ぜひ、見比べてみてください！</p><pre><code class="language-python"># 手続き型プログラミング
def create_animal(name, animal_type):
    return {&quot;name&quot;: name, &quot;type&quot;: animal_type}

def animal_speak(animal):
    if animal[&quot;type&quot;] == &quot;dog&quot;:
        return f&quot;{animal[&apos;name&apos;]} says Woof!&quot;
    elif animal[&quot;type&quot;] == &quot;cat&quot;:
        return f&quot;{animal[&apos;name&apos;]} says Meow!&quot;
    else:
        return &quot;Unknown animal&quot;

dog = create_animal(&quot;Rex&quot;, &quot;dog&quot;)
cat = create_animal(&quot;Whiskers&quot;, &quot;cat&quot;)

print(animal_speak(dog))  # Rex says Woof!
print(animal_speak(cat))  # Whiskers says Meow!


# 関数型プログラミング
def dog_speak(name):
    return f&quot;{name} says Woof!&quot;

def cat_speak(name):
    return f&quot;{name} says Meow!&quot;

def create_animal(name, speak_func):
    return lambda: speak_func(name)

dog = create_animal(&quot;Rex&quot;, dog_speak)
cat = create_animal(&quot;Whiskers&quot;, cat_speak)

print(dog())  # Rex says Woof!
print(cat())  # Whiskers says Meow!</code></pre><p>今回の記事はOOPについてのお話なので、説明については割愛させていただきます。</p><p>なんとなく「こんなに違うんだ」というのを感じ取っていただければ、と。</p><p></p><p>もし、私の記事がシリーズ化するのであれば、次回は上記二つのどれかのご説明をするかもしれません。</p><p>乞うご期待！笑</p><p></p><h2 id="h4d09b0d647">ここが謎だよ、OOPくん</h2><p>さてさて、ここまでさらっとOOPの説明をしましたが、</p><p>私が実際にOOPに触れた際に理解するのに苦労した概念がいくつかあります。<br><br></p><p>それが主に以下の3つです。</p><ul><li>インスタンス</li><li>ポリモーフィズム</li><li>カプセル化</li></ul><p>私自身そんなに賢くないので、座学だけで理解することができませんでした。。。<br><br></p><p>しかも、関数であれば呼び出すだけで一発で処理を動かすことができるのに、</p><p>OOPだと回りくどいことを最初にしなければならないのが、</p><p>私にとってはすごくとっつきにくく感じました。<br><br></p><p>若干偏見ではありますが、今まで関数を使ったプログラミングがメインだった方は、</p><p>もしかしたら私と同様の壁に当たった経験があるかもしれません。</p><p>これから前述の3つの概念を簡単なコードを用いて解説していきます。<br><br></p><h3 id="h1365540baa">インスタンス（Instance）</h3><p>インスタンスは、クラス（オブジェクトの設計図）から生成された具体的なオブジェクトのことです。</p><p>クラスは設計図にすぎませんが、その設計図に基づいて実体を作ることが<strong>インスタンス化</strong>と呼ばれます。</p><pre><code class="language-python">class Dog:
    def __init__(self, name):
        self.name = name

# Dogクラスのインスタンス生成
my_dog = Dog(&quot;Rex&quot;)
</code></pre><p>ここで my_dog は Dog クラスのインスタンスです。</p><p>Dog という設計図から具体的なオブジェクト（Rex という名前の1匹の犬）を作ったことになります。<br><br></p><h3 id="h1bab8d23dc">ポリモーフィズム：オーバーライド（Override）</h3><p>オーバーライドとは、親クラス（基底クラス）で定義されたメソッドを、</p><p>子クラスで再定義し、異なる動作に置き換えることです。<br><br></p><p>親クラスの機能を上書きして、子クラス固有の振る舞いを提供します。</p><pre><code class="language-python">class Animal:
    def speak(self):
        return &quot;Some sound&quot;

class Dog(Animal):
    # 親クラスの speak メソッドをオーバーライド
    def speak(self):
        return &quot;Woof!&quot;

dog = Dog()
print(dog.speak())  # Woof!
</code></pre><p>この例では、Dog クラスで Animal クラスの speak メソッドをオーバーライドして、Dog クラス独自の動作に変更しています。<br></p><h3 id="heb0745ac07">カプセル化（Encapsulation）</h3><p>クラスの属性に対しグルーピングを行い、外部からの直接アクセスを制限することができます。<br></p><p></p><p>クラスの外部からは、明示的に公開されたインターフェース（通常はパブリックメソッド）を通してのみ属性にアクセスできます。<br></p><p></p><p>これにより、クラスの内部実装を変更しても、外部のコードに影響を与えにくくなります。<br><br></p><p>Pythonでは、変数名やメソッド名の先頭にアンダースコア（ _ ）</p><p>またはダブルアンダースコア（ __ ）をつけることでカプセル化を実現できます。</p><pre><code class="language-python">class Person:
    def __init__(self, name, age):
        self.name = name      # パブリック属性
        self.__age = age      # プライベート属性
        self.__id = self.__generate_id()  # プライベート属性

    # パブリックメソッド
    def get_age(self):
        return self.__age

    def set_age(self, age):
        if self.__validate_age(age):
            self.__age = age

    def get_id(self):
        return self.__id

    # プライベートメソッド（慣習的に名前の前に__を付ける）
    def __validate_age(self, age):
        return age &gt; 0 and age &lt; 120

    def __generate_id(self):
        # 実際のIDジェネレータロジックはここに実装
        return &quot;ID-&quot; + str(id(self))

# インスタンスの生成
person = Person(&quot;Alice&quot;, 30)

# パブリック属性にアクセス
print(person.name)  # Alice

# プライベート属性に直接アクセスはできない（ただし、完全に不可能ではない）
# print(person.__age)  # AttributeError

# パブリックメソッドを通してアクセス
print(person.get_age())  # 30
person.set_age(35)
print(person.get_age())  # 35

# プライベートメソッドは直接呼び出せない（ただし、完全に不可能ではない）
# print(person.__validate_age(25))  # AttributeError

# IDの取得（プライベートメソッドで生成されたが、パブリックメソッドで取得可能）
print(person.get_id())  # ID-140712837567776 (実際の値は異なる場合があります)

# Pythonの名前修飾（name mangling）を使用して、プライベートメンバにアクセスすることも可能
# これは通常推奨されませんが、場合によっては必要になることがあります
print(person._Person__age)  # 35
print(person._Person__validate_age(25))  # True</code></pre><p>このコードでは、以下のようにデータとメソッドのカプセル化を実装しています。</p><ol><li>データ（属性）のカプセル化<ul><li><code>self.__age</code>と<code>self.__id</code>はプライベート属性として定義されています。</li><li>これらの属性には直接アクセスできず、メソッド（<code>get_age()</code>, <code>get_id()</code>）を通してアクセスします。</li><li><code>set_age()</code>メソッドは、値の検証を行ってから<code>__age</code>を更新します。<br></li></ul></li><li>メソッドのカプセル化<ul><li><code>__validate_age()</code>と<code>__generate_id()</code>はプライベートメソッドとして定義されています。</li><li>これらのメソッドはクラス内部でのみ使用され、外部からは直接呼び出せません。</li><li><code>__validate_age()</code>は<code>set_age()</code>内で使用され、年齢の妥当性をチェックします。</li><li><code>__generate_id()</code>は<code>__init__()</code>内で使用され、IDを生成します。<br></li></ul></li><li>パブリックインターフェース<p><code>name</code>属性、<code>get_age()</code>, <code>set_age()</code>, <code>get_id()</code>メソッドは公開されており、クラスの外部から安全にアクセスできます。<br></p></li></ol><p><strong>注意点</strong></p><p>Pythonでは、真の意味での「隠蔽」は存在しません。</p><p>名前の前に<code>__</code>を付けることで、名前修飾（name mangling）が行われますが、それでも完全に隠蔽されるわけではありません。</p><p>例えば、別の言語だとprivateやprotectedを頭につければ隠蔽を行うことができますが、Pythonにはその機能がないのです。<br></p><h3 id="hf4abe01e80">インスタンス、ポリモーフィズム、カプセル化についてまとめ</h3><ul><li>インスタンスはクラスから生成されたオブジェクト</li><li>オーバーライドは親クラスのメソッドを子クラスで上書きすること</li><li>カプセル化はオブジェクト内部の属性に対して外部からのアクセスを制御すること</li></ul><p><br></p><h2 id="h366da644fc">おわりのご挨拶</h2><p>いかがでしたでしょうか？</p><p>弊社ではBubbleを使用した開発を行っていますが、</p><p>中にはBubbleで対応しきれないことが出てきたらコードを書かなければいけなくなる場面も存在します。<br><br></p><p>そういう場面となった際に、プログラミングの基礎的な知識などを持つと役立つことも多々あると思います。</p><p>是非、色々なことに興味を持って吸収し、開発に取り組んで行きましょう！<br><br></p><p>最後に…</p><p>私たちのチームでは、業界最高のスピード感で新規事業開発に携わることができ、</p><p>テクノロジーの力で圧倒的な成長を実感することができます。</p><p>株式会社Biz Freakで一緒に成長したい方は、ぜひ以下のリンクからご応募ください。</p><p>チーム一同、あなたと一緒に未来を創ることを楽しみにしています！</p><p>👉 <a href="https://bizfreak.co.jp/recruit">https://bizfreak.co.jp/recruit</a></p>

全くの別業界→インフラ→バックエンド遍歴を辿るエンジニアが、プログラミングを学んでいた時に理解することに苦労したオブジェクト指向プログラミングを、Pythonの簡単なコードを用いてサクッと解説！

【プログラミング 基礎】元インフラ系の人と学ぶオブジェクト指向

<p>こんにちは! 仙台オフィスで主にTypeScriptを書いているChloéです。</p><p>普段の開発では静的型付き言語を使うことが多いのですが、今回はPythonにおける型ヒントと、それに基づいて型チェックを行うツールのmypyについて記事を書いてみることにしました。</p><p>記事のターゲットとしては、主に「Jupyter Notebook等で生成AI等を使うためにPythonを書くのには慣れているけど、Pythonで(Web)アプリケーションを作った経験があまり無い」という方を想定しています。</p><p></p><h2 id="h0669eefa7c">目次</h2><ol><li>環境</li><li>Pythonに型チェックを導入するモチベーション</li><li>型ヒントの基本<ol><li>変数の型ヒント</li><li>関数の型ヒント</li><li>Union型</li></ol></li><li>mypyの導入<ol><li>mypyのインストール</li><li>mypyによる型チェック</li></ol></li><li>実践的な型チェック<ol><li>意図しない型変換</li><li>Null安全</li></ol></li><li>まとめ</li></ol><h2 id="h2b77a92925">1. 環境</h2><ul><li>Python 3.12.1</li><li>mypy 1.10.0<ul><li>本記事では特にカスタマイズはせず、デフォルトの設定で使用します。</li></ul></li></ul><h2 id="he47629f54e">2. Pythonに型チェックを導入するモチベーション</h2><p>私たちの会社では、生成AIや機械学習関連の業務がそこそこ多いため、Pythonエンジニアの割合が高いです。そのため、Webバックエンドアプリケーションは主にPythonで実装されています。Pythonは動的型付き言語であるため、ある程度の規模以上のアプリケーションを実装する際、型の情報がコードに明示されていないとメンテナンス性に問題が生じる可能性があります。</p><p>このような問題を解決するために、現代のPythonには <strong>型ヒント(Type Hints)</strong> という機能が存在します。型ヒントを利用することで、以下の利点が得られます。</p><ul><li>ドキュメンテーション<ul><li>型ヒントによって変数や関数にどのような値が入るかが可視化されるため、人間がコードを読んだ時に理解の助けになります。</li></ul></li><li>自動補完<ul><li>Pythonに対応しているテキストエディタやIDEについて、自動補完をサポートします。Pythonは動的型付き言語なので、ある変数についてどのような操作や演算ができるか解析しにくいです。型ヒントを入れることにより、変数に対する操作や演算が明確になり、自動補完がより正確になります。</li></ul></li><li>型チェック<ul><li>型をチェックできる静的解析ツールにより、プログラミングのミスに早期に気付くことができます。</li></ul></li></ul><p>型ヒント自体はPythonの機能ですが、Pythonのランタイムは型ヒントに対して特に何もしないことに注意してください。(型ヒントが書かれているコードを実行した時、型ヒントが無い場合と全く同じ動作をします) 自動補完や型チェックについては、型ヒントを理解する外部ツールによって実現されています。</p><p>この記事では型チェックにフォーカスし、<strong>mypy</strong>という静的解析ツールを使って実際にPythonコードの型チェックを行う方法を説明します。</p><h2 id="h777965de86">3. 型ヒントの基本</h2><p>本章では、Pythonのコードに型ヒントを付ける方法を扱います。</p><h3 id="ha5befadd66">3.1 変数の型ヒント</h3><ul><li>変数に型ヒントを付ける際は、 <code>変数名: 型名 = 値</code> と書きます。</li></ul><pre><code class="language-python"># int型の値
int_value: int = 123

# str型の値
str_value: str = &quot;Biz Freak&quot;

# bool型の値
bool_value: bool = True</code></pre><ul><li><code>list</code>や<code>tuple</code>といったコレクション型の型ヒントは以下の要領で書きます。</li></ul><pre><code class="language-python"># str型の要素を持つlist
list_value: list[str] = [&quot;abc&quot;, &quot;def&quot;, &quot;ghi&quot;]

# 1番目の要素がstr型, 2番目の要素がint型のtuple
tuple_value: tuple[str, int] = (&quot;abc&quot;, 1)

# Keyがstr型、Valueがint型のdict
dict_value: dict[str, int] = { &quot;abc&quot;: 1, &quot;def&quot;: 2 }</code></pre><h3 id="h94457c143b">3.2 関数の型ヒント</h3><p>関数に型ヒントを付ける際は、 <code>def 関数名(引数名: 型名 ...) -&gt; 戻り値の型名</code> と書きます。</p><pre><code class="language-python"># str型の引数1つをとってstr型の返り値を返す関数
def do_freak(something: str) -&gt; str:
  return f&quot;{something} Freak&quot;</code></pre><h3 id="hb5e347ca97">3.3 Union型</h3><p>複数の型を受け入れる変数を定義したいことがしばしばあります。そのような時には、Union型を使います。Union型は「複数の型のうちいずれかの型」を表現するものです。</p><pre><code class="language-python">int_or_str_value: int | str = 1 # intとstrのUnion型。 int型の値を代入
int_or_str_value = &quot;foo&quot; # str型の値の代入が許される</code></pre><h2 id="h38babb5976">4. mypyの導入</h2><p>本章では、静的解析ツールであるmypyの導入と、簡単な型チェックの方法を扱います。</p><h3 id="h643ed29b6a">4.1 mypyのインストール</h3><p>mypyは外部ツールなので、 <code>pip</code> などのパッケージマネージャからインストールするのが簡単です。</p><pre><code class="language-shell">pip install mypy</code></pre><h3 id="h09aa9f9c49">4.2 mypyによる型チェック</h3><p><code>mypy</code> コマンドの後に型チェックしたいスクリプトファイルのパスを渡すと、そのファイルの型チェックを行えます。</p><pre><code class="language-shell">mypy my-script.py</code></pre><p>ここで、標準出力に <code>Success: no issues found in 1 source file</code> と出力されると、型チェック成功です。</p><p>また、ソースコードが置かれているディレクトリを渡すと、ディレクトリの中のスクリプトファイルを再帰的に型チェックできます。</p><pre><code class="language-shell">mypy ./src/</code></pre><h3 id="hdaad11f928">4.3 テキストエディタ・IDEとの統合</h3><p>この手のツール全般に言えることですが、テキストエディタやIDEと統合することで快適な開発環境を構築することができます。ここでは例として、VSCodeとの統合方法を紹介します。</p><ul><li>VSCodeの拡張機能のマーケットプレースから”<a href="https://marketplace.visualstudio.com/items?itemName=ms-python.mypy-type-checker">Mypy Type Checker</a>”をインストールします。</li><li>拡張機能の設定から”Mypy-type-checker: Show Notifications”を”onError”に設定します。<figure><img src="https://images.microcms-assets.io/assets/145b371faece4417bfaf63302a2f6c77/8e6187309f204d3e914819e0266b0bd7/python01-mypy-type-checker-show-notifications.png" alt="" width="511" height="118"></figure><p></p></li><li>型エラーのある箇所に、自動的に以下のような表示が出ます。<figure><img src="https://images.microcms-assets.io/assets/145b371faece4417bfaf63302a2f6c77/cdcf023227794d658583209077bcfe1d/python01-mypy-error-on-cursor.png" alt="" width="1037" height="129"></figure><p>ちなみにこのエディタは正確にはVSCodeではなく、VSCodeをフォークして開発された<a href="https://cursor.sh/">Cursor</a>です :-)</p></li></ul><h2 id="haed544bae8">5. 実践的な型チェック</h2><p>この章では、実際のコードでありそうな型エラーとその解決方法について扱います。</p><h3 id="hfbcb309316">5.1 意図しない型変換</h3><h4 id="h07bd922a7b">5.1.1 型エラーの出るコード例</h4><p>以下は、価格と税率から税込価格を計算しようとしているコードです。</p><pre><code class="language-python"># 税込価格を計算する
def calcurate_total(price: int, tax_rate_percentage: int) -&gt; int:
	tax_rate = tax_rate_percentage / 100
	return price * (1 + tax_rate)

if __name__ == &quot;__main__&quot;:
    print(calcurate_total(900, 10))</code></pre><p>このコードをmypyで型チェックすると、以下のようなエラーが出ます。</p><pre><code class="language-shell">error: Incompatible return value type (got &quot;float&quot;, expected &quot;int&quot;)  [return-value]</code></pre><h4 id="h8cbe228081">5.1.2 原因</h4><p>原因は <code>price * (1 + tax_rate)</code>の部分です。 <code>int</code> 型の値 <code>price</code> と、 <code>float</code> 型の値 <code>tax_rate</code> について計算を行っていますが、このとき <code>price</code> の型が <code>int</code> から <code>float</code> に自動的に変換されます。</p><ul><li> <code>float</code>は<code>int</code>よりも表現できる範囲が広いため、これらを混ぜて演算すると<code>int</code>が<code>float</code>に変換された上で演算されます。このような挙動を<strong>型昇格</strong>といいます。</li></ul><h4 id="hbc7a8127ed">5.1.3 修正案</h4><p>修正の方針ですが、税込価格が整数で欲しい場合は以下のような修正が考えられるでしょう。</p><pre><code class="language-python"># 税込価格を計算する
def calcurate_total(price: int, tax_rate_percentage: int) -&gt; int:
	tax_rate = tax_rate_percentage / 100
	return math.floor(price * (1 + tax_rate)) # 小数点以下を切り捨て</code></pre><p>この場合、<code>math.floor()</code>は<code>float</code>型の値を引数に取って<code>int</code>型の値を返す関数なので、<code>calcurate_total</code>関数の戻り値は<code>int</code>型になります。</p><p>割りとありがちなケアレスミスですが、型ヒントを書いておけばこのようなミスに早く気付くことができます。</p><h3 id="h2ae2f1a608">5.2 Null安全</h3><h4 id="h96d34dd40e">5.2.1 型エラーの出るコード例</h4><p>以下は、辞書からキー &quot;id&quot; に対応する値を取得しようとしているコードです。また、関数内で何やらデバッグログを出そうとしています。</p><pre><code class="language-python">import logging
logging.basicConfig(level=logging.DEBUG, format=&quot;%(message)s&quot;)

def get_id_value(input: dict[str, str]) -&gt; str:
    id_value = input.get(&quot;id&quot;)
    logging.debug(&quot;id_value: &quot; + id_value)
    return id_value

if __name__ == &quot;__main__&quot;:
    print(get_id_value({&quot;id&quot;: &quot;bar&quot;}))</code></pre><p>このコードをmypyで型チェックすると、以下のようなエラーが出ます。</p><pre><code class="language-python">Unsupported operand types for + (&quot;str&quot; and &quot;None&quot;)  [operator]
Incompatible return value type (got &quot;str | None&quot;, expected &quot;str&quot;)  [return-value]</code></pre><h4 id="hfc0ce67b96">5.2.2 原因</h4><p>エラーの内容を大雑把にいうと</p><ul><li>1行目: <code>str</code>型と <code>None</code>型について<code>+</code>演算子を適用できない (つまり、足し算ができない)</li><li>2行目: 関数の戻り値の型ヒントが<code>str</code>だが、mypyが推論した戻り値の型は <code>str | None</code> である</li></ul><p>ということになります。</p><p><code>input.get(&quot;id&quot;)</code> について、<code>input</code>に “id”という名前のキーが含まれていない場合、対応する値の代わりに<code>None</code>が返されるのですが、このコードはそれの考慮を忘れてしまっています。</p><p>また、このコードですが、<code>get_id_value</code>関数にうっかり”id”キーを含まない辞書を渡して実行すると以下のような例外がraiseされてしまいます。</p><pre><code class="language-python">Traceback (most recent call last):
  File &quot;/path-to-script.py&quot;, line 20, in &lt;module&gt;
    print(get_id({&quot;a&quot;: &quot;foo&quot;, &quot;d&quot;: &quot;bar&quot;}))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File &quot;/path-to-script.py&quot;, line 15, in get_id
    logging.debug(&quot;id_value: &quot; + id_value)
                  ~~~~~~~~~~~~~^~~~~~~~~~
TypeError: can only concatenate str (not &quot;NoneType&quot;) to str</code></pre><p>このような実行時エラーが起こりうる実装を、mypyを使うことによって実行前にチェックできます。</p><h4 id="hb3caff6542">5.2.3 修正案</h4><p>まず、<code>logging.debug()</code>の部分で例外が出ないように修正します。f-stringを使い、変数を文字列にそのまま埋め込むのが手っ取り早いでしょう。</p><pre><code class="language-python">logging.debug(f&quot;id_value: {id_value}&quot;)</code></pre><p>次に、戻り値の型を修正します。今回は ”id” がない場合はとりあえず<code>None</code>を返すようにします。この時、適切な型は<code>str</code>と<code>None</code>のUnion型 <code>str | None</code>です。</p><pre><code class="language-python">def get_id_value(input: dict[str, str]) -&gt; str | None:
  ...</code></pre><p>合わせると、以下のようになります。</p><pre><code class="language-python">import logging
logging.basicConfig(level=logging.DEBUG, format=&quot;%(message)s&quot;)

def get_id_value(input: dict[str, str]) -&gt; str | None:
    id_value = input.get(&quot;id&quot;)
    logging.debug(f&quot;id_value: {id_value}&quot;)
    return id_value

if __name__ == &quot;__main__&quot;:
    print(get_id_value({&quot;id&quot;: &quot;bar&quot;}))</code></pre><p>これは極端な例でしたが、値がNull (Pythonでは<code>None</code>に相当する) である場合のハンドリングを忘れてしまうことはしばしばあります。ある変数がNullではない事を言語レベルで表明できる機能のことを「Null Safety」と呼んだりしますが、mypyによってそれを部分的に実現できます。</p><h2 id="h51351c43d4">6. まとめ</h2><p>この記事では、Pythonの型ヒントとmypyを用いた型チェック方法を説明しました。型ヒントを使用すると、コードのドキュメンテーション、自動補完、型チェックの利点が得られ、開発効率が向上します。また、mypyを使用することにより、型エラーを早期に発見し修正することが可能になります。</p><p>また、一般的にコードを書く時間よりも読む時間の方が長いといわれています。型ヒントを重要な場所(特に、モジュール外から参照されうる関数や変数)に書くことにより、 他の開発者がコードを読む際に理解が容易になります。それにより、特に多人数で開発する際の開発者間の齟齬が小さくなり、結果的に開発の高速化に寄与できるのではないでしょうか。</p><p>どのようなツールを使用するかはプロジェクトやチームの状況によりますが、mypyや型ヒントなどのツールはPython開発をさらに効率的で信頼性の高いものにするための一つの選択肢となるでしょう。</p><p><a href="https://bizfreak.co.jp/recruit" target="_blank" rel="noopener noreferrer nofollow">株式会社Biz Freak</a>は、ロバストなソフトウェアの設計・実装に興味のあるPythonエンジニアを募集しています。</p>

型ヒントと型チェックで開発スピードを落とさずに安全に実装しましょう。

BLOG

【Python】非同期処理で支える AI の社会実装 | asyncio 入門

【プログラミング基礎】元インフラ系の人と学ぶ手続き型プログラミング

【Node.js 入門 #1】 Node.js とは？ JavaScript をサーバーサイドで実行しよう！

【Python #2】はじめてのPydantic

【プログラミング基礎】元インフラ系の人と学ぶオブジェクト指向

【Python #1】はじめてのmypy

RECRUIT

BLOG

【Python】非同期処理で支える AI の社会実装 | asyncio 入門

【プログラミング基礎】元インフラ系の人と学ぶ手続き型プログラミング

【Node.js 入門 #1】 Node.js とは？ JavaScript をサーバーサイドで実行しよう！

【Python #2】はじめてのPydantic

【プログラミング 基礎】元インフラ系の人と学ぶオブジェクト指向

【Python #1】はじめてのmypy

RECRUIT

【プログラミング基礎】元インフラ系の人と学ぶオブジェクト指向