Python並行処理：マルチコアCPUを最大限に活用

Python学習

Python並行処理：マルチコアCPUを最大限に活用

  1. はじめに：並行処理でPythonを高速化！マルチコアCPUを最大限に活用しよう
    1. 並行処理と並列処理：違いを理解しよう
    2. なぜ並行処理が重要なのか？
    3. マルチコアCPUのアーキテクチャ：並行処理の舞台裏
    4. Pythonで並行処理を行うメリット：豊富なツールと簡単な実装
  2. Pythonの並行処理：threading、multiprocessing、asyncio – 3つの選択肢
    1. threading：I/Oバウンドなタスクに最適
    2. multiprocessing：CPUバウンドなタスクに最適
    3. asyncio：高い並行性と効率的なリソース利用
    4. 3つのモジュール比較表
    5. パフォーマンス比較：タスクに合わせて最適な選択を
  3. threading：スレッドベースの並行処理を徹底解説
    1. threadingモジュールの実装方法：シンプルなコードで並行処理
    2. GIL（Global Interpreter Lock）の制約：CPUバウンドなタスクでは注意が必要
    3. I/Oバウンドなタスクへの適用：効果的な活用方法
  4. multiprocessing：CPUバウンドな処理を高速化
    1. multiprocessingモジュールの実装：複数のプロセスを起動
    2. CPUバウンドなタスクへの適用：計算処理を並列化
    3. プロセス間通信 (IPC)：プロセス間でデータを共有
  5. concurrent.futures：高レベルな並行処理APIでさらに簡単に
    1. ThreadPoolExecutorとProcessPoolExecutor：用途に応じた使い分け
    2. Futureオブジェクト：非同期処理の結果を受け取る
    3. コード例：ProcessPoolExecutorでCPUバウンドなタスクを高速化
  6. 並行処理におけるデバッグと注意点：安全な並行処理のために
    1. 並行処理における3つの落とし穴：ロック、デッドロック、レースコンディション
    2. デバッグのヒント：ログ出力、テスト、ツールの活用
    3. 具体的なデバッグ例：ログ出力を活用してレースコンディションを特定する
  7. まとめ：Python並行処理でプログラムを高速化しよう！
    1. 今日からできること：並行処理を試してみよう！
    2. 並行処理をマスターして、Pythonプログラミングのスキルを向上させましょう！
    3. 次のステップ：asyncioを学ぼう！

はじめに：並行処理でPythonを高速化！マルチコアCPUを最大限に活用しよう

画像処理に時間がかかりすぎて困っていませんか？ 大量のデータを分析するのに何時間も待っていませんか？ Pythonの並行処理を活用すれば、これらの問題を解決し、処理速度を劇的に向上させることができます。現代のコンピュータはマルチコアCPUが主流です。並行処理をマスターすることで、これらのCPUの性能を最大限に引き出し、アプリケーションのパフォーマンスを最適化しましょう。

並行処理と並列処理：違いを理解しよう

似た言葉に「並列処理」がありますが、これらは異なる概念です。並行処理は、シングルコアのCPUでもタスクを細かく分割し、短時間で切り替えることで、あたかも同時に実行しているかのように見せかける技術です。一方、並列処理は、複数のコアを持つCPUで、複数のタスクを文字通り同時に実行します。つまり、並列処理は並行処理を実現する手段の一つと言えます。

なぜ並行処理が重要なのか？

並行処理を活用することで、以下のようなメリットがあります。

  • パフォーマンス向上: 時間のかかるタスクを分割し、並行して実行することで、全体の処理時間を短縮できます。
  • スループット向上: 単位時間あたりに処理できるタスクの数を増やし、システムの効率を高めます。
  • リソースの有効活用: CPU、メモリ、I/Oなどのリソースを効率的に利用し、システム全体のパフォーマンスを最適化します。
  • 応答性の向上: ユーザーインターフェースの操作に対する応答性を高め、快適なユーザーエクスペリエンスを提供します。

マルチコアCPUのアーキテクチャ：並行処理の舞台裏

マルチコアCPUは、1つの物理チップに複数の処理ユニット（コア）を搭載したものです。デュアルコア、クアッドコア、ヘキサコア、オクタコアなど、コア数が多いほど、同時に実行できるタスクの数が増え、処理能力が向上します。マルチコアCPUには、SMP (Symmetric Multiprocessing) や NUMA (Non-Uniform Memory Access) などのアーキテクチャがあります。SMPはすべてのコアが同一のシステムメモリにアクセスするのに対し、NUMAはコアごとにローカルメモリが割り当てられます。

Pythonで並行処理を行うメリット：豊富なツールと簡単な実装

Pythonは、threading、multiprocessing、asyncioといった豊富な並行処理モジュールを提供しており、比較的容易に並行処理を実装できます。これらのモジュールを活用することで、マルチコアCPUの性能を最大限に引き出し、複雑なタスクを効率的に処理できます。例えば、画像処理、データ分析、Webスクレイピングなど、時間のかかる処理を高速化することが可能です。

この記事では、これらのモジュールについて詳しく解説し、具体的なコード例を通じて、Python並行処理の秘訣を伝授します。さあ、Python並行処理の世界へ飛び込みましょう！

Pythonの並行処理：threading、multiprocessing、asyncio – 3つの選択肢

Pythonで並行処理を実装する上で、threading、multiprocessing、asyncioは欠かせないモジュールです。これらのモジュールはそれぞれ異なる特徴を持ち、適した用途も異なります。ここでは、それぞれのモジュールの概要、特徴、そして使い分けについて詳しく解説します。

threading：I/Oバウンドなタスクに最適

threadingは、スレッドベースの並行処理を実現するためのモジュールです。軽量なスレッドを生成し、複数のタスクを並行して実行できます。しかし、PythonにはGIL（Global Interpreter Lock）という制約があり、同時に実行できるPythonバイトコードは一つのスレッドに制限されます。

GILの影響を受けるため、threadingはI/Oバウンドなタスク、つまりネットワーク通信やファイルI/Oなど、処理時間の大半が待ち時間で占められるタスクに適しています。スレッドがI/O待ちの間、GILが解放され、別のスレッドが実行されるため、全体の処理効率を向上させることができます。

例えば、複数のWebサイトからデータをダウンロードするようなタスクを考えてみましょう。threadingを使うことで、各Webサイトからのダウンロードを並行して行うことができ、全体のダウンロード時間を短縮できます。

multiprocessing：CPUバウンドなタスクに最適

multiprocessingは、プロセスベースの並行処理を実現するためのモジュールです。複数のプロセスを生成し、各プロセスが独立したメモリ空間を持つため、GILの制約を受けずに並列実行が可能です。

multiprocessingは、CPUバウンドなタスク、つまり数値計算や画像処理など、CPUパワーを必要とするタスクに適しています。複数のCPUコアを最大限に活用することで、処理速度を大幅に向上させることができます。

例えば、大規模な行列計算を行うようなタスクを考えてみましょう。multiprocessingを使うことで、計算を複数のプロセスに分割し、並列して実行することで、計算時間を大幅に短縮できます。

asyncio：高い並行性と効率的なリソース利用

asyncioは、シングルスレッドで並行処理を実現する非同期I/Oフレームワークです。イベントループと呼ばれる仕組みを使ってタスクを効率的に切り替え、I/O待ち時間を有効活用します。

asyncioは、高い並行性と効率的なリソース利用が求められるI/Oバウンドなタスクに適しています。特に、多数のクライアントからの接続を処理するようなネットワークアプリケーションで効果を発揮します。

例えば、チャットサーバーを構築するようなタスクを考えてみましょう。asyncioを使うことで、多数のクライアントからの接続を効率的に処理し、リアルタイムなコミュニケーションを実現できます。

3つのモジュール比較表

モジュール 特徴 適したタスク 注意点
threading スレッドベース、GILの影響を受ける I/Oバウンドなタスク CPUバウンドなタスクでは効果が限定的
multiprocessing プロセスベース、GILの影響を受けない CPUバウンドなタスク プロセス生成のオーバーヘッドが大きい、プロセス間通信が必要
asyncio シングルスレッド、非同期I/O 高い並行性が求められるI/Oバウンドなタスク コードが複雑になりやすい、ライブラリの非同期対応が必要

パフォーマンス比較：タスクに合わせて最適な選択を

一般的に、複数のコアを活用できるmultiprocessingは、CPUバウンドなタスクにおいてthreadingやasyncioよりも高速です。一方、I/Oバウンドなタスクでは、threadingやasyncioがmultiprocessingよりも効率的な場合があります。タスクの特性に合わせて適切なモジュールを選択することが重要です。

Python 3.13からはGILをオプションで無効化できる機能が実験的に導入されます。GILが無効化されればthreadingのCPUバウンドなタスクのパフォーマンスも向上することが期待されます。

これらのモジュールを理解し、適切に使い分けることで、Pythonによる並行処理を最大限に活用し、プログラムのパフォーマンスを飛躍的に向上させることができます。次のセクションでは、threadingモジュールについてさらに詳しく見ていきましょう。

threading：スレッドベースの並行処理を徹底解説

Pythonのthreadingモジュールは、スレッドベースの並行処理を実現するための強力なツールです。スレッドは、プロセス内の軽量な実行単位であり、複数のタスクを「同時に」実行しているかのように見せることができます。しかし、Pythonのthreadingを理解する上で避けて通れないのが、GIL（Global Interpreter Lock）の存在です。

threadingモジュールの実装方法：シンプルなコードで並行処理

threadingモジュールを使ってスレッドを生成するのは比較的簡単です。基本的な流れは以下の通りです。

  1. threading.Thread()でThreadオブジェクトを作成します。
  2. target引数に、スレッドで実行したい関数を指定します。
  3. start()メソッドを呼び出してスレッドを開始します。
  4. 必要に応じて、join()メソッドでスレッドの完了を待ちます。

以下に簡単なコード例を示します。

import threading
import time

def task(name):
    print(f"Task {name}: Starting")
    time.sleep(1) # 1秒間スリープ（I/O待ちを模擬）
    print(f"Task {name}: Finishing")

# スレッドの作成
t1 = threading.Thread(target=task, args=("A",))
t2 = threading.Thread(target=task, args=("B",))

# スレッドの開始
t1.start()
t2.start()

# スレッドの完了を待機
t1.join()
t2.join()

print("All tasks completed.")

この例では、task関数を2つのスレッドで実行しています。time.sleep(1)は、I/O待ちの状態を模擬しており、この間にGILが解放され、別のスレッドが実行される可能性があります。

GIL（Global Interpreter Lock）の制約：CPUバウンドなタスクでは注意が必要

GILは、一度に一つのスレッドしかPythonバイトコードを実行できないという制約を課します。これは、Cで実装されたPythonインタープリタのメモリ管理を単純化するために導入されましたが、CPUバウンドなタスクにおける並行処理のボトルネックとなることがあります。

つまり、複数のスレッドを作成してCPUをフル活用しようとしても、GILのせいで実際にはシングルコアで実行しているのと変わらない、という状況が発生しえます。

しかし、朗報もあります。Python 3.13からは、GILをオプションで無効化できる機能が実験的に導入される予定です。これにより、CPUバウンドなタスクでもthreadingのパフォーマンスが向上する可能性があります。

I/Oバウンドなタスクへの適用：効果的な活用方法

GILの制約があるthreadingですが、I/Oバウンドなタスクにおいては非常に有効です。I/Oバウンドなタスクとは、ネットワーク通信やファイルアクセスなど、CPUの処理時間よりもI/O待ち時間の方が長いタスクのことです。

スレッドがI/O待ちの状態になると、GILが解放され、別のスレッドが実行可能になります。これにより、複数のI/Oバウンドなタスクを効率的に並行処理できます。

concurrent.futures.ThreadPoolExecutorを使うと、スレッドプールを簡単に利用できます。以下に例を示します。

import concurrent.futures
import time
import requests

def download_site(url, session):
    with session.get(url) as response:
        print(f"Read {len(response.content)} from {url}")

def download_all_sites(sites):
    with requests.Session() as session:
        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
            executor.map(download_site, sites, [session] * len(sites))

if __name__ == "__main__":
    sites = [
        "https://www.jython.org",
        "http://olympus.realpython.org/",
    ] * 80
    start_time = time.time()
    download_all_sites(sites)
    duration = time.time() - start_time
    print(f"Downloaded {len(sites)} in {duration} seconds")

この例では、requestsライブラリを使って複数のWebサイトからコンテンツをダウンロードしています。ThreadPoolExecutorを使うことで、複数のダウンロードタスクを並行して実行し、全体の処理時間を短縮しています。

threadingでできること、できないこと

threadingは、I/O待ち時間が長いタスクを並行処理するのに適していますが、CPUをフルに活用するタスクには向きません。タスクの種類に応じて、適切なモジュールを選択することが重要です。

次のセクションでは、GILの制約を受けずにCPUをフル活用できるmultiprocessingモジュールについて解説します。

multiprocessing：CPUバウンドな処理を高速化

このセクションでは、Pythonのmultiprocessingモジュールを使ったプロセスベースの並行処理について解説します。スレッドベースの並行処理とは異なり、プロセスは独立したメモリ空間を持つため、GIL（Global Interpreter Lock）の制約を受けずにCPUバウンドなタスクを並列実行できます。CPUをフル活用したい場合に最適な選択肢です。

multiprocessingモジュールの実装：複数のプロセスを起動

multiprocessingモジュールを使って並行処理を実装する基本的な流れを見ていきましょう。

  1. Processオブジェクトの作成: multiprocessing.Process()を使ってプロセスを作成します。target引数には、プロセスで実行する関数を指定します。

    import multiprocessing

def worker(num):
    """ワーカープロセスで実行される関数"""
    print(f'Worker {num}: プロセスID={multiprocessing.current_process().pid}')

if __name__ == '__main__':
    processes = []
    for i in range(3):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    この例では、3つのワーカープロセスを作成し、それぞれworker関数を実行しています。multiprocessing.current_process().pidで現在のプロセスIDを取得できます。

  2. プロセスの開始と終了: start()メソッドでプロセスを開始し、join()メソッドでプロセスの完了を待ちます。join()を呼び出すことで、親プロセスはすべての子プロセスが終了するまで待機します。

CPUバウンドなタスクへの適用：計算処理を並列化

multiprocessingが最も威力を発揮するのは、CPUバウンドなタスクです。例えば、数値計算や画像処理など、CPUパワーを必要とする処理に適しています。GILの制約がないため、複数のコアをフルに活用し、処理速度を大幅に向上させることが可能です。

例として、素数判定を行う関数を複数のプロセスで並列実行するコードを見てみましょう。

import multiprocessing
import time

def is_prime(n):
    """素数判定関数"""
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def worker(num, numbers, result_queue):
    """ワーカープロセス"""
    count = 0
    for n in numbers:
        if is_prime(n):
            count += 1
    result_queue.put((num, count))

if __name__ == '__main__':
    numbers = list(range(2, 100000))
    num_processes = multiprocessing.cpu_count() # CPUのコア数を取得
    chunk_size = len(numbers) // num_processes

    result_queue = multiprocessing.Queue()
    processes = []

    start_time = time.time()

    for i in range(num_processes):
        start = i * chunk_size
        end = (i + 1) * chunk_size if i < num_processes - 1 else len(numbers)
        p = multiprocessing.Process(target=worker, args=(i, numbers[start:end], result_queue))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    end_time = time.time()

    total_primes = 0
    while not result_queue.empty():
        num, count = result_queue.get()
        total_primes += count

    print(f'素数の数: {total_primes}')
    print(f'実行時間: {end_time - start_time:.2f}秒')

このコードでは、multiprocessing.cpu_count()でCPUのコア数を取得し、その数だけプロセスを生成しています。素数判定というCPU負荷の高い処理を分割し、並列実行することで、全体の処理時間を短縮しています。

プロセス間通信 (IPC)：プロセス間でデータを共有

複数のプロセス間でデータを共有したり、情報を交換したりするには、プロセス間通信（IPC: Inter-Process Communication）の仕組みが必要です。multiprocessingモジュールでは、以下のIPCメカニズムが提供されています。

  • Queue: プロセス間で安全にデータを共有するためのキューです。put()メソッドでデータをキューに追加し、get()メソッドでデータを取り出します。上記の素数判定の例でも、各ワーカープロセスの結果をQueueを使って集約しています。

  • Pipe: プロセス間で双方向通信を行うためのパイプです。multiprocessing.Pipe()でパイプを作成し、send()メソッドでデータを送信し、recv()メソッドでデータを受信します。

  • Value, Array: 共有メモリを利用してデータを共有します。複数のプロセスが同じメモリ領域にアクセスできるため、高速なデータ共有が可能です。ただし、競合状態を避けるために、ロックなどの同期メカニズムを適切に利用する必要があります。

以下は、Queueを使った簡単なプロセス間通信の例です。

import multiprocessing

def sender(queue):
    """データを送信するプロセス"""
    queue.put('Hello from sender!')

def receiver(queue):
    """データを受信するプロセス"""
    message = queue.get()
    print(f'Received: {message}')

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=sender, args=(queue,))
    p2 = multiprocessing.Process(target=receiver, args=(queue,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

この例では、senderプロセスがQueueにメッセージを送信し、receiverプロセスがそのメッセージを受信して表示します。

multiprocessingモジュールを使うことで、Pythonでも簡単にプロセスベースの並行処理を実装し、マルチコアCPUの性能を最大限に引き出すことができます。CPUバウンドなタスクの高速化にぜひ活用してください。

次に、threadingとmultiprocessingをより簡単に扱うためのconcurrent.futuresモジュールを見ていきましょう。

concurrent.futures：高レベルな並行処理APIでさらに簡単に

concurrent.futuresモジュールは、Pythonで並行処理をより手軽に扱うための高レベルなAPIを提供します。threadingやmultiprocessingを直接扱うよりも、抽象化されたインターフェースを通じて、スレッドやプロセスを効率的に管理できます。

ThreadPoolExecutorとProcessPoolExecutor：用途に応じた使い分け

concurrent.futuresの主要な機能として、ThreadPoolExecutorとProcessPoolExecutorがあります。ThreadPoolExecutorはスレッドプールを利用し、I/Oバウンドなタスク（ネットワークリクエスト、ファイルアクセスなど）に適しています。一方、ProcessPoolExecutorはプロセスプールを利用し、CPUバウンドなタスク（数値計算、画像処理など）に適しています。

なぜ使い分ける必要があるのでしょうか？ threadingのセクションでも触れたように、PythonのthreadingはGIL（Global Interpreter Lock）の影響を受け、CPUバウンドなタスクでは並列実行の効果が得にくい場合があります。ProcessPoolExecutorを使うことで、GILの制約を回避し、マルチコアCPUの性能を最大限に引き出すことができます。

Futureオブジェクト：非同期処理の結果を受け取る

submit()メソッドで実行したタスクの結果は、Futureオブジェクトとして返されます。Futureオブジェクトは、非同期処理が完了するまで待機し、結果を取得するためのインターフェースを提供します。result()メソッドを呼び出すことで、処理結果を取得できます。また、as_completed()関数を使うと、複数のFutureオブジェクトが完了した順に処理できます。

コード例：ProcessPoolExecutorでCPUバウンドなタスクを高速化

import concurrent.futures
import time

def cpu_bound_task(n):
    sum = 0
    for i in range(n):
        sum += i
    return sum

if __name__ == '__main__':
    numbers = [10000000, 20000000, 30000000]
    start_time = time.time()
    with concurrent.futures.ProcessPoolExecutor() as executor:
        results = executor.map(cpu_bound_task, numbers)
    end_time = time.time()
    print(f'実行時間: {end_time - start_time:.2f}秒')
    print(list(results))

この例では、ProcessPoolExecutorを使って複数のCPUバウンドなタスクを並列実行し、処理時間を大幅に短縮しています。concurrent.futuresを活用することで、より簡潔に、より効率的な並行処理を実装できます。

concurrent.futuresを使うことで、threadingやmultiprocessingを直接扱うよりも、格段にコードが簡潔になります。しかし、並行処理には注意すべき点もあります。次のセクションでは、並行処理におけるデバッグと注意点について解説します。

並行処理におけるデバッグと注意点：安全な並行処理のために

並行処理は強力なツールですが、その力を引き出すには注意が必要です。特にデバッグは、逐次処理に比べて格段に難しくなります。なぜなら、タイミングによって結果が変動し、再現が困難なバグが発生しやすいからです。

並行処理における3つの落とし穴：ロック、デッドロック、レースコンディション

  • ロック（Lock）: 複数のスレッドやプロセスが共有リソースに同時にアクセスするのを防ぐ仕組みですが、扱いを間違えるとデッドロックの原因になります。例えば、2つのスレッドがそれぞれ異なるロックを取得し、互いのロック解除を待ってしまう状況です。

  • デッドロック（Deadlock）: 上述の通り、複数のスレッドやプロセスがお互いのロックを待ち、身動きが取れなくなる状態です。これを避けるには、ロックの取得順序を常に一定にする、タイムアウトを設定するなどの対策が必要です。

  • レースコンディション（Race Condition）: 複数のスレッドやプロセスが共有リソースに同時にアクセスし、予期せぬ結果が生じる状態です。例えば、複数のスレッドが同時に変数に書き込もうとして、最終的な値が不定になることがあります。これを防ぐには、アトミックな操作を使うか、ロックで排他制御を行う必要があります。

デバッグのヒント：ログ出力、テスト、ツールの活用

  • ログ出力: 処理の実行順序や変数の値を詳細に記録することで、問題発生時の状況を把握しやすくします。

  • テスト: 並行処理を行うコードは、様々なパターンを想定したテストを行うことが重要です。特に、競合状態が発生しやすい状況を再現するテストを心がけましょう。

  • ツール: 並行処理のデバッグを支援するツールを活用しましょう。例えば、スレッドの動作を可視化するツールや、デッドロックを検出するツールなどがあります。

具体的なデバッグ例：ログ出力を活用してレースコンディションを特定する

前のセクションで紹介した素数判定のコードを例に、デバッグの様子を見てみましょう。もし、素数の数が正しく計算されない場合、各ワーカープロセスの計算結果をログ出力することで、問題の原因を特定できます。

import multiprocessing
import time
import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(processName)s - %(message)s')

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def worker(num, numbers, result_queue):
    count = 0
    for n in numbers:
        if is_prime(n):
            count += 1
    logging.debug(f'Worker {num}: Found {count} primes in range {numbers[0]} - {numbers[-1]}')
    result_queue.put((num, count))

# (残りのコードは省略)

このように、ログ出力を活用することで、各プロセスの動作を詳細に把握し、問題の原因を特定することができます。

並行処理は、パフォーマンス向上に大きく貢献しますが、その複雑さを理解し、適切な対策を講じることが重要です。焦らず、段階的に理解を深めていきましょう。

まとめ：Python並行処理でプログラムを高速化しよう！

この記事では、Pythonで並行処理を実装し、マルチコアCPUの性能を最大限に引き出す方法を解説しました。threading、multiprocessing、concurrent.futuresといったモジュールの特徴や使い分け、具体的なコード例を通じて、並行処理の基本を理解していただけたかと思います。

今日からできること：並行処理を試してみよう！

まずは、簡単なタスクから並行処理を試してみましょう。例えば、Webサイトから複数の画像をダウンロードするスクリプトを書いて、threadingを使って並行処理化してみるのも良いでしょう。あるいは、数値計算を行うプログラムをmultiprocessingで並列化してみるのも良いでしょう。

並行処理をマスターして、Pythonプログラミングのスキルを向上させましょう！

並行処理は、Pythonプログラミングのスキルを向上させるための重要な要素です。この記事で学んだ知識を活かして、ぜひ並行処理に挑戦してみてください。きっと、あなたのプログラムはより高速に、より効率的になるでしょう。

次のステップ：asyncioを学ぼう！

この記事では、threading、multiprocessing、concurrent.futuresについて解説しましたが、Pythonにはもう一つ、asyncioという強力な並行処理モジュールがあります。asyncioは、非同期I/Oを扱うためのモジュールで、特にネットワークプログラミングで力を発揮します。asyncioについても学んで、Python並行処理のスキルをさらに向上させましょう！

さあ、あなたもPython並行処理の世界へ飛び込み、プログラムの可能性を広げましょう！

コメント

タイトルとURLをコピーしました