Pythonの利点

簡潔で学びやすい構文

Python の構文はシンプルで自然言語に近いです。初心者プログラマーでもすぐに始めることができ、学習の敷居が低くなります。

豊富な標準ライブラリとサードパーティのリソース

Python は、ネットワーキング、データ処理、グラフィカル インターフェイスなどの多くの側面をカバーする幅広い標準関数ライブラリを提供します。さらに、NumPy、Pandas、TensorFlow などの強力なサードパーティ エコシステムにより、Python は多用途の開発ツールになります。

クロスプラットフォーム機能

Python はクロスプラットフォーム言語です。 WindowsでもmacOSでもLinuxでも同じPythonプログラムを実行できるため、開発の自由度が大幅に向上します。

多くの分野で広く使用されています

Python はデータ サイエンス、人工知能、Web 開発、自動スクリプティング、ゲーム開発などの複数の分野で重要な役割を果たしており、開発者が 1 つの言語で複数のニーズに対応できるようになります。

積極的なコミュニティサポート

Python には大規模なグローバル コミュニティがあり、初心者も経験豊富な開発者も、教育リソース、ディスカッション グループ、技術サポートを簡単に見つけることができます。

効率的な開発スピード

Python は直感的な構文と強力なツールを提供するため、開発者はプログラミングをより迅速に実装し、製品開発サイクルを短縮できます。

Python開発環境

Anaconda

アナコンダとは何ですか？

Anaconda は、データ サイエンス、機械学習、人工知能、ビッグ データ分析などのアプリケーションを含む科学コンピューティング向けに設計されたオープンソースの Python および R プログラミング プラットフォームです。

主な機能

• 統合環境: Jupyter Notebook や Spyder などの使いやすい統合開発環境 (IDE) を提供します。
• パッケージ管理: Conda 管理ツールを使用して、数千のオープン ソース ライブラリを簡単にインストール、更新、管理します。
• クロスプラットフォームのサポート: Windows、macOS、Linux をサポートします。
• データの視覚化: Matplotlib や Seaborn など、データの視覚化に役立つ組み込みツールが多数あります。

オブジェクトに適しています

Anaconda は、次の分野のユーザーに適しています。

• データサイエンティスト
• 機械学習エンジニア
• 人工知能研究者
• ビッグデータ分析を実行する必要がある専門家

アナコンダをインストールするにはどうすればよいですか?

1. アクセスアナコンダ公式サイト。
2. 適切なオペレーティング システムのバージョンを選択し、対応するインストール ファイルをダウンロードします。
3. インストール ウィザードに従ってインストールを完了し、環境変数を構成します (オプション)。

よくある質問

ユーザーがよく遭遇する問題は次のとおりです。

• アナコンダをアップグレードするにはどうすればよいですか?

ターミナルで入力可能conda update condaそしてconda update anaconda。

• アナコンダとPythonの違いは何ですか?

Anaconda は、プログラミング言語である Python をさまざまな組み込みツールやライブラリと統合したデータ サイエンス プラットフォームです。

アナコンダ環境

アナコンダ環境とは何ですか

Anaconda は、同じコンピュータ上に複数の独立した Python 実行環境を作成できる仮想環境 (Environment) 機能を提供します。異なるプロジェクト間の依存関係の競合を避けるために、各環境に異なる Python バージョンとパッケージを含めることができます。

環境を整える

# myenv という名前の環境を作成し、Python のバージョンを指定します
conda create -n myenv python=3.10

環境の起動と切り替え

# 環境を開始する
conda は myenv をアクティブ化します

#環境を終了する
conda を非アクティブ化する

環境を見る

# すべての環境をリストする
conda 環境リスト
# または
conda 情報 --envs

環境のエクスポートと復元

# 環境設定を YAML ファイルにエクスポート
conda 環境エクスポート > 環境.yml

# YAMLファイルから環境を作成
conda env create -f 環境.yml

環境の削除

# 指定した環境を削除する
conda 削除 -n myenv --all

Jupyter

ジュピターとは何ですか？

Jupyter は、複数のプログラミング言語をサポートするオープンソースのインタラクティブ コンピューティング環境で、主にデータ サイエンス、機械学習、学術研究に使用されます。

コア機能

• 多言語サポート: Python、R、Julia、および 40 以上の言語を含みます。
• インタラクティブ プログラミング: Jupyter Notebook を通じてプログラムを作成し、コードを実行して、結果をリアルタイムで表示します。
• データ視覚化: Matplotlib、Plotly などのグラフィカル ツールの組み込みサポート。
• 共有機能: ノートブックは HTML、PDF にエクスポートしたり、Jupyter Hub 経由で共有したりできます。

主要コンポーネント

• Jupyter Notebook：ユーザーがコードを作成して実行できるようにする Web ベースのエディター。
• JupyterLab：より優れた機能性と拡張性を提供する次世代のユーザー インターフェイス。
• Jupyter Hub：チームまたは学術機関向けのマルチユーザー Jupyter プラットフォーム。

適用範囲

Jupyter は次の分野で広く使用されています。

• データサイエンスと分析
• 機械学習および深層学習モデルの開発
• 学術研究と教育
• データの視覚化とレポート作成

ジュピターの使い方は？

1. Anaconda をインストールするか、Jupyter スタンドアロンをインストールします。
2. ターミナルに入力してくださいjupyter notebookJupyter Notebook を起動します。
3. ブラウザーから編集インターフェイスに入り、ノートブックを作成して実行します。

利点と課題

• 利点:リアルタイムの実行、結果の視覚化、および多言語のサポート。
• チャレンジ：大規模なプロジェクトのサポートは限られており、実行効率は従来の IDE ほど良くない可能性があります。

VS Code Python 開発環境

Visual Studio コードをインストールする

に行くVisual Studio Code 公式ウェブサイト、オペレーティング システムに適したバージョンをダウンロードしてインストールします。

Python 拡張機能をインストールする

Visual Studio Code で、次の手順に従って Python 拡張機能をインストールします。

1. 左側の拡張機能アイコンをクリックします。
2. 「Python」で検索してください。
3. Microsoft が提供する Python 拡張機能を選択し、「インストール」をクリックします。

Pythonをインストールする

Python がシステムにインストールされていることを確認してください。から入手できますパイソン公式サイトダウンロードしてインストールします。

インストールが完了したら、コマンド ラインに次のコマンドを入力して、インストールが成功したことを確認します。

Python --バージョン
# または
python3 --バージョン

Python インタープリターのセットアップ

Python プロジェクトまたはファイルを開き、Visual Studio Code の右下隅にある「Python」ステータス バーをクリックして、適切な Python インタープリターを選択します。

Pythonプログラムを実行する

エディターで Python ファイルを開き、次の方法を使用してプログラムを実行します。

1. ファイルの内容を右クリックし、「ターミナルで Python ファイルを実行」を選択します。
2. またはショートカットキーを使用するCtrl + Shift + P, 「Python ファイルの実行」を検索して実行します。

必要なパッケージをインストールする

サードパーティのパッケージをインストールする必要がある場合は、内蔵ターミナルを使用して次のように入力できます。

pip インストールパッケージ名

オートコンプリートとデバッグを有効にする

Python 拡張機能によって提供される機能を通じて、オートコンプリートと強力なデバッグ ツールをお楽しみください。

1. 左側のデバッグアイコンをクリックします。
2. 「launch.json ファイルの作成」を選択し、Python を選択します。
3. 設定が完了したら、F5 キーを押してデバッグ モードを有効にします。

よく使うショートカットキー

よく使用されるショートカット キーをいくつか示します。

• 実行プログラム: Ctrl + F5
• コマンド パネルを開きます。 Ctrl + Shift + P
• コードのフォーマット: Shift + Alt + F
• ターミナルを起動します。 Ctrl + `

VS Code

VS Code は Python 実行パラメータを設定します

launch.jsonを変更する

Python プログラムの実行時にパラメータを渡す必要がある場合は、次のように設定できます。launch.json仕上げる：

1. 左側の「実行とデバッグ」アイコンをクリックします。
2. 「launch.json ファイルの作成」または「構成の追加」をクリックします。
3. 環境として「Python」を選択します。
4. 生成されたlaunch.jsonファイル内の関連する設定を変更します。

プログラムと引数のパラメータを設定する

以下は、プログラム パスと実行パラメータを含む設定例です。

{
    "バージョン": "0.2.0",
    「構成」: [
        {
            "name": "Python: 引数を指定して実行",
            "タイプ": "Python",
            "リクエスト": "起動",
            "program": "${workspaceFolder}/main.py", // プログラムのパス
            "console": "integrated Terminal", // 端末の種類
            "args": ["arg1", "arg2", "--option", "value"] // パラメータを渡す
        }
    ]
}

引数の目的

存在するargsコマンドラインパラメータは次のように渡すことができます。

• arg1そしてarg2は位置パラメータです。
• --optionそしてvalueはオプション付きのパラメータです。

プログラム内のパラメータを読み込む

使用sys.argvコマンドラインから渡されたパラメータを読み取るには:

インポートシステム

print("すべてのパラメータ:", sys.argv)
len(sys.argv) > 1の場合:
    print("最初のパラメータ:", sys.argv[1])
    print("第二パラメータ:", sys.argv[2])

実行例

次のようなプログラムがあるとします。

python main.py arg1 arg2 --option value

実行結果:

すべてのパラメータ: ['main.py'、'arg1'、'arg2'、'--option'、'value']
最初のパラメータ: arg1
2 番目のパラメータ: arg2

VS コード Python デバッグ モード

デバッグモードを有効にする

1. インストールPython Extension拡大。

2. VS Code で Python プロジェクトを開始します。

3. を押しますF5または、左側のアクティビティバーをクリックしますDebugアイコン。

launch.jsonの設定

1. デバッグパネルで「構成の追加」をクリックします。

2. 選択しますPython、システムは自動的にlaunch.json。

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal"
        }
    ]
}

ブレークポイントを設定する

1. コード行番号の横をクリックしてブレークポイントを追加します。

2. 条件付きブレーク ポイントを使用できます。ブレーク ポイントを右クリックし、[条件の編集] を選択します。

デバッグ機能

• ステップオーバー:によるとF10スキップ機能。
• ステップイン:によるとF11関数内に入力します。
• ステップアウト:によるとShift+F11関数から飛び出す。

変数をチェックする

1. [デバッグ] パネルの [変数] 領域で現在の変数のステータスを表示します。

2. [モニター] エリアに特定の式を手動で追加できます。

デバッグコンソールの使用

1. デバッグ コンソールに Python コマンドを入力して、プログラムのステータスをリアルタイムで確認します。

2. 変数クエリや関数呼び出しなどの操作を実行できます。

VS CodeはPythonパスを設定します

ステップ 1: Python と VS Code をインストールする

Python がインストールされ、システム環境変数に追加されていることを確認してから、Visual Studio Code をダウンロードしてインストールします。

ステップ 2: Python 拡張機能をインストールする

Visual Studio Code を開き、左側の [拡張機能] アイコンをクリックして検索します。Pythonをクリックし、Microsoft が提供する Python 拡張機能をインストールします。

ステップ 3: Python のインストール パスを確認する

ターミナルに次のコマンドを入力して、Python のインストール パスを確認します。

which python

または (Windows システム):

where python

ステップ 4: Python パスを設定する

Visual Studio Code で、次を押します。Ctrl + Shift + Pを入力して選択しますPython: Select Interpreter。

マニフェストで正しい Python パスを選択します。表示されない場合は、フルパスを手動で入力してください。

ステップ 5: 設定を確認する

ターミナルを開いて実行しますpython --versionPython インタープリターの正しいバージョンが選択されていることを確認します。

追加情報

特定のプロジェクトの Python パスが必要な場合は、プロジェクトのルート ディレクトリに追加できます。.vscode/settings.jsonファイルを作成し、次の内容を追加します。

{
  "python.pythonPath": "Python へのフルパス"
}

交換するPython のフルパスは実際のパスです。

VS Code Python 環境の切り替え

VS Code で開発する場合、主に基盤となるインタープリター (Interpreter) の設定を通じて、Anaconda またはその他の環境を使用することにします。これにより、パッケージの依存関係がプログラム実行環境から完全に分離されます。

1. Python 環境を選択する手順

• 右下隅にある環境名をクリックします。VS Code ウィンドウの右下隅に、Python 3.x.x または環境名に似たテキストが表示されます。直接クリックするとメニューが開きます。
• コマンド パレットを使用します。プレスCtrl + Shift + P(Windows) またはCmd + Shift + P(Mac)、入力して選択しますPython: Select Interpreter。
• リストからターゲット環境を選択します。
  • Anaconda を使用するには、ラベルの付いたオプションを選択しますConda言葉の道。
  • 標準の仮想環境を使用するには、ラベルの付いたオプションを選択します。Venvプロジェクト。

2. Anaconda を使用するか他の環境を使用するかを決定する方法

3. Conda で環境を管理および切り替える

グラフィカル インターフェイスに加えて、VS Code の組み込みターミナルのコマンドを使用して環境を管理することもできます。

• すべての環境を表示します。 conda env list
• 環境を手動でアクティブ化します。 conda activate 環境名
• 新しい環境を作成します。 conda create -n name python=3.10

4. よくある質問と解決策

• Conda 環境が見つかりません:リストが表示されない場合は、Anaconda がシステム環境変数を追加しているかどうかを確認するか、「インタープリター パスを入力」をクリックして手動で指定してください。python.exeパス。
• ターミナルは自動的にアクティブ化されません。VS Code 設定での検索python.terminal.activateEnvironment、このオプションがチェックされていることを確認してください。
• 権限エラー:Windows をオンにできない場合は、管理者として VS Code を実行するか、PowerShell で実行してください。Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser。

Chromebook で Python を実行する

方法 1: Linux (クロスティーニ) を使用する

1. Chromebookの設定で「Linux（ベータ）」または「開発者→Linux開発環境」をオンにします。
2. Linux ターミナルを起動し、次のように入力します。

   
   sudo apt update
   sudo apt install python3 python3-pip -y
       

3. 入力python3Python インタラクティブ環境に入ります。
4. 追加のモジュールをインストールするには、利用可能なpip3 インストールモジュール名。

方法 2: オンライン コンパイラーを使用する

• オンライン Python コンパイラーは、ブラウザーから直接使用できます。次に例を示します。
  • Google Colab
  • Replit
  • Jupyter Notebook on Binder
• インストールしたくない環境やコードの一時的なテストに適しています。

方法 3: Android アプリをインストールする

• Chromebook は、Google Play からダウンロードできる Android アプリのインストールをサポートしています。
  • Pydroid 3: 完全な Python 開発環境。
  • QPython:軽量の Python スクリプト ツール。

方法 4: VS コードを使用する

1. Linux (Crostini) 環境に VS Code をインストールします。

   
   sudo apt install wget gpg -y
   wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
   sudo install -o root -g root -m 644 packages.microsoft.gpg /usr/share/keyrings/
   sudo sh -c 'echo "deb [arch=amd64 signed-by=/usr/share/keyrings/packages.microsoft.gpg] \
   https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
   sudo apt update
   sudo apt install code -y
       

2. プログラムを開発するには、VS Code に Python プラグインをインストールします。

結論は

• 最も早い方法は使用することですLinux (Crostini)Pythonをインストールします。
• システムを妨害したくない場合は、次のオプションを選択できます。オンライン環境またはAndroid App。
• 先進的な開発提案VS CodeまたはJupyter Notebook。

pip の使用ガイド

1.ピップとは何ですか?

• 意味：pip は Python のパッケージ管理ツールで、正式名は「Pip Installs Packages」です。
• 使用：Python をインストール、更新、削除、管理するためのスイート。
• ソース：pip は、公式 Python パッケージ ライブラリ PyPI (Python Package Index) からパッケージをダウンロードします。

2. pipの基本操作

• バージョンを確認します:

  pip --version

• 取り付けキット:

  pip インストールパッケージ名

  例えば：pip install requests

• アップグレードキット:

  pip install --upgrade パッケージ名

  例えば：pip install --upgrade requests

• インストールされているパッケージをリストします。

  pip list

• パッケージをアンインストールします。

  pipアンインストールパッケージ名

  例えば：pip uninstall requests

• 期限切れのパッケージを確認します。

  pip list --outdated

3. 先進的な機能

• 特定のバージョンをインストールします。

  pip install パッケージ名==バージョン番号

  例えば：pip install requests==2.26.0

• 複数のパッケージをインストールします。

  pip install -r requirements.txt

  使用requirements.txtファイル。必要なパッケージ名とバージョンをすべてリストします。

• 要件ファイルを生成します。

  pip freeze > requirements.txt

  このコマンドは、現在の環境のパッケージとバージョンを要件アーカイブとしてエクスポートします。

• キャッシュをクリアします:

  pip cache purge

  pip のキャッシュ フォルダーをクリーンアップしてディスク領域を解放します。

4. よくある質問と解決策

• 問題: pip コマンドが見つかりません

  解決策: Python がインストールされているかどうかを確認し、Python のインストール ディレクトリがシステムの PATH 環境変数に追加されていることを確認します。

• 問題: パッケージのインストール中に権限エラーが発生しました

  解決策: 追加してみてください--userパラメータは次のとおりです。pip install パッケージ名 --user

• 問題: PyPI に接続できない

  解決策: ネットワークが正常かどうかを確認するか、次のように国内のミラー ソースを使用してみてください。pip install パッケージ名 -i https://pypi.tuna.tsinghua.edu.cn/simple

5. pip のベストプラクティス

• などの仮想環境を使用します。venvまたはvirtualenv) グローバル インストール パッケージとの競合を避けるため。
• セキュリティを維持するために、インストールされているパッケージを定期的に確認して更新します。
• プロジェクトで使用されるrequirements.txt依存関係を管理します。

pip/cache/http-v2 フォルダー

1. pip/cache/http-v2 フォルダーとは何ですか?

• pip：Python パッケージをインストール、更新、管理するための Python パッケージ管理ツール。
• cache：pip のキャッシュ ディレクトリは、ダウンロードしたパッケージと関連リソースを保存し、再利用しやすいようにするために使用されます。
• http-v2：キャッシュされた HTTP 要求データ、特に HTTP/2 プロトコルに基づくダウンロード要求用。

2. http-v2 フォルダーの目的

• ダウンロードしたパッケージをキャッシュする:パッケージをインストールするとき、pip はパッケージのアーカイブをダウンロードしてキャッシュします。http-v2ディレクトリに保存されるため、今後同じパッケージをインストールするときに再度ダウンロードする必要がなくなります。
• インストールプロセスを高速化します。キャッシュ内のファイルを再利用することで、ネットワーク リクエストが削減され、インストール速度が向上します。
• 帯域幅を節約します:パッケージをインストールするたびにインターネットから再ダウンロードする必要がなく、帯域幅の消費が削減されます。

3. http-v2フォルダの管理

• キャッシュの場所を表示:
  • 使用説明書pip cache dir現在のキャッシュ ディレクトリを表示します。
• キャッシュをクリアします:
  • 使用説明書pip cache purgeキャッシュされたデータをすべてクリアします。
  • 特定のキャッシュ データのみを削除します。直接削除できます。http-v2ただし、これにより、次回関連パッケージをインストールするときに pip がファイルを再ダウンロードすることになります。
• キャッシュを無効にする:
  • キャッシュを使用したくない場合は、パッケージのインストール時にキャッシュを追加できます。--no-cache-dirパラメータは次のとおりです。pip install package_name --no-cache-dir。

4. 注意事項

• キャッシュディレクトリのサイズ:pip を長期間使用すると、キャッシュ フォルダーが大きくなる可能性があります。定期的にクリーンアップしてディスク領域を解放することをお勧めします。
• オフラインインストール:キャッシュされたパッケージは、インターネットに接続していなくてもオフラインでインストールできます。
• バージョンアップデート：キャッシュをクリアすると、一部のパッケージの再ダウンロードが必要になる場合がありますが、確実に最新バージョンをダウンロードできます。

Pythonの基本的なデータ構造

変数の型を確認する

type() を使用する

type()この関数はオブジェクトのタイプを返すことができます。

x = 10
print(type(x))   # <class 'int'>

y = "hello"
print(type(y))   # <class 'str'>

isinstance() を使用する

isinstance()変数が特定の型に属しているかどうかを確認するために使用され、複数の型のチェックをサポートします。

x = 10

print(isinstance(x, int))         # True
print(isinstance(x, str))         # False
print(isinstance(x, (int, float))) # True

違い

• type()比較的厳密で、正確な型のみが返されます。
• isinstance()継承関係が考慮され、実際にはより一般的に使用されます。

Python ブールデータ型

Python のブール値は、True または False の 2 つの論理状態を表すプログラミングの基本的なデータ型です。これは、すべての条件判断とプロセス制御の基礎となります。

1. ブール値と型

• ボリンジャー値は 2 つだけです。TrueそしてFalse。
• 最初の文字を大文字で書く必要があります。
• ブール値の型は次のとおりです。bool。

a = 真
b = 偽
print(type(a)) # 出力: <class 'bool'>

2. ボリンジャーと数字の関係

Python の内部では、boolは整数ですintのサブカテゴリなので、数値演算に参加できます。

• True数値的には 1 と同等です。
• False数値的には 0 と同等です。

print(True + 1) # 出力: 2 (1 + 1)
print(False * 5) # 出力: 0 (0 * 5)

3. 主な用途: 比較演算子

比較演算子は 2 つの値を比較し、ブール値の結果を返します。

4. 論理演算子

論理演算子は、ブール値またはブール式を結合または変更するために使用されます。

• and: 論理「and」、両辺はTrue結果はTrue。
• or: 論理「OR」、どちらかがTrue結果はTrue。
• not: 論理「否定」、ブール値を反転します。

print(True と False) # 出力: False
print(True または False) # 出力: True
print(not True) # 出力: False

5. 真理値テスト

Python では、すべてのオブジェクトが真理値を持ちます。オブジェクトが条件判定に使用される場合、Python はそれを次のように変換します。TrueまたはFalse：

• とみなされるFalse(偽) オブジェクトには次のものが含まれます。None、数字の 0 (0, 0.0)、空の文字列("")、空のリスト ([])、空のタプル(())、空の辞書 ({}) と空集合 (set())。
• とみなされるTrue(真実の) オブジェクトには、Falsy 値 (ゼロ以外の数値、空でないコンテナなど) を除く他のすべてのオブジェクトが含まれます。

if []: # 空のリストは False として扱われます
    print("これは実行されません")
それ以外の場合:
    print("リストは空です")

if "hello": # 空でない文字列は True とみなされます
    print("文字列が空ではありません")

Python 配列

配列とは何ですか?

Python では、配列は同じ型の複数の要素を格納するために使用されるデータ構造です。 Python 自体には組み込みの配列型はありませんが、次のように使用できます。listまたはarray同様の機能を実現するモジュール。

リストを配列として使用する

listこれは、さまざまなタイプのデータを保存できる Python の組み込みデータ構造ですが、配列のシミュレーションにも使用できます。

my_list = [1、2、3、4、5]
print(my_list[0]) # 出力: 1

アレイモジュールの使用

真の配列が必要な場合 (すべての要素が同じ型である必要があります)、次のように使用できます。arrayモッド。

配列をインポートする

my_array = array.array('i', [1, 2, 3, 4, 5])
print(my_array[0]) # 出力: 1

ここ、'i'配列内の要素が整数であることを示します。

配列モジュールの基本操作

基本的な操作をいくつか示します。

• 新しい要素:my_array.append(6)
• 要素を削除します。my_array.remove(3)
• 長さを取得します。len(my_array)

配列とNumPy

数値演算が必要な場合には、numpyより強力な配列サポートを提供します。

numpyをnpとしてインポート

my_numpy_array = np.array([1, 2, 3, 4, 5])
print(my_numpy_array[0]) # 出力: 1

NumPy 配列は多次元データとベクトル化された演算をサポートしているため、大量のデータの処理に最適です。

結論は

Python には配列関数を実装するためのさまざまな方法が用意されています。list一般的な状況に当てはまりますが、arrayモジュールは、同じタイプの要素が必要な状況に適していますが、numpyこれは科学計算に最適なツールです。

リストが空かどうかを判断する

変数の場合ret_value = [], Python 言語には、空のリストかどうかを判断する簡単で効率的な方法がいくつかあります。空のリストは次のように扱われるため、False, 以下に一般的に使用されるいくつかの判断方法を示します。

1. ブール評価を使用します (Python で最も推奨される方法)

これは最も一般的な方法で、リストのブール値を直接チェックします。リストが空の場合、not演算子はその条件を true に評価します (True）。

ret_value = []

ret_value でない場合:
    #リストが空の場合はここで実行
    print("ret_value は空のリストです")
それ以外の場合:
    #リストが空でない場合はここで実行
    print("ret_value は空のリストではありません")

2. 使用するlen()関数

リストの長さが 0 に等しいかどうかを確認します。

ret_value = []

len(ret_value) == 0の場合:
    print("ret_value は空のリストです")
それ以外の場合:
    print("ret_value は空のリストではありません")

3. 同等の比較を使用する== []

変数を空のリスト リテラルに直接代入する[]比較してみましょう。

ret_value = []

ret_value == []の場合:
    print("ret_value は空のリストです")
それ以外の場合:
    print("ret_value は空のリストではありません")

配列の動的な増減

リストを使用した動的操作

Pythonでは、listこれは、要素を簡単に追加および削除できる動的なデータ構造です。

新しい要素を追加する

新しい要素は、次の方法を使用して追加できます。

• append(): リストの最後に要素を追加します。
• insert(): 指定したインデックス位置に要素を挿入します。
• extend(): 別のリストの要素を既存のリストに追加します。

# 新しい要素の例
my_list = [1, 2, 3]
my_list.append(4) # [1, 2, 3, 4]
my_list.insert(1, 10) # [1, 10, 2, 3, 4]
my_list.extend([5, 6]) # [1, 10, 2, 3, 4, 5, 6]

要素の削除

要素は以下を使用して削除できます。

• pop(): インデックスに基づいて要素を削除します。デフォルトでは最後の要素が削除されます。
• remove(): 値に基づいて最初に一致した要素を削除します。
• clear(): リストからすべての要素を削除します。

# 要素の削除例
my_list = [1、2、3、4、5]
my_list.pop() # [1, 2, 3, 4]
my_list.remove(2) # [1, 3, 4]
my_list.clear() # []

配列モジュールを使用した動的操作

同じタイプの要素が必要な場合は、次のように使用できます。arrayモッド。

新しい要素を追加する

append()そしてextend()メソッドの適用先arrayモッド。

import array
my_array = array.array('i', [1, 2, 3])
my_array.append(4)  # [1, 2, 3, 4]
my_array.extend([5, 6])  # [1, 2, 3, 4, 5, 6]

要素の削除

remove()そしてpop()使用できるメソッドarrayモッド。

# 要素の削除例
my_array = array.array('i', [1, 2, 3, 4])
my_array.remove(2) # [1, 3, 4]
my_array.pop() # [1, 3]

結論は

Python には、配列を動的に増減するさまざまなメソッドが用意されています。listそしてarrayモジュールはさまざまなニーズに適しています。より多くの機能要件が必要な場合は、次の使用を検討することもできます。numpy。

Python の配列カウント

Pythonでは、list.count()統計に特化したツールです特定の要素の出現数方法。リストの長さを取得するのと同じですlen()それとは異なり、パラメータを比較オブジェクトとして渡す必要があります。

1. list.count()の基本構文

構文は次のとおりですlist.count(value)、リスト内に値が出現する回数を整数で返します。値が存在しない場合は 0 が返されます。

果物 = ['リンゴ'、'バナナ'、'リンゴ'、'オレンジ'、'リンゴ']

# 「apple」の出現数を数える
apple_count = フルーツ.カウント('リンゴ')
print(apple_count) # 出力: 3

# 存在しない要素をカウントする
グレープ_カウント = フルーツ.カウント('グレープ')
print(grape_count) # 出力: 0

2. 一般的な計数要件とツールの比較

ニーズ (単一の要素、複数の要素、またはすべての統計を探しているかどうか) に応じて、さまざまなベスト プラクティスがあります。

3. 高度なツール: collections.Counter

リスト内に「すべての要素」が一度に何回出現するかを知る必要がある場合は、次を使用します。Counter何度も走りますcount()はるかに効率的です (O(n) と O(n^2) の比較)。

コレクション輸入カウンターから

データ = [1、2、2、3、3、3、4]
カウント = カウンタ(データ)

print(counts) # 出力: Counter({3: 3, 2: 2, 1: 1, 4: 1})
print(counts[3]) # 回数を取得 3:3
print(counts.most_common(1)) # 最も多く出現する要素を取得します

4. 混乱しやすい使用上のリマインダー

• 存在を確認するために count を使用しないでください。要素がリストにあるかどうかを確認したいだけの場合は、次を使用します。if x in list比較するif list.count(x) > 0はるかに高速なので、in最初のものが見つかるとすぐに停止します。
• ネストされたリスト: count()「浅い比較」のみが実行されます。リストに別のリストが含まれている場合、そのリストはサブリスト内ではカウントされません。
• パフォーマンスに関するメモ:大規模なループ内で同じ長いリストへの呼び出しを繰り返すlist.count()パフォーマンスの大幅な低下につながるため、優先順位を付ける必要があります。Counter。

5. 実践的なスキル: 条件付きカウント

特定のロジック (たとえば、長さが 3 を超える文字列) に準拠する要素の数を数えたい場合は、以下を組み合わせることができます。sum()：

単語 = ['こんにちは'、'こんにちは'、'Python'、'a'、'コード']

# 長さ > 3 の単語の数を数える
big_word_count = sum(len(w) > 3 の場合、単語内の w に対して 1)
print(big_word_count) # 出力: 3

2D リストを結合する

要件の説明

• 2 つの 2D リスト、各要素は[key, value]。
• 最初の要素（キー）に対応します。
• キーが同じ場合、両側の 2 番目の要素は 2 番目と 3 番目の列にマージされます。
• 順序は必ずしも同じである必要はありません。

サンプルプログラム

リスト1 = [
    ["a", 1],
    [「b」、2]、
    ["c"、3]
]

リスト2 = [
    [「c」、30]、
    [「a」、10]、
    [「d」、40]
]

#list1 を dict に変換します
dict1 = {k: k の v、list1 の v}
dict2 = {k: k の v、list2 の v}

# すべてのキーを検索する
all_keys =sorted(set(dict1.keys()) | set(dict2.keys()))

# 結果をマージする
結合 = []
all_keys の k の場合:
    v1 = dict1.get(k)
    v2 = dict2.get(k)
    merged.append([k, v1, v2])

マージされた行の場合:
    印刷(行)

出力結果

['a', 1, 10]
['b', 2, None]
['c', 3, 30]
['d', None, 40]

結論は

• 辞書を使用してキーをすばやく比較します。
• 存在しない値を使用するNone埋める。
• 結果は 3 列の構造になります。[key, value1, value2]。

2 つのリストを同時にループする

Python では、2 つのリストがある場合 (例:selected_fields_listそしてaSqlValuesStr_list) を同時に反復処理する必要がある場合、最も一般的で Python 的な方法は、組み込みのzip()関数。

1. zip()関数を使用する

zip()この関数は、複数の反復可能オブジェクト (Iterable) を一連のタプルにパックします。ループの各反復により、各リストから対応する位置にある要素が削除されます。

輸入再

# これらが re.split() の後に取得される 2 つのリストであると仮定します。
selected_fields = "名前、年齢、都市"
aSqlValuesStr = "アリス、25 歳、台北"

selected_fields_list = re.split(r',', selected_fields)
aSqlValuesStr_list = re.split(r',', aSqlValuesStr)

# forループを実行する
フィールドの場合、zip 内の値 (selected_fields_list, aSqlValuesStr_list):
    print(f"フィールド: {フィールド}, 値: {値}")

2. サンプル出力

フィールド: 名前、値: アリス
フィールド: 年齢、値: 25
フィールド: 都市、値: 台北

3. zip() に関する重要な注意事項

使用するときはzip()関数を使用する場合は、次の点に注意する必要があります。

• リストの長さが矛盾しています: zip()反復は最も短いリストで停止します。もしselected_fields_list3つの要素があり、aSqlValuesStr_list要素が 4 つある場合、ループは 3 回だけ実行されます。
• 長さの不一致に対処する必要がある:2 つのリストの長さが正確に一致していることを確認する必要がある場合、または長いリストを優先させる必要がある場合は、次を使用する必要があります。itertools.zip_longest。

#例: リストの長さが矛盾しています
リスト1 = [1, 2, 3]
リスト2 = ['a', 'b']

zip(list1, list2)のitem1、item2の場合:
    print(項目1, 項目2)
#出力は次のようになります:
#1a
#2b

2D配列の表示を揃える

フォーマットを使用してフィールドを整列する

データ = [
    [1、23、456]、
    [7890、12、3]、
    [45、678、9]
】

# 各列の最大幅を計算します
Col_widths = [max(len(str(row[i])) for row in data) for i in range(len(data[0]))]

# 出力のフォーマット
データ内の行の場合:
    print(" ".join(str(val).rjust(col_widths[i]) for i, val in enumerate(row)))

出力結果

   1   23  456
7890   12    3
  45  678    9

表作成モジュールの使用

サードパーティのパッケージtabulate整列されたテーブルを直接出力できます。

from tabulate import tabulate

data = [
    [1, 23, 456],
    [7890, 12, 3],
    [45, 678, 9]
]

print(tabulate(data, tablefmt="grid"))

出力結果

+------+-----+-----+
|    1 |  23 | 456 |
| 7890 |  12 |   3 |
|   45 | 678 |   9 |
+------+-----+-----+

結論は

• 組み込みメソッド: 最初に列幅を計算してから、rjust()位置合わせ。
• 外部キット: 使用tabulate美しいテーブルを素早く生成します。

2次元配列浮動小数点数の整列出力

説明する

次の例は、2 次元リストを印刷する方法を示しています。要素がfloat小数点以下 2 桁の表示が修正され、フィールドの配置を維持したまま他の要素がそのまま出力されます。

プログラム例

データ = [
    [1、23.456、456]、
    [7890.1、12、3.5]、
    [45、678.9、9]
]

# 各要素の文字列をフォーマットする
フォーマットされたデータ = []
データ内の行の場合:
    新しい行 = []
    行の val の場合:
        if isinstance(val, float):
            s = f"{val:.2f}" # float -> 小数点以下 2 桁
        それ以外の場合:
            s = str(val)
        new_row.append(s)
    formatted_data.append(new_row)

# 各列の最大幅を計算します
Col_widths = [max(len(row[i]) for row in formatted_data) for i in range(len(formatted_data[0]))]

# 出力のフォーマット
formatted_data の行の場合:
    print(" ".join(val.rjust(col_widths[i]) for i, val in enumerate(row)))

出力結果

    1  23.46  456
7890.10     12  3.50
   45  678.90     9

集中

• 使用isinstance(val, float)浮動小数点数を決定します。
• を通してf"{val:.2f}"浮動小数点数を小数点以下 2 桁にフォーマットします。
• まずすべての要素を文字列に変換してから、列の幅を計算して列の位置を揃えます。

辞書リストからすべての値を抽出します

提供するデータ構造は複数の辞書を含むリストであり、各辞書は時系列レコード (K ライン データなど) を表します。

data = [
    {'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
    {'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'},
    # ...
]

すべてのレコードのすべての値を取得したい場合(1759028400000, '109398.3', '109364.8'など）それらをリストに収集すると、Nested List Comprehension を使用できます。

1. すべての値を 1 つのリストに抽出します (平坦化)

2 レベルのリスト内包表記を使用して、リスト内の各辞書を反復処理してから、.values()メソッドは値を取得し、最後にすべての値をフラット リストに収集します。

データ = [
    {'時間': 1759028400000, '開値': '109398.3', '終値': '109364.8', '高値': '109489.2', '安値': '109364.8', '音量': '518.7594'},
    {'時間': 1759024800000、'開値': '109305.6'、'終値': '109398.3'、'高値': '109496.4'、'安値': '109296.0'、'音量': '757.0290'}
]

すべての値 = [
    値
    for record in data # 外部リスト内の各辞書レコードを走査します
    for value in record.values() # 辞書レコード内のすべての値を走査します
]

print(all_values)

2. 結果の出力

これにより、すべての値を含む単一のリストが作成されます。

[1759028400000, '109398.3', '109364.8', '109489.2', '109364.8', '518.7594', 1759024800000, '109305.6', '109398.3', '109496.4', '109296.0', '757.0290']

3. 特定のフィールドの値を抽出する

特定のフィールドのみを抽出する必要がある場合 (例: すべてのフィールドのみ)open価格)、単一レベルのリスト内包表記を使用できます。

data = [
    {'time': 1759028400000, 'open': '109398.3', ...},
    {'time': 1759024800000, 'open': '109305.6', ...}
]

open_prices = [record['open'] for record in data]

print(open_prices)

出力結果:

['109398.3', '109305.6']

辞書リストから特定のキーの値を抽出します。

1. リスト内包表記を使用する (推奨) ✅

リスト内包表記は、既存のリストから新しいリストを作成するための簡潔な 1 行の構文です。

Pythonの実装例

日時インポート日時から

データリスト = [
    {'videoid': 'b5HxsaM_E2Y', 'publishedat': datetime(2025, 12, 7, 3, 0, 53), 'rankno': 7, 'viewcount': 913053, 'query': 'baseball'},
    {'videoid': 'FEbMCBxsoWI', 'publishedat': datetime(2025, 11, 25, 5, 28, 6), 'rankno': 13, 'viewcount': 754598, 'query': 'baseball'},
    {'videoid': 'nOJUI0PGB68', 'publishedat': datetime(2025, 12, 7, 3, 7, 46), 'rankno': 14, 'viewcount': 748349, 'query': 'baseball'},
    {'videoid': 'uMHXIudw_w0', 'publishedat': datetime(2025, 12, 2, 10, 1, 38), 'rankno': 8, 'viewcount': 687949, 'query': 'baseball'}
]

target_key = 'ビデオID'

# リスト内包表記を使用します: data_list の各辞書項目に対して、 item[target_key] を取り出します。
video_ids = [data_list 内のアイテムの item[target_key]]

print(f"抽出されたキー: {target_key}")
print("すべてのビデオID値:")
print(video_ids)

出力結果

['b5HxsaM_E2Y', 'FEbMCBxsoWI', 'nOJUI0PGB68', 'uMHXIudw_w0']

2. キーが存在しない可能性がある状況に対処する (安全なアクセス)

リスト内の一部の辞書にターゲット キーがない可能性がある場合 (たとえば、一部の辞書に `videoid` キーがない場合)、`item[target_key]` を直接使用すると、`KeyError` エラーがスローされます。辞書の `.get()` メソッドまたは条件を使用して、辞書を安全に処理できます。

Python実装例（セキュアアクセス）

data_with_missing_key = [
    {'videoid': 'A1', 'query': 'フットボール'},
    {'query': 'basketball'}, # 'videoid' キーがありません
    {'videoid': 'C3', 'query': 'バレーボール'}
】

target_key = 'ビデオID'

# オプション A: .get() を使用して、デフォルト値を None (または他の値) に設定します。
safe_video_ids_A = [data_with_missing_key 内のアイテムの item.get(target_key)]
# 出力: ['A1'、なし、'C3']

# オプション B: そのキーを持つ値のみを抽出します
safe_video_ids_B = [data_with_missing_key のアイテムの item[target_key]、アイテムの target_key の場合]
# 出力: ['A1', 'C3']

print(f"\n安全な抽出結果 (プラン B): {safe_video_ids_B}")

辞書値をリストに変換する

あなたからonesymbollist.values()取得された結果は Python 辞書ビュー オブジェクトですdict_values。これはリストのように見えますが、これは動的ビューであり、インデックスを付けたり変更したりできる標準のリストではありません。

dict_values([1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523'])

表示しないdict_values()タグの内容を取得するには、組み込みのメソッドを使用するのが最も簡単で一般的な方法です。list()関数はそれをリストにキャストします。

1.リスト（リスト）に変換する

意思dict_valuesに渡されましたlist()ビューオブジェクト内のすべての要素を新しい標準リストにただちにコピーする関数。

# これが取得した dict_values ビュー オブジェクトであると仮定します。
dict_values_object = your_dictionary.values() # onesymbollist が辞書であると仮定します

# ステップ: list() 関数を使用して変換します
result_list = リスト(dict_values_object)

print(結果リスト)

出力結果

[1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523']

2.タプルに変換する

不変のシーケンスを作成することが目的の場合は、次のように使用できます。tuple()関数はそれをタプルに変換します。

result_tuple = tuple(dict_values_object)

print(result_tuple)

出力結果

(1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523')

3. 直接反復 (変換は必要ありません)

ループ内で値を 1 つずつ処理するだけの場合は、明示的にリストに変換する必要はないことに注意してください。dict_valuesそれ自体は反復可能なオブジェクト (Iterable) です。

# これが取得した dict_values ビュー オブジェクトであると仮定します。
dict_values_object = your_dictionary.values()

print("要素を1つずつ出力:")
dict_values_object の値の場合:
    print(値)

要約すると、使用しますlist(your_dict.values())これは、クリーンで実用的な値のリストを取得する最も一般的な方法です。

辞書の値をカンマ区切りの文字列に変換します

から始めるdict_valuesビュー オブジェクトからすべての値を抽出し、それらをカンマとスペースのみで区切られた単一の文字列に結合します (例:1763510400000, '0.00015218', ...)、次の手順を組み合わせる必要があります。

1. 辞書から得るdict_valuesビューオブジェクト。
2. このビューオブジェクト内のすべての要素を文字列型に変換します。
3. Pythonの使用", ".join()これらの文字列を連結するメソッド。

1.Pythonの実装

元の辞書が次の名前であると仮定します。onesymbol_dict、文字列以外の値 (タイムスタンプなど) を文字列に変換して使用する必要があります。.join()接続を確立します。

onesymbol_dict = {
    「時間」: 1763510400000、
    'オープン': '0.00015218',
    '閉じる': '0.00015336',
    '高': '0.00015415',
    '低': '0.00015067',
    'ボリューム': '1634523'
}

# ステップ 1 と2: 値を取得し、すべての値を文字列に変換します
# リスト内包表記を使用して、すべての要素が文字列であることを確認します
value_as_strings = [onesymbol_dict.values() の v に対する str(v)]

# ステップ 3: ', '.join() を使用してこれらの文字列を結合します
value_string = ", ".join(values_as_strings)

print(値の文字列)

2. 結果の出力

これにより、外側の大括弧や角括弧のない、値のみが内容となる単一の文字列が生成されます。dict_valuesラベル：

1763510400000, 0.00015218, 0.00015336, 0.00015415, 0.00015067, 1634523

3. 文字列引用符に関する注意事項

予想される出力例では、タイムスタンプ以外の値が一重引用符で囲まれていることに注意してください。1763510400000, '0.00015218', ...。

最終出力で文字列値が一重引用符を保持することが目標の場合、連結中に手動で引用符を追加する必要があります。これは通常、SQL ステートメントまたは特定の形式の文字列を準備するときに必要です。

# 追加のステップ: 非整数値には引用符が必要であると想定して、引用符を手動で処理します
引用値 = []
onesymbol_dict.values() の v の場合:
    if isinstance(v, (str, float)) または (isinstance(v, int) および v< 1000000000000): # 假設小數字串需要引號
        quoted_values.append(f"'{v}'")
    else:
        quoted_values.append(str(v))

final_quoted_string = ", ".join(quoted_values)

print(final_quoted_string)

これにより、期待どおりの形式が得られます（次のように仮定します）time引用符は必要ありません。他の数値文字列は必要です):

1763510400000, '0.00015218', '0.00015336', '0.00015415', '0.00015067', '1634523'

文字列が数値かどうかを判断する

str.isdigit() を使用する

isdigit()メソッドを使用して、文字列に数字のみが含まれているかどうかを確認できます。

# 例
文字列 = "12345"
string.isdigit() の場合:
    print("は数値です")
それ以外の場合:
    print("数値ではありません")

知らせ：isdigit()小数点や負号は扱えません。

小数を処理するには str.replace() を使用します

小数点を含む文字列をチェックする必要がある場合は、使用する前に小数点を削除できます。isdigit()。

# 例
文字列 = "123.45"
if string.replace(".", "").isdigit():
    print("は数値です")
それ以外の場合:
    print("数値ではありません")

この方法は負の数では機能しません。

try-excel を使用して数値に変換する

最も一般的なアプローチは、文字列を浮動小数点または整数に変換し、変換が失敗した場合に例外をキャッチすることです。

# 例
文字列 = "-123.45"
試してみてください:
    float(string) # 代わりに int(string) を使用して整数をチェックできます
    print("は数値です")
ValueError を除く:
    print("数値ではありません")

正規表現を使用する

正規表現は、整数、小数、負の数を含む数値と正確に一致します。

# 例
輸入再

文字列 = "-123.45"
パターン = r"^-?\d+(\.\d+)?$"
if re.match(パターン, 文字列):
    print("は数値です")
それ以外の場合:
    print("数値ではありません")

結論は

単純な場合には、次を使用します。isdigit()。より複雑な場合（小数や負の数の処理など）には、次の使用をお勧めします。try-exceptまたは正規表現。

Python f-string

f-string (フォーマットされた文字列リテラル) は、Python 3.6 で導入された強力で効率的な文字列フォーマット方法です。変数や式の値を文字列に埋め込むための、簡潔で読みやすい方法を提供します。

f-string の中心的な機能は、文字列の先頭にプレフィックスを使用することです。fまたはF、中括弧を使用する{}計算して表示する内容を含めます。

1. 基本的な使い方：変数を埋め込む

中括弧内に変数名を直接入れることができます。

名前＝「アリス」
年齢=30歳
message = f「こんにちは、私の名前は {name}、年齢は {age} です。」
# 出力: こんにちは、私の名前はアリス、30 歳です。

2. 埋め込み式

f-string の利点は、有効な Python 式を中括弧内に置くことができ、それが実行時に評価されることです。

価格 = 19.99
税率 = 0.05
合計 = 価格 * (1 + 税率)

# f-string 内で計算を実行する
result = f"税込みの合計価格は: {price * (1 + Tax_rate):.2f} 元です。"
# 出力: 税込みの合計価格: 20.99 元。

# 関数の呼び出し
def get_status():
    「OK」を返します

status_msg = f"システムステータス: {get_status()}"
# 出力: システムステータス: OK

3. 文字列のフォーマットと配置

f 文字列のサポートと.format()コロンを使用した書式指定子ミニ言語と同じ方法:式と書式指定子を区切ります。

4. F ストリングのデバッグ

Python 3.8 以降、f-string には、変数の後に等号を追加できる便利なデバッグ機能が導入されています。=、変数名とその値が自動的に表示されます。

ユーザーID = 42
is_active = True

debug_output = f"ユーザー ID は {user_id=}、ステータス: {is_active=}"
# 出力: ユーザー ID は user_id=42、ステータス: is_active=True

5. 注意事項

• 引用符: f 文字列内の式では、外側の文字列とは異なる引用符の種類を使用できます。一重引用符が外側で使用されている場合'...'内で二重引用符を使用できます"..."、逆に。
• 中括弧: f 文字列内のリテラル値の中括弧を表示する必要がある場合は、二重中括弧を使用します。{{}}。
• バックスラッシュ: f 文字列内のバックスラッシュ\次のような文字列形式を表すために使用することは許可されていません。f"{{'\n'}}"エラーの原因となります。

f-string は浮動小数点小数点を表示しません

1. 解決策 1: f 文字列内の整数変換 (推奨)

F 文字列の中括弧{}内部的には直接使用できますint()この関数は変数を整数型に変換し直します。これは最も明確で直接的な方法です。

Pythonの実装例

inta = 12 # 生の整数を仮定します
float_a = inta * 2.0 # 結果は 24.0 (浮動小数点数)

# f-string で浮動小数点数を直接整数に変換します
result_str = f"abc def {int(float_a)}"

print(f"元の値(float_a): {float_a}")
print(f"フォーマットされた結果: {result_str}")

2. オプション 2: f-string 形式指定子を使用する (形式指定子)

書式設定ミニ言語の整数形式コードを使用できます。dまたは.0f出力形式を制御します。

A. 整数形式のコードを使用する:d

使用:dPython は、表示時に値を整数として扱うように求められます。変数の場合aは浮動小数点数であるため、Python は表示する前に自動的に最も近い整数に丸めます (計算結果が $24.0$ の場合は、$24$ が表示されます)。

float_a = 24.0
result_d = f"abc def {float_a:d}"
# 出力: abc def 24

B. 浮動小数点形式のコードを使用する:.0f

使用:.0f値を浮動小数点数としてフォーマットしますが、小数点以下の桁は 0 桁である必要があることを意味します。これにより、表示前に結果が丸められます。

float_a = 24.0
result_0f = f"abc def {float_a:.0f}"
# 出力: abc def 24

要約と提案

結果が小数点のない絶対整数であることを確認することが目的の場合は、オプション 1 を使用することをお勧めします。

str = f"abc def {int(a)}"

Pythonのre.split関数

Pythonでは、re.split()機能はre(正規表現) モジュールの強力なツール。正規表現で定義された区切り文字 (パターン) に従って文字列を分割し、結果をリスト (リスト) として返すために使用されます。

1. 関数の構文

re.split(pattern, string, maxsplit=0, flags=0)

• pattern: 文字列を分割するために使用される正規表現パターン。
• string: カット対象の文字列。
• maxsplit(オプション): 最大カット数を指定します。デフォルト値 0 は、カット数に制限がないことを意味します。
• flags(オプション): 正規表現の動作を制御するフラグ (例:re.IGNORECASE）。

2. 基本的な使い方

正規表現を使用して、複数または複雑な区切り文字を定義します。

輸入再

text = "リンゴ、バナナ、オレンジ、ブドウ"
# 区切り文字としてカンマ、セミコロン、またはハイフンを使用します
result = re.split(r'[;,-]', text)

印刷(結果)
# 出力: ['リンゴ'、'バナナ'、'オレンジ'、'グレープ']

3. 複数のスペースの処理 (一般的な用途)

標準的な文字列を使用した場合split()違う、re.split()複数の連続する区切り文字 (複数のスペースなど) は簡単に処理して無視できます。

テキスト = "単語 1 単語 2 単語 3"
# \s+ を使用して 1 つ以上の空白文字を区切り文字として一致させます
result = re.split(r'\s+', text)

印刷(結果)
# 出力: ['Word1', 'Word2', 'Word3']

4. maxsplit を使用してカット数を制限する

設定されている場合maxsplitの場合、切り取り操作は指定された回数だけ実行され、残りの部分は最後の要素としてリストに保持されます。

テキスト = "1:2:3:4"
# カットは一度だけ
結果 = re.split(r':', テキスト, maxsplit=1)

印刷(結果)
# 出力: ['1', '2:3:4']

5. 区切り文字を保持する

括弧内に区切り文字パターンを配置すると、()の場合、区切り文字自体も結果リストの要素の間に含まれます。

テキスト = "2025-01-15"
# 保持されるようにハイフンを括弧内に入れます
result = re.split(r'(-)', text)

印刷(結果)
# 出力: ['2025', '-', '01', '-', '15']

文字列の先頭を判定する

使用

startswith()は Python 文字列 (str) オブジェクト メソッド。文字列が指定された部分文字列で始まるかどうかを判断するために使用されます。 一致した場合は返すTrue;それ以外の場合は戻るFalse。

文法

str.startswith(prefix[, start[, end]])

パラメータの説明

• prefix: 比較する開始文字列は、単一の文字列または文字列のタプルにすることができます。
• start(オプション): 元の文字列のどのインデックス位置から判断を開始するかを指定します。
• end(オプション): インデックス位置 (末尾を除く) を指定します。

戻り値

ブール値: 文字列が指定されたプレフィックスで始まる場合、戻り値True、さもないとFalse。

例

text = "Python プログラミング"

#基本的な使い方
print(text.startswith("Py")) # True
print(text.startswith("Java")) # False

#範囲指定
print(text.startswith("thon", 2)) # True (インデックス 2 から始まるのは "thon")

# 複数のアライメント
print(text.startswith(("Py", "Java", "C"))) # True、一致するものがあるため

# 大文字と小文字は区別されません（最初に小文字に変換できます）
print(text. lower().startswith("py")) # True

一般的なアプリケーション

• ファイル名かURLの判定：

  URL = "https://openai.com"
  url.startswith("https://") の場合:
      print("安全な接続 URL")

• フィルタリスト:

  
  files = ["data1.csv", "data2.csv", "readme.txt"]
  csv_files = [f for f in files if f.startswith("data")]
  print(csv_files)  # ['data1.csv', 'data2.csv']
  

伸ばす

文字列が特定のテキストで「終わる」かどうかを判断するには、次を使用できます。endswith()メソッド、構文、startswith()同じ。

ファイル名 = "レポート.pdf"
if filename.endswith(".pdf"):
    print("これはPDFファイルです")

文字列の最後の文字を削除します

説明する

Python では、文字列は不変オブジェクトです。 最後の文字を削除するには、通常、文字列のスライスを使用して新しい文字列を作成します。

例

テキスト = "こんにちは!"

#方法 1: スライスを使用する
new_text = テキスト[:-1]
print(new_text) #出力: こんにちは

#方法 2: rstrip() を使用して特定の終了文字を削除する
text2 = "こんにちは!!!"
new_text2 = text2.rstrip("!")
print(new_text2) #出力: こんにちは

#方法 3: 空でないことを確認してから最後の文字を削除する
テキストの場合:
    テキスト = テキスト[:-1]
印刷(テキスト)

出力結果

Hello
Hello
Hello

説明する

• text[:-1]先頭から最後から2番目の文字までの部分文字列が取り出されます。
• rstrip(chars)末尾の指定文字（1文字に限らず）を削除できます。
• スライスする前に、値のエラーを避けるために文字列が空かどうかを確認できます。

伸ばす

先頭の文字を削除するには、次を使用します。

text = text[1:]

要約する

• 最後の文字を削除する最も簡単な方法は次のとおりです。s[:-1]。
• 特定の末尾文字を削除するには、次の使用をお勧めします。rstrip()。

文字列内の部分文字列の前のコンテンツを検索します

問題文

文字列を与えるstr1で見つかることを願っていますstrAまたはstrBその前にある部分。例えば：

str1 = "Hello World, this is a test. Stop here or continue."
strA = "Stop"
strB = "continue"

目標は取得することです"Hello World, this is a test. "。

re.split() を使用する

re.split()複数のキーワードに基づいて文字列を分割し、最初の部分を取得できます。

import re

def get_substring_before(text, strA, strB):
    result = re.split(f"{re.escape(strA)}|{re.escape(strB)}", text, maxsplit=1)[0]
    return result

str1 = "Hello World, this is a test. Stop here or continue."
strA = "Stop"
strB = "continue"

print(get_substring_before(str1, strA, strB))  # "Hello World, this is a test. "

re.search() を使用する

re.search()一致するために使用できますstrAまたはstrB、一致する前にコンテンツを取得します。

import re

def get_substring_before(text, strA, strB):
    match = re.search(f"{re.escape(strA)}|{re.escape(strB)}", text)
    return text[:match.start()] if match else text

str1 = "Hello World, this is a test. Stop here or continue."
print(get_substring_before(str1, "Stop", "continue"))  # "Hello World, this is a test. "

find()メソッドを使用する

find()最も古いものを手動で検索できますstrAまたはstrBをクリックして、対応する部分を取得します。

def get_substring_before(text, strA, strB):
    indexA = text.find(strA)
    indexB = text.find(strB)
    
    indices = [i for i in [indexA, indexB] if i != -1]
    first_index = min(indices, default=len(text))
    
    return text[:first_index]

str1 = "Hello World, this is a test. Stop here or continue."
print(get_substring_before(str1, "Stop", "continue"))  # "Hello World, this is a test. "

結論は

• 使用re.split()最も単純で、単一の検索に適しています。
• 使用re.search()より柔軟な定期的なマッチングを提供します。
• 使用find()この方法は最も効率的であり、単純な文字列処理に適しています。

複数の値を文字列に連結します

結合を使用します (最初にすべてを文字列に変換する必要があります)

値 = ["str1", "str2", 123, "str3", 456]

s = ", ".join(値の v に対する str(v))
print(s) # 出力: str1、str2、123、str3、456

文字列と整数の混合を自動的に処理する

def join_values(*args, sep=", "):
    return sep.join(str(v) for v in args)

print(join_values("str1", "str2", 88, "str3"))
# 出力: str1、str2、88、str3

ソースが辞書の場合、キーでソートしてから連結します

データ = {
    "str1": "こんにちは",
    "str2": "ワールド",
    "int1": 123、
    "str3": "わかりました"
}

# キーでソートしてから結合する
s = ", ".join(str(data[k]) for k insorted(data.keys()))
print(s) # hello、world、123、ok

キーと値を結合するには

s = ", ".join(f"{k}={v}" for k, v in data.items())
印刷する
# 出力: str1=hello、str2=world、int1=123、str3=ok

ソースは辞書のリストであり、各辞書は 1 つの列に結合されます。

rows = [
    {"str1": "A", "int1": 10},
    {"str1": "B", "int1": 20},
]

for row in rows:
    print(", ".join(str(v) for v in row.values()))
# A, 10
# B, 20

ユニバーサル機能: 「引用符あり」モードと「引用符なし」モードの切り替え

def join_values(values, sep=", ", quote=False):
    引用された場合:
        # 完全な一重引用符「 」を使用します
        return sep.join(f"‘{v}’" for v in value)
    それ以外の場合:
        return sep.join(str(v) for v in value)

値 = ["str1", "str2", 88, "str3"]

print(join_values(values, quote=False))
# 出力: str1、str2、88、str3

print(join_values(values, quote=True))
# 出力: 'str1'、'str2'、'88'、'str3'

*args 入力バージョンをサポートできます

def join_args(*args, sep=", ", quoted=False):
    if quoted:
        return sep.join(f"‘{v}’" for v in args)
    return sep.join(str(v) for v in args)

print(join_args("str1", "str2", 88, "str3", quoted=True))
# ‘str1’, ‘str2’, ‘88’, ‘str3’

dict をサポート (出力値のみ)

data = {"str1": "hello", "str2": "world", "int1": 123}

print(join_values(data.values(), quoted=True))
# ‘hello’, ‘world’, ‘123’

key=value形式をサポート

def join_key_value(d, sep=", ", quoted=False):
    if quoted:
        return sep.join(f"{k}=‘{v}’" for k, v in d.items())
    return sep.join(f"{k}={v}" for k, v in d.items())

print(join_key_value(data, quoted=True))
# str1=‘hello’, str2=‘world’, int1=‘123’

re.match()

re.match()

パイソンre.match正規表現モジュール内の関数で、文字列の先頭から一致させるために使用されます。 一致が成功した場合は、Match物体;それ以外の場合は戻るNone。

文法

re.match(pattern, string, flags=0)

パラメータの説明:

• pattern: 照合する正規表現。
• string: チェックする文字列。
• flags: 一致動作を変更するために使用されるオプションのパラメータ。たとえば、re.IGNORECASE。

共通のプロパティとメソッド

• group(n)：最初に戻るn捕捉されたサブグループ、n=0一致全体を返します。
• start(): 試合の開始位置を返します。
• end(): 一致の終了位置を返します。
• span(): 一致する範囲 (開始、終了) を返します。

使用例

輸入再

#文字列を定義する
text = "123 Hello World!"

# re.match を使用して番号を先頭から照合します
match = re.match(r"(\d+)\s+(.*)", text)

一致する場合:
    print(f"一致結果全体: {match.group(0)}") # 123 Hello World!
    print(f"数値部分: {match.group(1)}") # 123
    print(f"テキスト部分: {match.group(2)}") # Hello World!
それ以外の場合:
    print("一致に失敗しました")

出力結果

整个適合結果: 123 Hello World!
数字部分：123
テキスト部分: Hello World!

注意事項

• re.match文字列の先頭からのみ一致し、先頭が一致しない場合は戻ります。None。
• グローバルに検索する必要がある場合は、次を使用します。re.searchまたはre.findall。

正規表現

正規表現 (略して Regex) は、文字列一致ルールを記述するために使用される構文です。文字列の検索、置換、検証によく使用されます。 Pythonでreモジュールでは、patternこれがこれらのルールを定義する中心部分です。

基本的な構文要素

• 文字クラス：
  • \d: 任意の数値 (0 ～ 9) と一致します。
  • \D: 数値以外のものと一致します。
  • \w: 任意の 1 文字 (文字、数字、アンダースコア) と一致します。
  • \W: 任意の非単一文字と一致します。
  • \s: 任意の空白文字 (スペース、タブなど) と一致します。
  • \S: 空白以外の文字と一致します。
  • .: 改行文字 (\n) 単一の文字を除きます。
• 量指定子：
  • *: 前の式と 0 回以上一致します。
  • +: 前の式と 1 回以上一致します。
  • ?: 前の式と 0 回または 1 回一致します。
  • {n}: 前の式と正確に n 回一致します。
  • {n,}: 前の式と少なくとも n 回一致します。
  • {n,m}: 前の式と少なくとも n 回、最大 m 回一致します。
• 境界線の記号：
  • ^: 文字列の先頭と一致します。
  • $: 文字列の末尾と一致します。
  • \b: 単語の境界 (単語の先頭または末尾など) と一致します。
  • \B: 単語以外の境界に一致します。
• グループ化と選択：
  • (...):グループ化、括弧内の内容をキャプチャします。
  • |: 論理「または」、などa|bマッチaまたはb。
  • (?:...): グループ化しますが、コンテンツはキャプチャしません。

高度な使用法

• 先読みと後読み：
  • (?=...): 今後、試合の後には指定されたコンテンツが続く必要があります。
  • (?!...): 否定的な参照、一致の後に指定されたコンテンツを続けることはできません。
  • (?<=...): 前方参照、マッチングの前に指定されたコンテンツが存在する必要があります。
  • (?<!...): ネガティブ ルックバック。指定されたコンテンツを一致の前に置くことはできません。

例

輸入再

# 例 1: 数字で始まるコンテンツの一致
パターン = r"^\d+"
テキスト = "123abc"
match = re.match(パターン, テキスト)
一致する場合:
    print(f"マッチング結果: {match.group()}") # 出力: 123

#例 2: 数字の後のテキストと一致する
パターン = r"(\d+)\s+(.*)"
text = "123 ハローワールド"
match = re.match(パターン, テキスト)
一致する場合:
    print(f"数値部分: {match.group(1)}") # 出力: 123
    print(f"テキスト部分: {match.group(2)}") # 出力: Hello World

正規表現の応用シナリオ

• 電子メール アドレスまたは電話番号の形式を確認してください。
• テキストから日付や URL などの特定のデータを抽出します。
• 句読点をスペースに置き換えるなど、テキストをバッチ置換します。

re.search()の応用

基本的な使い方

re.search()文字列内の正規表現に最初に一致するものを検索し、それを返すために使用されます。Matchオブジェクト、一致しない場合に返されるNone。

輸入再

text = "こんにちは 2024 年!"
match = re.search(r"\d+", text)

一致する場合:
    print("見つかった番号:", match.group()) # 2024

Match オブジェクトを返す

いつre.search()一致するものが見つかった場合は返されますMatchオブジェクトは次の方法で情報にアクセスできます。

• group(): 一致した文字列を返します
• start(): 一致する開始インデックス
• end():一致の終了インデックス
• span():インデックス範囲(開始、終了)を返します。

輸入再

text = "Python 3.10 は素晴らしいです!"
match = re.search(r"\d+\.\d+", text)

一致する場合:
    print("一致する内容:", match.group()) # 3.10
    print("開始インデックス:", match.start()) # 7
    print("終了インデックス:", match.end()) # 11
    print("範囲:", match.span()) # (7, 11)

グループマッチングを使用する

括弧を通して()グループを作成して使用するにはgroup(n)対応する一致するコンテンツを抽出します。

輸入再

text = "ジョン・ドゥ、年齢: 25"
match = re.search(r"(\w+) (\w+), 年齢: (\d+)", text)

一致する場合:
    print("姓:", match.group(1)) # ジョン
    print("name:", match.group(2)) # Doe
    print("年齢:", match.group(3)) # 25

re.findall() との比較

re.search()最初に一致した結果のみが返されますが、re.findall()一致するすべての結果が返されます。

import re

text = "Price: $10, Discount: $2, Tax: $1"

match = re.search(r"\$\d+", text)
print("re.search:", match.group())  # $10

matches = re.findall(r"\$\d+", text)
print("re.findall:", matches)  # ['$10', '$2', '$1']

結論は

re.search()最初に一致する結果を見つけるのに適しており、次の用途に使用できます。Match詳細情報を取得するオブジェクト。複数の一致結果を得るには、次を使用します。re.findall()。

正規表現の非キャプチャ グループ

マッチングパフォーマンスの向上

正規表現では、(...)一致するコンテンツがキャプチャされ、保存されます。group(n)、ただしキャプチャグループではありません(?:...)これは組織構造にのみ使用され、グループ番号には影響しないため、マッチングが高速になります。

グループインデックスへの影響を避ける

正規表現で使用する場合()に影響を与えるマッチング条件を整理するためgroup(n)番号。使用(?:...)これにより、グループ インデックスが変更されないことが保証されます。

import re

text = "2024-03-12"
pattern = r"(\d{4})-(?:\d{2})-(\d{2})"

match = re.search(pattern, text)
print(match.group(1))  # 2024
print(match.group(2))  # 12

OR 演算子と組み合わせる

使用(?:...|...)させられる|演算子は、一致するコンテンツには影響しますが、グループ アクセスには影響しません。

import re

text = "bar123"
pattern = r"(?:foo|bar|baz)\d+"

match = re.search(pattern, text)
print(match.group())  # bar123

--user-data-dir 解析に適用されます

Chrome パラメータを解析するときは、次を使用します。(?:...)これにより、一致する形式がグループ番号に影響を与えなくなります。

import re

cmdline = '--user-data-dir="C:\\Users\\moirg\\AppData\\Local\\Google\\Chrome\\User Data"'

match = re.search(r'--user-data-dir=(?:"([^"]+)"|(\S+))', cmdline)
user_data_dir = match.group(1) or match.group(2)

print(user_data_dir)  # C:\Users\moirg\AppData\Local\Google\Chrome\User Data

結論は

(?:...)正規表現のパフォーマンスを向上させ、グループ インデックスへの影響を回避でき、次の用途に適しています。|操作と特定の条件のマッチングにより、コードがより効率的かつ明確になります。

Python の日時

インポートモジュール

import datetime

現在時刻を取得する

now = datetime.datetime.now()
print(now)

指定した時間を作成する

dt = datetime.datetime(2025, 7, 2, 14, 30, 0)
print(dt)

時刻文字列のフォーマット

now = datetime.datetime.now()
formatted = now.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)

時間文字列を解析する

dt_str = "2025-07-02 14:30:00"
parsed = datetime.datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
print(parsed)

時間の足し算と引き算

now = datetime.datetime.now()
delta = datetime.timedelta(days=7)
next_week = now + delta
print(next_week)

今日の日付を取得する

today = datetime.date.today()
print(today)

日付を比較する

dt1 = datetime.datetime(2025, 7, 1)
dt2 = datetime.datetime(2025, 7, 2)
print(dt1 < dt2)

時差を取得する

dt1 = datetime.datetime(2025, 7, 1, 12, 0, 0)
dt2 = datetime.datetime(2025, 7, 2, 14, 30, 0)
diff = dt2 - dt1
print(diff)
print(diff.total_seconds())

曜日を取得する

今日 = datetime.date.today()
print(today.weekday()) # 0 = 月曜日、6 = 日曜日

日時のタイムゾーンの問題

オフセット ナイーブおよびオフセット対応の日時減算エラー

一方の datetime オブジェクトにはタイム ゾーンがなく (ナイーブ)、もう一方にはタイム ゾーンがある (認識) 場合に減算すると、次のようになります。

TypeError: can't subtract offset-naive and offset-aware datetimes

datetime がナイーブであるか認識しているかを確認する

from datetime import datetime

def is_aware(dt):
    return dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None

def is_naive(dt):
    return not is_aware(dt)

dt1 = datetime.now()                 # naive
dt2 = datetime.now().astimezone()    # aware

print(is_naive(dt1), is_aware(dt1))
print(is_naive(dt2), is_aware(dt2))

解決策 A: 認識型に変換する (推奨)

タイムゾーンを越える状況や、正確な時間計算が必要な場合に適しています。

from datetime import datetime、timezone

sql_dt = sql_dt.replace(tzinfo=timezone.utc) # SQL データ転送を認識
now_dt = datetime.now(timezone.utc) # 現在の時刻を認識するように使用します

diff = now_dt - sql_dt
print(diff.total_秒())

解決策 B: ナイーブに変換する (推奨されません。タイムゾーンの違いは無視されます)

sql_dt = sql_dt.replace(tzinfo=None)
now_dt = datetime.now()

diff = now_dt - sql_dt

要約する

• 2 つの日時は両方ともナイーブであるか、両方とも減算されることを認識している必要があります。
• タイムゾーンエラーを避けるために、すべてのデータを UTC 対応に変換することをお勧めします。

系列の標準偏差を計算する

説明する

Python では、組み込みモジュールを使用できますstatisticsのstdev()またはpstdev()標本標準偏差または母集団標準偏差を計算します。

例

統計をインポートする

比率 = [2.3, 2.8, 3.1, 2.5, 3.0]

# 平均
平均 = 合計(比率) / len(比率)

#サンプル標準偏差 (n-1)
std_sample = 統計.stdev(比率)

#行列標準偏差 (n)
std_population = 統計.pstdev(比率)

print(f"平均: {平均:.2f}")
print(f"サンプル標準偏差: {std_sample:.3f}")
print(f"母集団標準偏差: {std_population:.3f}")

出力結果

平均: 2.74
サンプル標準偏差: 0.303
母集団標準偏差: 0.271

計算式の方法（MODを使わない）

頼りたくないならstatisticsモジュールでは、数式を使用して自分で計算できます。

比率 = [2.3, 2.8, 3.1, 2.5, 3.0]
平均 = 合計(比率) / len(比率)

#標準偏差 (母集団)
分散 = sum((x - 平均) ** 比率の x には 2) / len(比率)
std_dev = 分散 ** 0.5

print(f"標準偏差: {std_dev:.3f}")

出力結果

標準偏差: 0.271

相違点の説明

• statistics.stdev(): サンプル標準偏差 (で割った値)n-1）
• statistics.pstdev(): 親の標準偏差 (で割った値)n）
• データが行列全体の場合 → を使用pstdev()
• データがサンプルの場合→使用stdev()

要約する

• 平均値:avg = sum(data) / len(data)
• サンプル標準偏差:statistics.stdev(data)
• 親の標準偏差:statistics.pstdev(data)

Python は ANSI カラー文字列を表示します

基本的な例

# ANSI カラーコードの例
print("\033[31m 赤文字\033[0m")
print("\033[32m 緑色のテキスト\033[0m")
print("\033[33m黄色のテキスト\033[0m")
print("\033[34m 青文字\033[0m")
print("\033[35m 紫色のテキスト\033[0m")
print("\033[36m シアンのテキスト\033[0m")
print("\033[37m 白文字\033[0m")

太字と背景色

print("\033[1;31m 太字の赤文字\033[0m")
print("\033[42m 緑色の背景テキスト\033[0m")

カスタム色の組み合わせ

# 格式: \033[样式;前景色;背景色m
# スタイル: 0=デフォルト、1=太字、4=下線
# 前景色: 30~37
# 背景色: 40~47

print("\033[1;33;44m 太字の黄色のテキスト + 青色の背景\033[0m")

関数にカプセル化できる

def color_text(text, color_code):
    f"\033[{color_code}m{text}\033[0m"を返す]

print(color_text("警告!", "1;31")) # 太字の赤
print(color_text("成功!", "1;32")) # 太字の緑色

現在の端末が ANSI カラーをサポートしているかどうかを確認する

方法 1: sys.stdout.isatty() を確認する

インポートシステム

sys.stdout.isatty() の場合:
    print("端末は ANSI カラーをサポートしている可能性があります")
それ以外の場合:
    print("カラーに対応していないファイルまたは出力環境の可能性があります")

方法 2: colorama を使用する (クロスプラットフォーム ソリューション)

輸入コロラマ
colorama.init()

print("\033[32mこのテキストは緑色でなければなりません\033[0m")

方法 3: 実際のテスト出力

def support_ansi():
    試してみてください:
        print("\033[31m テストレッド\033[0m")
        Trueを返す
    以下を除く：
        Falseを返す

print("ANSI はサポートされています" ifsupports_ansi() else "ANSI はサポートされていません")

補充する

• Linux/macOS 端末は通常、デフォルトで ANSI カラーをサポートします。
• Windows 10 では、以前は追加のツールをインストールするか、colorama。
• 出力がファイルに送られる場合、カラー コードは色ではなくテキストとして表示されます。

Python 入力はオートコンプリートをサポートします

説明する

Pythonでは、input()機能自体は対応していないTab自動的に完了します。 この機能を実現するには、以下を組み合わせることができますreadlineユーザーが使用できるようにするモジュールTabオートコンプリートを実行します (Bash または IPython と同様)。

基本的な例

リードラインをインポートする

# 補完できる文字列のリストを定義します
WORDS = ['リンゴ'、'バナナ'、'チェリー'、'ブドウ'、'オレンジ'、'スイカ']

def コンプリーター(テキスト、状態):
    """オートコンプリート機能: 入力された接頭辞に基づいて利用可能な文字列を比較します"""
    options = [w for w in WORDS if w.startswith(text)]
    if 状態 <;長さ(オプション):
        戻り値のオプション[状態]
    それ以外の場合:
        なしを返す

# 補完機能を有効にする
readline.set_completer(コンプリーター)
readline.parse_and_bind('タブ: 完了')

# ユーザー入力 (タブをサポート)
user_input = input("果物の名前を入力してください (Tab キーを押して入力できます): ")
print(f"入力した内容は: {user_input}")

取扱説明書

• readline.set_completer()自動完了ロジックを設定します。
• readline.parse_and_bind('tab: complete')させてTabキーによりオートコンプリートがトリガーされます。
• completer(text, state)：
  • text現在入力されているテキストです。
  • state一致する項目 (0、1、2...) を表します。
  • 一致するものがない場合は戻りますNone。

詳細: 動的補完

現在のコンテキストまたは動的コンテンツに基づいて補完リストを更新することもできます。

リードラインをインポートする

defdynamic_completer(テキスト、状態):
    current_words = ['猫'、'車'、'犬'、'アヒル'、'鹿']
    options = [w for w in current_words if w.startswith(text)]
    if 状態 <;長さ(オプション):
        戻り値のオプション[状態]
    なしを返す

readline.set_completer(dynamic_completer)
readline.parse_and_bind('タブ: 完了')

command = input("動物の名前を入力してください: ")
print("次を入力します:", コマンド)

注意事項

• readlineモジュールは入っていますLinux / macOS上記のプリセットが利用可能です。
• 存在するWindowsでは、パッケージをインストールする必要があります。

  pip install pyreadline3

• この方法は端末 (コンソール) でのみ機能し、GUI または非対話型環境では使用できません。

要約する

• 使用readlineモジュールにより可能input()タブ補完をサポートします。
• 入力内容に応じて補完ロジックをカスタマイズできます。
• Windowsには追加のインストールが必要ですpyreadline3キット。

Pythonプロセス

Python ループ

range() 付きの場合

最も一般的なループは、固定回数またはシーケンスを実行するために使用されます。

#0から4まで
range(5) の i の場合:
    print(i) #0,1,2,3,4

#開始点、終了点、ステップサイズを指定します
range(2, 10, 2) の i の場合:
    print(i) #2,4,6,8

反復可能なオブジェクトの場合

リスト、文字列、辞書などを直接反復します。

果物 = [「リンゴ」、「バナナ」、「チェリー」]

果物の中の果物の場合：
    プリント(フルーツ)

「こんにちは」の ch の場合:
    印刷(ch)

#辞書を反復処理する
person = {"名前": "トム", "年齢": 25}
person.items() のキーと値の場合:
    print(キー, 値)

while ループ

条件が True の場合は常に実行されます。

count = 0
while count < 5:
    print(count)
    count += 1

中断して継続する

ループ処理を制御します。

range(10) 内の i の場合:
    i == 3の場合:
        続行 # 今回はスキップします
    i == 7の場合:
        休憩 # 早めに終了
    印刷(i)

ネストされたループ

サークルに戻ってサークルに戻します。

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

else のループマッチング

for または while を追加できますelseの場合は「正常終了（ブレークなし）」のみ実行されます。

range(5) の i の場合:
    印刷(i)
それ以外の場合:
    print("ループが正常に終了")

リストの内包理解

簡潔な記述方法では、1 行でループを完了し、リストを生成できます。

squares = [x**2 for x in range(5)]
print(squares)  # [0,1,4,9,16]

結論は

• for in range()：固定時間やシーケンスに適しています。
• 反復可能なオブジェクトの場合: リスト、文字列、辞書の処理に適しています。
• while：回数無制限、条件により終了するループに適しています。
• break / continue / else：ループ処理を制御します。
• リスト生成: データを 1 行ですばやく生成します。

Pythonの例外処理

基本的な文法構造

Python は、try...Except ステートメントを使用して、プログラムの実行中に発生するエラーをインターセプトして処理し、プログラムのクラッシュを防ぎます。

試してみてください:
    # 例外を引き起こす可能性のあるコード
    結果=10/0
ZeroDivisionError を除く:
    # 特定の例外が発生したときに実行されるコード
    print("除数をゼロにすることはできません")
e としての例外を除く:
    #他のすべてのタイプの例外をキャッチする
    print(f"エラーが発生しました: {e}")
それ以外の場合:
    # tryブロックで例外が発生しなければ実行
    print("正常に動作しています")
最後に：
    # 例外発生の有無に関わらず実行される
    print("リソースをクリーンアップするか、ファイルを閉じる")

ブロック機能の説明

• try: 監視対象のコード スニペットを配置します。
• ただし、特定のエラー タイプを処理するためのロジックを定義します。 as を使用すると、エラー メッセージを取得できます。
• else: オプションのブロック。エラーがない場合にのみプログラム コードが実行されます。
• finally: オプションのブロック。通常はデータベース接続またはファイルを閉じてリソースを確実に解放するために使用されます。

複数の例外をキャッチする

例外でタプルを使用すると、複数のエラー タイプを同時に処理できます。

試してみてください:
    # 操作を実行する
    パスする
(ValueError、TypeError) を除く:
    print("入力されたデータ型または値が正しくありません")

積極的に例外をスローする

raise キーワードを使用して、論理要件に基づいて例外を手動でトリガーします。

age = -1
if age < 0:
    raise ValueError("年齡數值不可為負數")

ベストプラクティス

• 一般的な例外ではなく、特定のエラー タイプ (FileNotFoundError など) をキャッチするようにしてください。
• try ブロック内のコードは単純にして、エラーの原因となる可能性のある数行のみを含めてください。
• ファイルの読み取りと書き込みを処理するには、finally または with ステートメントを使用して、プログラム例外が発生したときにファイルを正しく閉じることができるようにします。

Pythonのカテゴリ

1. カテゴリの基本概念

クラスMyClass:
    def __init__(self, value):
        self.value = 値

    デフォルト表示(自分自身):
        print(f"値: {self.value}")

obj = MyClass(10)
obj.display() # 出力: 値: 10

2. 静的方法

静的メソッドは `@staticmethod` デコレータを使用して定義され、カテゴリやオブジェクトとは何の関係もありません。カテゴリ プロパティやオブジェクト プロパティにはアクセスできません。一部の楽器機能に適用されます。

クラスMyClass:
    @静的メソッド
    def add(a, b):
        a + bを返す

結果 = MyClass.add(5, 3)
print(結果) # 出力: 8

3. クラスメソッド

クラスメソッドは `@classmethod` デコレータを使用して定義され、最初のパラメータはクラス自体 (通常は `cls` という名前) であり、クラス属性にアクセスできます。

クラスMyClass:
    カウント = 0

    @クラスメソッド
    デフォルトの増分カウント(cls):
        cls.カウント += 1

MyClass.increment_count()
print(MyClass.count) # 出力: 1

4. 継承とポリタイプ

Python はクラスの継承をサポートしています。サブクラスは親クラスのプロパティとメソッドを継承し、親クラスのメソッドをオーバーライドできます。

クラスの親:
    デフォルトの挨拶(自分自身):
        print("親からこんにちは!")

クラス子(親):
    デフォルトの挨拶(自分自身):
        print("子供からこんにちは!")

obj = 子()
obj.greet() # 出力: Child からこんにちは!

5. カテゴリ属性とオブジェクト属性

カテゴリ属性はカテゴリ全体に属し、すべてのオブジェクトで共有されます。オブジェクト属性は各オブジェクトに属します。

クラスMyClass:
    class_attr = "私はクラス属性です"

    def __init__(self, value):
        self.instance_attr = 値

obj1 = MyClass(10)
obj2 = MyClass(20)

print(MyClass.class_attr) # 出力: 私はクラス属性です
print(obj1.instance_attr) # 出力: 10
print(obj2.instance_attr) # 出力: 20

6. オブジェクトを基本クラスとして使用する

Python のすべてのクラスはデフォルトで `object` を継承します。これは、`__str__` や `__eq__` などのいくつかの基本メソッドを提供する組み込み基本クラスです。

クラスMyClass(オブジェクト):
    def __init__(self, value):
        self.value = 値

    def __str__(自分自身):
        return f"値が {self.value} の MyClass"

obj = MyClass(5)
print(obj) # 出力: 値 5 の MyClass

7. まとめ

クラスの継承

1. 基本的な継承の概念

Python では、クラスの継承により、サブクラス (派生クラス) が親クラス (基本クラス) のプロパティとメソッドを継承して、コードの再利用が可能になります。例えば：

クラスの親:
    デフォルトの挨拶(自分自身):
        print("保護者からこんにちは!")

クラス子(親):
    パスする

c = 子()
c.greet() # 出力: 親からこんにちは!

2. サブクラスが親クラスのメソッドをオーバーライドする

サブクラスは、親クラスのメソッドをオーバーライド (Override) し、その関数を書き換えることができます。

クラスの親:
    デフォルトの挨拶(自分自身):
        print("保護者からこんにちは!")

クラス子(親):
    デフォルトの挨拶(自分自身):
        print("子供からこんにちは!")

c = 子()
c.greet() # 出力: Child からこんにちは!

3. super() を使用して親クラスのメソッドを呼び出します。

サブクラスでは、`super()` を通じて親クラスのメソッドを呼び出し、親クラスの動作を拡張できます。

クラスの親:
    デフォルトの挨拶(自分自身):
        print("親からこんにちは!")

クラス子(親):
    デフォルトの挨拶(自分自身):
        super().greet()
        print("子供からこんにちは!")

c = 子()
c.greet()
# 出力:
#保護者の方からこんにちは！
#チャイルドからこんにちは！

4. 多重継承

Python は多重継承をサポートしており、サブクラスは同時に複数の親クラスを継承できます。

クラス親1:
    デフォルトの挨拶(自分自身):
        print("親 1 からこんにちは!")

クラス親2:
    デフォルトの挨拶(自分自身):
        print("Parent2 からこんにちは!")

クラス子(親1, 親2):
    パスする

c = 子()
c.greet() # 出力: Parent1 からこんにちは! （相続順位による）

5. メソッド解決順序 (MRO)

多重継承では、MRO (メソッド解決順序) を使用してメソッドの解決順序を決定します。これは、`__mro__` 属性を使用して確認できます。

print(Child.__mro__)
# 出力: (, , , )

6. 抽象基本クラス

`abc` モジュールを使用して抽象基本クラスを定義し、サブクラスに特定のメソッドの実装を強制します。

from abc import ABC、abstractmethod

クラス AbstractParent(ABC):
    @abstractmethod
    デフォルトの挨拶(自分自身):
        パスする

クラス子(抽象親):
    デフォルトの挨拶(自分自身):
        print("子供からこんにちは!")

c = 子()
c.greet() # 出力: Child からこんにちは!

7. まとめ

ClassBを継承する一時クラスを作成する

サンプルコード

クラスクラスB:
    デフォルトの挨拶(自分自身):
        print("クラスBからこんにちは!")

# ClassB から継承した一時クラスを動的に作成
TempClass = type('TempClass', (ClassB,), {
    'greet': lambda self: (print("Hello from TempClass!"), super(TempClass, self).greet())[0]
})

#インスタンスを作成してテストする
temp = TempClass()
temp.greet()

説明する

1. type() 関数:
   type('TempClass', (ClassB,), {...})
   - 'TempClass': 新しいカテゴリ名。
   - (ClassB,): 基本カテゴリのタプル。ここには ClassB のみがあります。
   - {...}: 新しい属性またはメソッド。
2. Lambda 関数はメソッドをオーバーライドするために使用されます。
   - カスタマイズgreetこのメソッドは、最初に新しいメッセージを出力してから、super()親カテゴリを呼び出すgreet。

出力結果

Hello from TempClass!
Hello from ClassB!

同じインターフェイスで異なるカテゴリの使用を切り替える

説明する

2つのカテゴリがあるとしますAClassそしてBClass、同じ名前とパラメータを持つ関数があります。 メイン プログラム ロジックを変更せずに、使用するカテゴリを簡単に切り替えられるようにしたいと考えています。

サンプルプログラム

クラスAクラス:
    def プロセス (自分自身、データ):
        print(f"AClass 処理: {data}")

    デフォルトの結果(自分自身):
        「AClassからの結果」を返す


クラスBクラス:
    def プロセス (自分自身、データ):
        print(f"BClass 処理: {data}")

    デフォルトの結果(自分自身):
        「BClass からの結果」を返す


# 設定を通じてどのカテゴリを使用するかを制御できます
USE_A = True

#カテゴリーの動的な選択
SelectedClass = USE_A の場合は AClass、それ以外の場合は BClass

# インスタンスを作成して使用する
obj = SelectedClass()
obj.process("テストデータ")
print(obj.result())

出力結果(USE_A=True)

Aクラス処理: テストデータ
Aクラスの結果

出力結果(USE_A=False)

BClass 処理: テストデータ
Bクラスの結果

より高度な記述方法: ファクトリ関数を使用する

def get_class(名前):
    マッピング = {
        「A」: Aクラス、
        「B」：Bクラス
    }
    returnmapping.get(name, AClass) # デフォルトは AClass

# 動的選択
cls = get_class("B")
obj = cls()
obj.process("テストデータ")

結論は

• 2 つのカテゴリが同じインターフェイスを持つ場合、条件式またはファクトリ関数を使用して直接切り替えることができます。
• 関数名とパラメータの一貫性を保つことで、メイン プログラムをまったく変更する必要がなくなります。
• より柔軟な設計が必要な場合は、「インターフェイス」または「抽象クラス (abc)」の使用を検討してください。

Python は抽象カテゴリを使用します

短い答え

Pythonでは、必ずしも必要ではないC++ または Java のように記述されるabstract class。 Pythonでは「ダックタイピング」が採用されています。オブジェクトのメソッド名と動作が同じである限り、それらは互換性があると見なされます。

アヒルタイピングの例

クラスAクラス:
    def プロセス (自分自身、データ):
        print(f"AClass 処理: {data}")

クラスBクラス:
    def プロセス (自分自身、データ):
        print(f"BClass 処理: {data}")

デフォルト実行(obj):
    obj.process("data") # このメソッドがあれば型の指定は不要

run(AClass())
run(BClass())

出力結果

Aクラスの処理: データ
Bクラス処理: データ

抽象カテゴリ（ABC）を使用する状況

Python は型を強制しませんが、チーム開発または大規模プロジェクトでインターフェイスを明確に定義したい場合は、次のように使用できます。abcモッド。

from abc import ABC、abstractmethod

クラスBaseClass(ABC):
    @abstractmethod
    def プロセス (自分自身、データ):
        パスする

クラス AClass(BaseClass):
    def プロセス (自分自身、データ):
        print(f"AClass 処理: {data}")

クラス BClass(BaseClass):
    def プロセス (自分自身、データ):
        print(f"BClass 処理: {data}")

# 抽象メソッドが実装されていないため、BaseClass() はエラーを報告します

結論は

• Python は抽象カテゴリの使用を強制しません。動的型付け言語は本質的に「同じインターフェイスの異なるカテゴリ」をサポートします。
• プロジェクトで明確なインターフェイス仕様、高い可読性、または自動チェックが必要な場合は、使用することをお勧めします。abcモッド。
• 小規模または急速な開発プロジェクトでは、ダック タイピングでニーズを満たすことができます。

Pythonモジュール

意味

Pythonでは、モジュールプログラムコードを含むファイルで、通常はファイル拡張子が.py終わり。モジュールでは関数、カテゴリ、変数を定義でき、再利用とプログラムの構造化を容易にする実行可能コードを含めることもできます。

使用

• メンテナンスと読み取りを容易にするために、プログラムを複数のファイルに分割します。
• 再利用可能なライブラリまたはツールを提供します。
• コードの重複を回避し、開発効率を向上させます。
• 名前空間管理をサポートして、名前の競合を減らします。

使用法

Python経由importモジュールを紹介するキーワード。例:

数学をインポートする

print(math.sqrt(16)) # 出力 4.0

カスタムモジュール

開発者は独自の MOD を作成できます。たとえば、mymodule.py：

# mymodule.py
def greet(name):
    return f"Hello, {name}!"

別のプログラム ファイルで使用します。

import mymodule

print(mymodule.greet("Alice"))

共通の組み込みグループ

• os: オペレーティング システム関連の操作を処理します。
• sys: Python インタープリター関連情報にアクセスします。
• datetime：処理日時。
• math: 数学関数を提供します。
• random：乱数を生成します。

Python スイート

意味

Pythonでは、パッケージモジュールを整理する方法です。パッケージは複数のモジュールを含むディレクトリであり、階層構造を通じてプログラムの管理と保守が容易になります。

特徴

• パッケージとはディレクトリ（フォルダー）のことです。
• ディレクトリには少なくとも 1 つが含まれています__init__.pyarchive (Python 3.3 以降では省略されていますが、スイートを明確に定義するために追加されました)。
• パッケージにはサブスイートを含めて階層構造を形成できます。

基本的な例

というファイルを作成しますmypackageキット内容:

mypackage/
│── __init__.py
│── module1.py
└── module2.py

module1.py例：

def add(a, b):
    return a + b

module2.py例：

def multiply(a, b):
    return a * b

キットを使用する

mypackage.module1 をインポートします
mypackage.module2 をインポートします

print(mypackage.module1.add(2, 3)) # 出力 5
print(mypackage.module2.multiply(2, 3)) # 出力 6

パッケージから特定のプロジェクトをインポートする

mypackage.module1 からインポート追加
mypackage.module2 からインポート乗算

print(add(10, 5)) # 出力 15
print(multiply(10, 5)) # 出力 50

一般的な用途

• 関連するモジュールを統合して管理し、メンテナンスを容易にします。
• 名前の競合を回避し、明確な名前空間を提供します。
• 大規模プロジェクトの構造をより明確にします。

現在のパッケージ名を取得する

説明する

Python で現在のモジュールを取得するにはパッケージ名、特殊変数を使用できます__package__。これと__module__現在のモジュール名を取得する概念も同様です。

例: モジュールとキットの構造

mypackage/
│── __init__.py
└── submodule.py

submodule.pyコンテンツ：

print("__name__:", __name__)
print("__package__:", __package__)
print("__module__:", __module__)

実行結果

他のプログラムで次のように使用する場合import mypackage.submoduleインポートすると、出力はおおよそ次のようになります。

__name__: mypackage.submodule
__package__: mypackage
__module__: __main__

説明する

• __name__: 完全なモジュール名。
• __package__: 現在のモジュールが属するパッケージの名前。最上位モジュールの場合は空の文字列になります。
• __module__: 通常、クラスまたは関数の定義で、それがどのモジュールで定義されているかを示すために使用されます。

アプリケーションシナリオ

• 大規模なプロジェクトにおけるモジュールの文脈上の位置を決定します。
• 相対インポートする場合は、使用します__package__パッケージのパスを確認するのに役立ちます。

Python パッケージのバージョン

Python パッケージのバージョンを確認するには、主に 2 つの方法があります。ターミナル (コマンド ライン) を使用する方法と、Python コードで実行する方法です。これは、環境がプロジェクトの要件を満たしているかどうかを確認するのに役立ちます。

1. ターミナル（コマンドライン）で確認する

これは最も速い方法であり、Python 対話型環境に入る必要はありません。

• 特定のパッケージを確認します。 pip show パッケージ名（例えばpip show pandas）。
• インストールされているすべてのパッケージをリストします。 pip list。
• 特定のパッケージ バージョンを検索します。 ピップリスト | findstr "パッケージ名"(Windows) またはピップリスト | grep "パッケージ名" (Linux/Mac)。
• コンダ環境: conda リストのパッケージ名。

2. Python コードをチェックインする

プログラムの実行時にバージョンを確認する必要がある場合は、次の 2 つの方法を使用できます。

• __version__ 属性を使用します。ほとんどの主要なパッケージはこのプロパティをサポートしています。

  import pandas
  print(pandas.__version__)

• importlib.metadata を使用します (推奨):これは Python 3.8 以降に組み込まれている標準メソッドであり、最初にパッケージをインポートしなくても確認できます。

  from importlib.metadata import version
  print(version('pandas'))

3. 検査方法比較表

4. Python 自体のバージョンを確認する

問題はスイートではなく、Python インタープリター自体にある場合があります。

• ターミナル： python --version
• プログラム内:

  import sys
  print(sys.version)

5. よくある質問と注意事項

• 複数の環境の競合:もしpip list表示されるバージョンは、VS Code で実行されたバージョンとは異なります。をご確認ください。Interpreterその選択が正しいかどうか。
• パッケージがインストールされていません:使用する場合importlibアンインストールされたパッケージをチェックするとスローされますPackageNotFoundError。
• 大文字と小文字を区別：存在するpip show大文字と小文字は区別されませんが、コード ロジックによっては正確な名前が必要な場合があります。

カテゴリとモジュールオブジェクトからパッケージ名を取得

クラスオブジェクト

Python では、クラス オブジェクトには次の方法でアクセスできます。cls.__module__カテゴリを定義するモジュールの名前を見つけて、次を使用します。sys.modulesモジュールオブジェクトを取得し、最後にそれを読み取ります__package__パッケージ名を取得するプロパティ。

インポートシステム

# カテゴリが mypackage.submodule で定義されていると仮定します
クラスMyClass:
    パスする

# カテゴリが属するモジュールの名前を取得します
module_name = MyClass.__module__
print("モジュール名:", module_name)

# モジュールオブジェクトを取得
mod = sys.modules[モジュール名]

# モジュールオブジェクトからパッケージ名を取得する
print("パッケージ名:", mod.__package__)

モジュールオブジェクト

モジュール自体はオブジェクトであり、直接アクセスできます。__package__財産。

数学をインポート
mypackage.submodule をサブとしてインポートします

# math は標準関数ライブラリ モジュールであり、パッケージがないため、__package__ は空の文字列です
print("math.__package__:", math.__package__)

# カスタムキット用のモジュール
print("sub.__package__:", sub.__package__)

実行結果の例

モジュール名: mypackage.submodule
パッケージ名: mypackage
math.__package__:
sub.__package__: 私のパッケージ

結論は

• カテゴリ → __module__ → sys.modules[...] → __package__
• モジュールオブジェクト → __package__直接入手

inspect.getfile

Python ファイルを直接実行する場合、そのモジュール名は次のようになります。__main__。これにより、使用するのはcls.__module__元のファイル名とパスを取得できません。

プロジェクト構造が次のようになっていると仮定します。

/プロジェクト
  |-- test_runner.py <-- 直接実行するファイル (__main__ として扱われます)
  |-- テスト/
        |-- db_test.py <-- DbCmdAgent を定義するファイル

`test_runner.py` で次のコードを実行すると:

test.db_test から DbCmdAgent をインポート
Agent_obj = DbCmdAgent(...) # インスタンス化

# この時点では cls.__module__ はまだ 'test.db_test' (正しいモジュール名)

ただし、`test_runner.py` でカテゴリを定義すると、次のようになります。

# test_runner.py の内容
クラスDbCmdAgent:
    パスする

エージェント_obj = DbCmdAgent()
#この時点では cls.__module__ == '__main__' (モジュール名が間違っています)

これは、情報を取得しているクラスが `__main__` として実行されるファイル内で定義されていることを示します。

使用inspectモジュールはファイルパスを直接取得できます

カテゴリが __main__ で定義されているかどうかに関係なく、 __module__ 属性をバイパスして使用できます。inspectモジュールを使用して、このカテゴリに対応するソース コード ファイルのパスを取得します。これはより信頼性が高く、一般的な方法です。

Python の実装を修正しました

輸入検査
OSをインポートする

# --- シミュレーション状況: __main__ で定義されたカテゴリ (現在実行中のスクリプト) ---

クラスDbCmdAgent:
    """このカテゴリは現在実行中のメイン スクリプトで定義されています"""
    def __init__(self, data):
        self.data = データ

Agent_obj = DbCmdAgent("some_data")

def get_class_location_robust(obj):
    「」
    __module__ == '__main__' 問題を回避するには、inspect.getfile を使用します。
    「」
    cls = タイプ(obj)
    
    # 1. Inspection.getfile() を使用して、カテゴリを定義するファイル パスを取得します
    試してみてください:
        file_path = Inspection.getfile(cls)
        
        # 2. ファイル名とディレクトリを取得する
        ファイル名 = os.path.basename(ファイルパス)
        ディレクトリ = os.path.dirname(ファイルパス)
        py_name = os.path.splitext(ファイル名)[0]
        
        # 3. __module__ が __main__ の場合、より多くのコンテキストを提供するためにアーカイブ名に置き換えます。
        module_name = cls.__module__
        if module_name == '__main__':
            module_name = py_name # db_test または test_runner をコンテキストとして使用します
            
    例外タイプエラー:
        # 組み込み型を処理する
        file_path = "N/A (組み込みまたは C 拡張子)"
        ファイル名 = "該当なし"
        ディレクトリ = "該当なし"
        py_name = "該当なし"
        module_name = cls.__module__
        
    戻り値 {
        "モジュール名またはメイン": モジュール名,
        "py_name_no_ext": py_name,
        「ディレクトリ」: ディレクトリ、
        "ファイルパス": ファイルパス、
    }

# 実行して結果を表示する
location_info = get_class_location_robust(agent_obj)

print("--- カテゴリ定義ファイル情報 ---")
print(f"ファイル名(.py名): {location_info['py_name_no_ext']}")
print(f"ディレクトリパス(パッケージ): {location_info['ディレクトリ']}")
print(f"完全なファイルパス: {location_info['file_path']}")

4. 要点のまとめ

• 使用inspect.getfile(type(obj)): これは、モジュールが考慮されるかどうかに完全に関係なく、元の定義ファイルのパスを直接取得する最も信頼性の高い方法です。__main__。
• __module__これは、現在のプログラム内のクラスのモジュール名前空間のみを反映し、プロジェクト構造内の実際の名前が反映されるとは限りません。

動的インポートモジュール

機能説明

この方法では、importlib.import_module指定されたモジュールをインポートしてみます。遭遇したらModuleNotFoundErrorは、現在ロードされているパッケージからサブモジュールをインポートしようとします。

プログラム例

インポートインポート
インポートシステム

defsafe_import(モジュール名):
    試してみてください:
        # 直接インポートしてみる
        return importlib.import_module(モジュール名)
    ModuleNotFoundError を除く:
        # 失敗した場合は、既知のパッケージからサブモジュールのインポートを試みます
        list(sys.modules.keys()) の pkg の場合:
            pkg ではなく pkg.startswith("_") の場合:
                試してみてください:
                    return importlib.import_module(f"{pkg}.{module_name}")
                ModuleNotFoundError を除く:
                    続ける
        raise # それでも見つからない場合は例外をスローします

使用例

numpyをインポートする

mod1 = safety_import("random") # 標準ライブラリなので直接成功可能
mod2 = safety_import("linalg") # numpy.linalg を試します
print(mod2.__name__) # numpy.linalg を出力します

説明する

• sys.modulesロードされたすべてのモジュールを保存します。
• インポートが失敗すると、次のように試行されます。package.module_nameもう一度試す方法。
• このメソッドは、Python サブモジュールの自動検索メカニズムをシミュレートします。

Python モジュールの検索パス: sys.path の構成

Pythonでは、sys.pathモジュールをインポートしようとするときに Python インタープリターが順番に検索するすべてのディレクトリ パスを含むリストです。実行するとimport some_module, Pythonは順番にチェックしていきます。sys.pathという名前のディレクトリが見つかるまで、リスト内の各ディレクトリを検索します。some_moduleファイル (例:some_module.py、some_module/__init__.py待って）。

sys.path の 3 つの主要コンポーネント

sys.path通常、リストは次の 3 つの部分で構成され、次の順序で検索されます。

1. プログラムコードのエントリディレクトリ（エントリポイント）

• スクリプトを実行するディレクトリ: リストの最初の要素 (sys.path[0]) は通常、現在実行中の Python スクリプトです (例:main.py) ディレクトリにあります。
• インタラクティブ モード: インタラクティブ インタプリタまたは Jupyter Notebook を使用している場合、この要素は空の文字列になります。''は、現在の作業ディレクトリ (現在の作業ディレクトリ、CWD) を表します。

2. PYTHONPATH 環境変数

• Python は次の名前のファイルを読み取ります。PYTHONPATHシステム環境変数。
• この変数で定義されたすべてのディレクトリ パスは、sys.path真ん中。
• 使用：PYTHONPATH通常、標準以外の場所にある一般的に使用されるプロジェクトまたはライブラリのディレクトリを、プロジェクトごとに手動で設定することなく、検索パスに永続的に追加するために使用されます。

3. 標準関数ライブラリとインストールディレクトリ

• 標準ライブラリ: すべての Python 組み込みモジュール (os, sys, json, socket) インストールディレクトリ。
• サードパーティパッケージのインストールディレクトリ (site-packages): これですべてですpipインストールされたサードパーティ パッケージ (例:fastapi, numpy, pandas) インストールディレクトリ。仮想環境では、これは通常、環境のlib/site-packagesディレクトリ。

sys.path に関連するシステム変数

上記に加えてPYTHONPATHさらに、Python 実行環境に関連する環境変数がいくつかあります。これらはインタープリタとパス検索の動作に影響しますが、sys.pathを構成する主な変数は、PYTHONPATH：

sys.pathを変更する方法

なぜならsys.pathは、プログラムの実行中に動的に変更できる通常の Python リストですが、そのような変更は現在のインタープリター セッション内でのみ有効になります。

インポートシステム
OSをインポートする

# 親ディレクトリを検索パスに追加します (テストまたは内部プロジェクト参照によく使用されます)
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

モッドシャドウ

モジュール シャドウイング (または名前シャドウイング) は、Python における一般的なエラーまたはプログラミングの問題です。この問題は、インポートまたは使用しようとしている組み込みモジュールまたはサードパーティ ライブラリの名前と競合するコード ファイルまたは変数名を誤って作成した場合に発生します。

1. 定義と発生原因

• 定義: Python インタープリターがモジュールをロードしようとするとき、特定の検索順序に従います (sys.path）MODを見つけます。
• シャドウが発生する: インポートしようとしているモジュールと一致する標準モジュールがプロジェクト ディレクトリにある場合 (例:socket, json, random)、またはサードパーティのライブラリと同じ名前のファイルまたはディレクトリ (たとえば、次の名前のファイルを作成します)socket.pyファイル)、Python は最初にローカル ファイルを読み込みます。

この結果、ローカル ファイルがロードされるべき標準モジュールを「カバー」または「オーバーライド」し、コードが標準モジュールの機能 (たとえば、socket.AF_UNSPEC) ロードしたローカル ファイルにはこれらのプロパティがないため、失敗します。

2. よくある例

3. 解決策

1. アーカイブの名前を変更します。これは最も簡単で効果的な解決策です。標準のモジュール名またはライブラリ名と競合するローカル ファイルまたはディレクトリの名前を変更するだけです。たとえば、次のように変更します。socket.py名前が変更されましたnetwork_handler.py。
2. sys.path を確認してください: コード内でこれを実行してくださいimport sys; print(sys.path)Python の検索パスをチェックして、標準ライブラリ ディレクトリよりも優先してローカル ファイルが読み込まれるかどうかを確認します。
3. 仮想環境を使用する: 仮想環境自体はローカル アーカイブ シャドウイングを防止しませんが、インストールするサードパーティ パッケージが他の環境と競合しないようにすることができます。

現在のエントリの .py 名を取得します

説明する

Python プログラムの現在の実行を取得するには__main__所属する .py ファイルの名前 (使用可能)__main__.__file__またはsys.argv[0]。ただし、インタラクティブ モードでは、Jupyter、または-c実行時には存在しない可能性があるため、安全な取り扱いが必要です。

現在のメインの .py ファイル名を取得します (安全なバージョン)

OSをインポートする
インポートシステム
__メイン__をインポートする

def get_main_py_path():
    """main が属する .py の絶対パスを返します。見つからない場合は None を返します"""

    # ケース 1: 通常の実行 .py
    main_file = getattr(__main__, "__file__", None)
    main_file の場合:
        os.path.abspath(main_file)を返す

    # ケース2：sys.argv[0]からの判定
    len(sys.argv) > 0の場合:
        argv0 = sys.argv[0]
        argv0 が (""、"-c"、" にない場合)"):
            候補 = os.path.abspath(argv0)
            os.path.exists(候補)の場合:
                復帰候補者

    # ケース 3: インタラクティブ モード、Jupyter、埋め込みなど
    なしを返す

# 例
パス = get_main_py_path()
パスの場合:
    print("メインパス:", パス)
    print("メインファイル名:", os.path.basename(パス))
それ以外の場合:
    print("main.py が見つかりません (対話型環境にあるか、アーカイブから実行されていない可能性があります)")

ファイル名（ベース名）のみ

path = get_main_py_path()
filename = os.path.basename(path) if path else None
print(filename)

要約する

• __main__.__file__は最も信頼性の高い方法ですが、常に存在するとは限りません。
• sys.argv[0]はバックアップ方法ですが、値がそうでないことを確認する必要があります。-cまたは<stdin>。
• Interactive (REPL/Jupyter) は .py 名を取得できず、None を返します。

現在の関数のパラメータ名と値を取得します

To get the parameter names and their corresponding values of a function in Python, you can use the `inspect` module, which provides introspection utilities. Specifically, `inspect.signature()` can help you retrieve the names of the parameters, and you can pass the current frame's local variables to get their values.

Here is an example that demonstrates how to get the function name, parameter names, and their values:

```python
import inspect

# Sample function
def my_function(a, b, c=5):
    # Get the current frame
    frame = inspect.currentframe()
    
    # Get the function name
    func_name = frame.f_code.co_name
    print(f"Function name: {func_name}")
    
    # Get the parameter names and their values
    args, _, _, values = inspect.getargvalues(frame)
    
    # Print parameter names and values
    for arg in args:
        print(f"Parameter name: {arg}, Value: {values[arg]}")

# Call the function
my_function(1, 2)
```

### Output:
```
Function name: my_function
Parameter name: a, Value: 1
Parameter name: b, Value: 2
Parameter name: c, Value: 5
```

### Explanation:
1. **`inspect.currentframe()`**: Retrieves the current execution frame.
2. **`frame.f_code.co_name`**: Extracts the name of the current function.
3. **`inspect.getargvalues(frame)`**: Gets the argument names and their corresponding values from the frame. This function returns a tuple containing:
   - `args`: List of argument names.
   - `_`: Placeholder for unused information.
   - `values`: Dictionary containing argument names as keys and their values.

This allows you to print both the names of the function's parameters and their values at runtime.

関数パラメータの型を取得する

検査モジュールの使用

Python では、次のように使用できますinspect.signature()関数のパラメータ情報を取得し、 そしてさらにそこからParameter.annotationプロパティは、各パラメーターの型アノテーション (型ヒント) を取得します。

輸入検査

def my_function(a: int, b: str, c: float = 3.14) -> bool:
    戻り値 str(a) == b

sig = Inspection.signature(my_function)

sig.parameters.items() の名前、パラメータ:
    print(f"パラメータ名: {name}")
    print(f"デフォルト値: {param.default}")
    print(f"型アノテーション: {param.annotation}")
    プリント()

出力結果

パラメータ名: a
  デフォルト: <クラス 'inspect._empty'>
  型アノテーション: <class 'int'>

パラメータ名：b
  デフォルト: <クラス 'inspect._empty'>
  型アノテーション: <class 'str'>

パラメータ名：c
  デフォルト: 3.14
  型アノテーション: <class 'float'>

説明する

• param.annotation型の注釈 (次のような) を取得します。int、str）。
• パラメータに型注釈がない場合は、次のようになります。inspect._empty。
• 利用可能get_type_hints()完全なタイプヒント辞書を取得します。

get_type_hints を使用する

このメソッドは、前方参照 (文字列としてマークされた型) を自動的に解決します。

from typing import get_type_hints

hints = get_type_hints(my_function)
print(hints)

出力結果

{'a': <class 'int'>, 'b': <class 'str'>, 'c': <class 'float'>, 'return': <class 'bool'>}

要約する

• inspect.signature()パラメータの順序と名前を取得できます。
• param.annotation各パラメータの型アノテーションを確認できます。
• get_type_hints()すべての型ヒント (戻り値を含む) を一度に取得する方が簡単です。

オブジェクトのクラス名を取得します

説明する

Python では、オブジェクトの__class__属性またはtype()機能、 所属するカテゴリ(クラス)を取得し、カテゴリ名を取得します。

例

クラス動物:
    パスする

クラス犬(動物):
    パスする

obj = 犬()

#方法 1: __class__.__name__ を使用する
print(obj.__class__.__name__) # 出力: Dog

#方法 2: type() を使用する
print(type(obj).__name__) # 出力: Dog

#方法 3: 完全なモジュール名とカテゴリ名を取得する
print(obj.__class__) # 出力: <class '__main__.Dog'>
print(obj.__class__.__module__) # 出力: __main__

出力結果

Dog
Dog
<class '__main__.Dog'>
__main__

説明する

• obj.__class__: オブジェクトのカテゴリオブジェクトを取得します。
• obj.__class__.__name__: カテゴリ名の文字列を取得します。
• type(obj)に相当obj.__class__。
• __module__：カテゴリが定義されているモジュール名を取得できます。

高度なアプリケーション

完全な「モジュール + カテゴリ名」を同時に取得するには、次のように記述できます。

cls = type(obj)
full_name = f"{cls.__module__}.{cls.__name__}"
print(full_name)

出力結果

__main__.Dog

要約する

• type(obj).__name__これはカテゴリ名を取得する最も簡単な方法です。
• カテゴリのソース (モジュールを含む) を完全に特定する必要がある場合は、次を使用できます。f"{obj.__class__.__module__}.{obj.__class__.__name__}"。

属性が属するカテゴリを検出します

以下は、Python を使用してプロパティがどの継承クラスに属するかを決定するサンプル コードです。

サンプルコード

輸入検査

クラスBaseClass:
    Base_attr = "私はBaseClassの属性です"

クラスのサブクラス(BaseClass):
    sub_attr = "私はサブクラスの属性です"

# 属性が属するカテゴリを検索する関数を定義する
def find_attribute_owner(cls, attr_name):
    inspect.getmro(cls) のベースの場合: # MRO (メソッド解決順序) を取得します
        attr_name が Base.__dict__ の場合:
            リターンベース
    なしを返す

# テスト
sub_obj = サブクラス()
attributes = sub_obj.__class__.__dict__.items() # カテゴリ レベルですべての属性を取得します
名前、属性の値:
    owner = find_attribute_owner(sub_obj.__class__, 名前)
    print(f"属性 '{name}' はカテゴリに属します: {owner.__name__}")

プログラムの説明

• inspect.getmro(cls):カテゴリの MRO (メソッド解決順序)、つまり継承されたカテゴリ階層順序を取得します。
• base.__dict__:各カテゴリには独自のものがあります__dict__、カテゴリによって定義された属性が保存されます。
• この関数は、MRO 内の各カテゴリをチェックして、属性がどのカテゴリに定義されているかを見つけます。

実行結果

例のカテゴリの実行結果は次のようになります。

属性「__module__」はクラスに属します: SubClass
属性「sub_attr」はクラスに属します: SubClass
属性 '__doc__' はクラス: SubClass に属します
属性「base_attr」はクラスに属します: BaseClass

関数のアノテーションを取得 (Docstring)

__doc__ を使用する

class MyClass:
    def fun1(self):
        '''
        Fun1 comment
        '''
        pass

obj = MyClass()
print(obj.fun1.__doc__)

検査モジュールの使用

import inspect

class MyClass:
    def fun1(self):
        '''
        Fun1 comment
        '''
        pass

print(inspect.getdoc(MyClass.fun1))

非推奨としてマークされた関数

警告モジュールの使用

Python では、組み込みのwarnings関数が非推奨になったことを (コンパイル時ではなく) 実行時にユーザーに警告し、新しい代替案を提案するモジュール。

インポート警告

def old_function(x, y):
    警告.warn(
        "関数 old_function() は非推奨です。代わりに new_function(x, y) を使用してください。",
        category=非推奨警告、
        スタックレベル=2
    )
    x + yを返す

def new_function(x, y):
    x + yを返す

実行例

result = old_function(3, 4)
print(result)

出力結果

非推奨警告: 関数 old_function() は非推奨です。代わりに new_function(x, y) を使用してください。
  結果 = old_function(3, 4)
7

追加情報

• warnings.warn()警告は実行フェーズ中に表示され、プログラムは中断されません。
• category=DeprecationWarning非推奨の警告をマークするために使用されます。
• stacklevel=2警告メッセージが関数内ではなく、呼び出し元の場所を指すようにします。
• 開発中に警告をエラーとして扱いたい場合は、以下を使用します。

  python -W error::DeprecationWarning your_script.py

上級: 非推奨の関数を自動的にマークするデコレータを作成する

デコレータを使用すると、複数の古い関数が同じ非推奨プロンプト ロジックを共有できるようになります。

インポート警告
functools インポートラップから

def 非推奨(new_func_name):
    def デコレータ(関数):
        @ラップ(関数)
        def ラッパー(*args, **kwargs):
            警告.warn(
                f"関数 {func.__name__}() は非推奨です。代わりに {new_func_name}() を使用してください。",
                category=非推奨警告、
                スタックレベル=2
            )
            return func(*args, **kwargs)
        リターンラッパー
    デコレータを返す

@deprecated("new_function")
def old_function(x, y):
    x + yを返す

@staticmethod と @classmethod の違い

Pythonでは、@staticmethodそして@classmethodどちらのデコレータも、クラスをインスタンス化せずに呼び出すことができるメソッドを定義できますが、その目的と動作は異なります。

@staticmethod

• 意味：@staticmethod暗黙の最初の引数を受け入れません (なしselfまたはcls） 方法。これは通常の関数と同じで、クラスの名前空間に属しているだけです。
• 使用法: 静的メソッドはクラスまたはインスタンスの状態を変更できません。通常はクラス関連の機能に使用されますが、クラスまたはインスタンスへのアクセスや変更は必要ありません。
• いつ使用するか: カテゴリまたはインスタンスにアクセスする必要はないが、関連する機能をカテゴリに関連付けたい場合に使用します。@staticmethod。

@staticメソッドの例:

クラスMyClass:
    @静的メソッド
    def static_method(x, y):
        x + yを返す

# インスタンスを作成せずに静的メソッドを呼び出すことができます
result = MyClass.static_method(5, 10) # 結果: 15

集中：@staticmethodカテゴリにアクセスできません (cls) またはインスタンス (self）。

@classmethod

• 意味：@classmethod受け入れカテゴリ自体です (cls) を最初のパラメータとして指定します。これにより、カテゴリのステータスにアクセスして変更できるようになります。
• 使用法:Category メソッドは、カテゴリ階層 (カテゴリ変数など) の状態を変更でき、インスタンスまたはカテゴリに対して呼び出すことができます。
• いつ使用するか: カテゴリレベルのデータ (カテゴリ変数など) にアクセスまたは変更する必要がある場合、またはカテゴリの代替コンストラクタを作成する必要がある場合に使用します。@classmethod。

@クラスメソッドの例:

クラスMyClass:
    クラス変数 = 0

    def __init__(self, value):
        self.value = 値
        MyClass.class_variable += 1

    @クラスメソッド
    def get_class_variable(cls):
        cls.class_variable を返す

#インスタンスの作成
obj1 = MyClass(10)
obj2 = MyClass(20)

# カテゴリメソッドを呼び出す
print(MyClass.get_class_variable()) # 結果: 2

集中：@classmethodカテゴリレベルのステータスにアクセスできます (cls）。

要約する

静的クラスが初期化を実行します

Python 自体には、「デフォルトの静的メソッド」や「デフォルトのクラスメソッド」、つまり、初めて静的メソッドやクラスメソッドが呼び出されたときにメソッドを自動的に実行する機能は提供されていません。ただし、遅延読み込み手法を使用すると、同様の動作を実現できます。

解決策: 静的変数と遅延読み込みを使用する

クラス内に静的変数を定義して初期化状態を追跡し、静的メソッドまたはクラス メソッドが初めて呼び出されたときに初期化ロジックを実行できます。

例：

クラスMyClass:
    Initialized = False # 静的変数、初期化されたかどうかを追跡する

    @静的メソッド
    def init_once():
        MyClass.initialized でない場合:
            print("初期化ロジックの実行...")
            MyClass.initialized = True

    @クラスメソッド
    def クラスメソッド(cls):
        cls.init_once()
        print("クラスメソッドの呼び出し")

    @静的メソッド
    def static_method():
        MyClass.init_once()
        print("静的メソッドの呼び出し")

# カテゴリメソッドを初めて呼び出して初期化をトリガーします
MyClass.class_method() # 出力: 初期化ロジックの実行...クラスメソッドの呼び出し

# category メソッドを 2 回目に呼び出し、初期化を実行しません
MyClass.class_method() # 出力: クラスメソッドの呼び出し

# 静的メソッドが初めて呼び出されるときは、すでに初期化されているため、初期化は実行されません。
MyClass.static_method() # 出力: 静的メソッドの呼び出し

仕組み:

• 静的変数initialized: この変数は、カテゴリが初期化されているかどうかを追跡するために使用されます。初期値はFalse。
• init_once()方法: このメソッドは初期化ロジックの実行を担当し、initializedに設定True、初期化の繰り返しを防ぐため。
• 静的メソッドとクラスメソッド: これらのメソッドが呼び出されるたびに、まず初期化が必要かどうかを確認して、初期化ロジックが 1 回だけ実行されるようにします。

要約する

Python には組み込みの「デフォルトの静的メソッド」または「デフォルトのクラス メソッド」がありませんが、静的変数と遅延読み込み手法を使用することで、静的メソッドまたはクラス メソッドが初めて呼び出されたときに初期化ロジックを自動的に実行し、このロジックが 1 回だけ実行されるようにすることができます。

Python スレッド

Python では、スレッドは同時実行性を実装するために使用されるメカニズムです。これにより、プログラムは単一のプロセス (プロセス) 内で複数のタスクを同時に実行できます。これは、I/O 集中型の操作 (ネットワーク通信、ファイルの読み取りと書き込みなど) を実行する場合に非常に便利で、外部操作の完了を待ってプログラムがブロック (ブロック) されるのを防ぐことができます。

1. なぜスレッドを使用するのでしょうか?

• ノンブロッキング I/O: プログラムがネットワーク応答またはディスクの読み取りと書き込みを待機している間、他のスレッドは効率を向上させるために計算を実行し続けることができます。
• ユーザー インターフェイス: メイン プログラムが時間のかかるバックグラウンド タスクを実行している場合でも、UI の応答性を維持します。
• 並列タスク: 複数のクライアント接続要求など、複数の独立したタスクを同時に処理します。

2. Python スレッドの制限: GIL (グローバル インタプリタ ロック)

標準の CPython インタープリターには、「グローバル インタープリター ロック」(Global Interpreter Lock、GIL) があります。 GIL は、常に 1 つのスレッドだけが Python ビットコードを実行できるようにします。これはつまり：

• スレッドは、I/O 集中型のタスクで良好にパフォーマンスします (Python は I/O を待機している間に GIL を解放し、他のスレッドの実行を可能にすることができるため)。
• CPU を大量に使用するタスクに対するスレッドの高速化効果は明ら​​かではありません (GIL がマルチコア CPU の並列コンピューティング機能を制限するため)。 CPU を集中的に使用するタスクの場合は、マルチプロセス (multiprocessingモジュール）。

3. 実行スレッドモジュール:threading

Pythonは標準関数ライブラリを使用しますthreading実行スレッドを処理するモジュール。スレッドの作成には主に 2 つの方法があります。

方法 1: 関数をターゲットとして渡す (ターゲット関数)

これは最も単純で最も一般的な使用法です。

インポートスレッド
インポート時間

def タスク (名前、遅延):
    """スレッドによって実行されるタスク関数"""
    print(f"スレッド {name}: 開始中...")
    time.sleep(lay) # 時間のかかる I/O 操作をシミュレートします
    print(f"スレッド {name}: タスクが完了しました。")

#実行スレッドの作成
thread1 = threading.Thread(target=タスク, args=("T1", 2))
thread2 = threading.Thread(target=タスク, args=("T2", 4))

# スレッドを開始します
thread1.start()
thread2.start()

# すべてのスレッドが完了するまで待ちます (完了するまでメインスレッドをブロックします)
thread1.join()
thread2.join()

print("すべての実行スレッドが完了しました。メインプログラムが終了します。")

方法 2: 継承threading.Threadカテゴリ

実行スレッドのロジックをカテゴリにカプセル化する、より複雑なシナリオに適しています。

インポートスレッド
インポート時間

クラスMyThread(threading.Thread):
    def __init__(自分自身、名前、遅延):
        super().__init__()
        self.name = 名前
        self.delay = 遅延

    デフォルト実行(自分自身):
        「」
        スレッドが開始されると、run() メソッドが自動的に呼び出されます。
        ここでは、スレッドによって実行されるタスクを定義します。
        「」
        print(f"スレッド {self.name}: 開始中...")
        time.sleep(自己.遅延)
        print(f"スレッド {self.name}: タスクが完了しました。")

#スレッドを作成して開始する
thread3 = MyThread("T3", 3)
thread3.start()
thread3.join()

print("カスタム実行スレッドが完了しました。")

4. スレッドの同期とデータ共有

複数のスレッドが共有データにアクセスして変更すると、競合状態が発生する可能性があります。データを保護するには、同期メカニズムを使用する必要があります。

• Lock: ロックは最も基本的な同期プリミティブです。スレッドが共有リソースにアクセスする前に呼び出されますlock.acquire()、完了後に電話lock.release()。
• RLock(再入可能ロック): 同じスレッドが複数回ロックを取得できるようにします。
• Semaphore(ログ): 同時にリソースにアクセスできるスレッドの数を制限するために使用されます。

ロックの使用例

インポートスレッド

# 共有リソース
カウンタ = 0
# ロックを作成する
ロック = threading.Lock()

デフォルトのincrement_counter():
    グローバルカウンター
    # ロックを取得して、このブロックを同時に 1 つのスレッドだけが実行できるようにします。
    lock.acquire()
    試してみてください:
        # コンペティション部門
        現在の値 = カウンタ
        time.sleep(0.001) # 切り替えをシミュレートします
        カウンタ = 現在の値 + 1
    最後に：
        # ロックを解除する
        ロック.リリース()

スレッド = []
範囲 (100) 内の i の場合:
    t = threading.Thread(target=increment_counter)
    スレッド.append(t)
    t.start()

スレッド内の t の場合:
    t.join()

print(f"最終カウンタ値: {counter}") # ロックがない場合、この値は 100 にならない可能性があります

Python スレッドの開始、同期、停止

パイソンthreadingこのモジュールは実行スレッドを作成および管理する機能を提供しますが、オペレーティング システムの制限と設計思想のため、Python には外部実行スレッドを停止 (強制終了) するための安全かつ直接的かつ強制的な方法がありません。強制停止するとリソース漏洩やデータ破損が発生する可能性があります。

したがって、実行スレッドの停止は **協調メカニズム**** を通じて実現する必要があります。つまり、実行スレッドが独自に停止フラグをチェックし、正常に終了できるようにする必要があります。

1. スレッド停止機構：フラグを利用した（Flag）

これは、スレッドを停止する最も安全で最も推奨される方法です。スレッドはタスク実行のループ内で外部変数 (フラグ) を定期的にチェックする必要があります。

Pythonの実装例

インポートスレッド
インポート時間

# 共有停止フラグ
stop_flag = threading.Event()

def 監視タスク(名前、遅延):
    「」
    停止フラグを定期的にチェックするタスク関数
    「」
    print(f"スレッド {name}: 開始中...")
    i = 0
    stop_flag.is_set() 以外の場合: # フラグが設定されているかどうかを確認します
        私 += 1
        print(f"スレッド {name}: 実行ステップ {i}")
        
        # 時間のかかる操作をシミュレーションし、定期的にチェックする
        時間.睡眠(遅延)
        
        # ここで、無限ループが発生しないように実行回数の制限を設定できます。
        私が 5 以上の場合:
            休憩
            
    print(f"実行スレッド {name}: 停止シグナルを受信したか、タスクが終了し、正常に終了しました。")

# --- メインプログラム制御ブロック ---

#実行スレッドの作成
worker_thread = threading.Thread(target=monitored_task, args=("Worker-1", 1))

# スレッドを開始します
ワーカースレッド.start()

print("\nメイン プログラム: 実行スレッドが開始されました。3 秒お待ちください...\n")
time.sleep(3) # スレッドをしばらく実行させます

# 停止信号を送信
print("\nメインプログラム: 停止フラグを設定します...\n")
stop_flag.set() # イベントを設定し、is_set() が True を返すようにします

# スレッドが正常に終了して終了するまで待機します (通常はすぐに終了します)
ワーカースレッド.join()

print("\nメイン プログラム: スレッドは安全に停止され、参加しました。プログラムは終了しました。")

2. 主要コンポーネントの説明

• threading.Event(): 単純な同期プリミティブ。ボリンジャーフラグを内部的に維持します。
  • stop_flag.is_set(): フラグが True かどうか (つまり、停止信号が発行されているかどうか) を確認します。
  • stop_flag.set():フラグを True に設定すると、停止信号が送信されます。
• while not stop_flag.is_set():: これはスレッドの主な制御構造です。停止信号が受信されない限り、ループは実行を続けます。
• worker_thread.join(): メイン プログラムが実行を続行する前に、ワーク スレッドが完了する (正常に終了する) まで待機するようにしてください。これは手術を確実にきれいに終えるための重要なステップです。

3. その他の停止機構（強制停止は推奨しません）

`_thread.stop()` の使用や例外のスローなど、強制的に停止するための実験的または安全でない方法がいくつかありますが、これらの方法では次のような問題が発生する可能性があります。

• リソースのロック: ロック (Lock) を保持しているときに実行スレッドが強制的に停止された場合、ロックは決して解放されず、他の実行スレッドが永続的にブロックされます。
• データの破損: 共有データの変更中にスレッドが終了し、一貫性のない状態が残る可能性があります。

したがって、Python では、スレッドを停止するために常に調整されたフラグ設定メカニズムを使用することに固執する必要があります。

マルチスレッド共有オブジェクトの競合の解決策

1. 最も一般的に使用されるソリューション: スレッドローカルストレージ

これは、マルチスレッド環境で最も推奨されるアプローチです。すべてのスレッドが同じオブジェクトを取得するのではなく、各スレッドがオブジェクトの独立したコピーを持ちます。 Python では、次のように使用できますthreading.local()達成するために。

インポートスレッド

# オブジェクトを格納するスレッド領域を作成する
thread_data = threading.local()

def get_service():
    # 現在のスレッドに独自のサービスがない場合は、サービスを作成します
    hasattr(thread_data, 'service') がない場合:
        print(f"スレッド {threading.current_thread().name} の新しい接続を作成します")
        thread_data.service = create_new_connection()
    thread_data.service を返す

デフォルトタスク():
    サービス = get_service()
    # 操作を実行します...

2. 2 番目によく使用される方法: ロック機構 (Locking)

オブジェクトが同じである必要がある場合 (同じファイルへの書き込みや同じグローバル カウンターでの操作など)、次を使用する必要があります。Lock。これにより、同時に 1 つのスレッドだけがオブジェクトにアクセスできるようになり、競合状態が回避されます。

ロック = threading.Lock()

デフォルトのsafe_task():
    ロック付き:
        # このブロック内では、他のスレッドは待機する必要があります
        共有オブジェクト.do_something()

マルチスレッドの代替手段: 非同期およびマルチ処理

複数のスレッドに伴うロック競合やクラッシュのリスクを回避したい場合は、主に次の 2 つの代替案を考慮する必要があります。

1. 非同期コルーチン (Asyncio) - I/O 集中型のタスクに適しています

これは現在、Python で最も一般的なアプローチです (FastAPI の中心原則など)。シングルスレッド内で動作し、タスクを切り替えながらI/O（APIリクエストやデータベースクエリなど）を待ちます。

• アドバンテージ: スレッドの競合の問題がなく、ロックを使用する必要がなく、メモリ消費量が非常に少ないです。
• シーンに合わせて: 多数の API リクエスト、クローラー、Web サーバー。

非同期をインポートする

非同期デフォルト fetch_api(url):
    # aiohttp などの非同期ライブラリを使用する
    応答 = call_api(url) を待ちます
    応答を返す

非同期def main():
    # 複数のタスクを同時に実行しますが、単一スレッド内で切り替えます
    results = await asyncio.gather(fetch_api("url1"), fetch_api("url2"))

2. マルチプロセッシング - 計算負荷の高いタスクに適しています

Python の実行スレッドは GIL (グローバル インタープリター ロック) によって制限されており、操作を真に並列化することはできません。multiprocessing複数の独立した Python インタープリター インスタンスが開きます。

• アドバンテージ: 各プロセスは独立したメモリ空間を持っており、「共有オブジェクトのクラッシュ」の問題はまったく発生しません。マルチコアCPUを活用できる。
• シーンに合わせて: 画像処理、ビッグデータ操作、大規模な JSON の解析。

マルチプロセスインポートプロセスから

デフォルトタスク(名前):
    print(f"プロセス {name} が実行中です")

__name__ == "__main__"の場合:
    p = プロセス(ターゲット=タスク、引数=('A',))
    p.start()
    p.join()

3. タスクキュー - 分散処理に適しています

タスクを完全に分離したい場合は、Celery または Redis Queue を使用できます。タスクをキューにスローし、バックエンド ワーカー (複数のプロセスまたは複数のマシンの場合があります) にタスクを取得して実行させます。

要約提案

スレッド領域のストレージと情報共有のバランス

コアコンセプト

スレッドローカル ストレージ (TLS) を使用する場合、その目的は、「非スレッドセーフ」オブジェクト (API サービス、データベース接続など) を保護することです。ただし、スレッド間でデータを交換する必要がある場合 (たとえば、スレッド A によってダウンロードされた結果をスレッド B によって処理する必要がある場合)、特別な「通信チャネル」を確立する必要があります。

1. スレッドセーフなキュー (キュー) を使用する - 最も推奨される

パイソンqueue.Queueスレッドセーフです。これは、スレッド間で情報を転送するための最も標準的で安全な方法です。すべてのロック ロジックが内部ですでに処理されています。

インポートスレッド
インポートキュー

# すべての実行スレッドがアクセスできるグローバル キューを作成します
task_queue = キュー.Queue()

デフォルトプロデューサー():
    # データを生成してキューに入れる
    データ = {"video_id": "abc", "ステータス": "保留中"}
    task_queue.put(データ)

def Consumer():
    # キューからデータを取得する
    データ = task_queue.get()
    # データを処理します...
    task_queue.task_done()

2. スレッドセキュリティ変数を使用する (共有リストロックなど)

大規模なリストまたは辞書を共有する必要がある場合は、一般的なグローバル変数を使用できますが、一致するものを使用してアクセスする必要があります。threading.Lock。

共有結果 = []
results_lock = threading.Lock()

デフォルトタスク():
    result = "一部の操作結果"
    
    #共有リソースにアクセスする前にロックする
    results_lock を使用:
        shared_results.append(結果)
    # withブロックを離れた後に自動的にロックを解除する

3. Event オブジェクトまたは Condition オブジェクトを使用する (信号同期)

「データ」ではなく「状態」を共有したい場合があります (例: API が初期化されたことを他のスレッドに通知する)。

api_ready = threading.Event()

def 初期化子():
    #初期化を行う
    api_ready.set() # シグナルを送信

def ワーカー():
    api_ready.wait() # イニシャライザが set() を呼び出すまでシグナルを待ちます
    print("作業を開始")

概要: リージョン ストレージと共有情報

簡単に言うと、 **「プライベートツール(コネクション)は自分で取得し、公開情報(データ)はキュー(Queue/Lock)で取得する。」**

ネジロック

基本的な概念

マルチスレッド環境では、複数のスレッドが同じグローバル変数または共有リソース (ファイル、データベース接続、グローバル リストなど) を同時に変更しようとすると、エラーが発生します。競合状態、データの混乱につながります。threading.Lock一度に 1 つのスレッドだけが保護されたコード ブロックに入ることができるようにする同期プリミティブです。

1. 標準的な使用方法

最も安全かつ推奨される方法は、一致させることです。with物語的な文章を使用します。これにより、ブロック内で例外が発生した場合でもロックが正しく解放され、デッドロックが回避されます。

インポートスレッド

# 1. ロックオブジェクトを作成する
my_lock = threading.Lock()
共有カウンター = 0

def increment_task():
    グローバル共有カウンター
    # 2. with を使用して、acquire() と release() を自動的に管理する
    my_lock を使用:
        # このブロック内のコードは一度に 1 つのスレッドでのみ実行できます
        temp = 共有カウンター
        温度 += 1
        共有カウンター = 温度

# 複数のスレッドのテストを開始する
スレッド = [threading.Thread(target=increment_task) for _ in range(100)]
スレッド内の t の場合: t.start()
スレッド内の t の場合: t.join()

print(f"最終カウント: {shared_counter}")

2. 手動制御方法

推奨されませんが、より細かい制御が必要な場合があります。手動で呼び出す必要がありますacquire()ロックを取得し、finallyブロック内で呼び出しますrelease()。

ロック = threading.Lock()

defマニュアル_タスク():
    lock.acquire() #ロックを取得します。すでにロックが占有されている場合は、ここでブロック（待機）します。
    試してみてください:
        # タスクを実行する
        パスする
    最後に：
        lock.release() # 解放する必要があります。解放しないと、他のスレッドは実行できなくなります。

3. ロック特性: 非再入性

threading.Lockリエントラントではありません。これは、同じスレッドがすでにロックを保持しているときに同じロックを再度要求すると、スレッド自体が「ロック」されます (デッドロック) ことを意味します。

• 解決: 同じスレッド内で同じロックを複数回取得する必要がある場合は、代わりに を使用します。threading.RLock()(リエントラントロック)。

4. いつロックを使用する必要がありますか?

• グローバル変数を変更する：カウンタやアキュムレータなど。
• 非スレッドセーフなオブジェクト：先ほどもおっしゃったようにGoogle API Service物体。
• ファイル書き込み: 複数の実行スレッドが同じファイルを同時に書き込み、コンテンツの混乱を引き起こすことを防ぎます。
• データベース操作: 複数の実行スレッドがクエリと送信のために同じ接続を共有する場合。

パフォーマンスに関する考慮事項

ロックを過度に使用すると、複数のスレッドが「実行のキュー」に入れられるため、プログラムのパフォーマンスが低下します。可能であれば優先的に使用してくださいqueue.Queueまたは以前に議論したことThread-Local Storage、これらの方法は通常、頻繁にロックするよりも効率的で、エラーが発生しにくくなります。

Python 非同期プログラミング

Pythonでは、async defそしてawait実現される非同期プログラミングコア構文。これらにより、I/O タスク (ネットワーク要求、ファイルの読み取りなど) の待機中にプログラムが停止するのを防ぎ、代わりに他のタスクを処理できるようになり、パフォーマンスが大幅に向上します。

1. async def: コルーチン関数を定義します。

関数定義の先頭に次の文字を追加すると、async、関数は次のようになります。コルーチン関数。これを呼び出すと、コンテンツはすぐには実行されませんが、「コルーチン オブジェクト」が返されます。

非同期デフォルト fetch_data():
    print("データの取得を開始します...")
    # 時間のかかるタスクをシミュレートする
    戻り値 {"データ": "成功"}

# 直接呼び出しはコルーチン オブジェクトを取得するだけであり、print は実行されません。
結果 = fetch_data()
print(result) # 出力: <coroutine object fetch_data at ...>

2. await: 一時停止して待機します。

awaitしかありませんasync def内部使用用。その機能は、「現在のコルーチンを一時的に停止し、後続のタスクが完了するのを待って戻り値を取得する」ことです。待機中に、システムは他の非同期タスクを実行できます。

非同期をインポートする

非同期def main():
    # await を使用してコルーチンを実行し、結果を取得します
    データ = fetch_data() を待ちます
    print(f"キャプチャ結果: {data}")

# 非同期プログラムのエントリを開始します
asyncio.run(main())

3. 主要な比較表

4. 一般的なエラーと修正

• await を書き忘れました:これは最も一般的な間違いです。書かない場合はawait、あなたは得るでしょうcoroutineオブジェクトのプロパティ (たとえば、result.text）が噴出するときAttributeError。
• 一般的な関数で await を使用します。この結果、SyntaxError。外部関数に次の機能があることを確認する必要があります。asyncグルーミング。
• ブロック操作:存在するasync関数で使用されるtime.sleep()イベントループ全体がブロックされます。代わりに使用してくださいawait asyncio.sleep()。

5. 非同期を使用する理由は何ですか?

あなたが料理をしているところを想像してみてください。

• 同期:お湯を沸かすとき、やかんの前で呆然と立ち尽くし、お湯が沸騰してから野菜を切りに行く。
• 非同期 (非同期):水を沸騰させる（await）同時に、野菜を切りに行くと、お湯が沸騰する音（イベント通知）が対処を呼び戻します。

コルーチンを完了して結果を返す

loop.run_until_complete()はいasyncioモジュールの下位レベルのメソッドは、完了するまでコルーチンを実行し、結果を返すために使用されます。 Python 3.7 以降では、公式には使用が推奨されていますが、asyncio.run()ただし、特定の状況 (イベント ループを再利用する必要がある場合や起動ロジックをカスタマイズする必要がある場合など) では、このメソッドを使用する必要があります。

1.基本的な利用の流れ

使用run_until_completeまずイベント ループ オブジェクトを取得または作成してから、それにコルーチンを渡す必要があります。

非同期をインポートする

非同期定義 my_task():
    asyncio.sleep(1) を待ちます
    「タスクが完了しました」を返す

# 1. イベントループの取得
ループ = asyncio.get_event_loop()

# 2. コルーチンを完了まで実行し、戻り値を直接取得する
結果 = ループ.run_until_complete(my_task())

print(result) #出力: タスクが完了しました

2. asyncio.run() との違い

どちらも戻り値を取得できますが、ライフサイクルの管理方法は異なります。

3. 既存のループで結果を取得する

すでに実行中のスクリプト内で、コルーチンが実行されて値が取得されていることを確認したい場合は、次のメソッドを使用できます。

非同期をインポートする

非同期デフォルト追加(a, b):
    a + bを返す

ループ = asyncio.new_event_loop()
asyncio.set_event_loop(ループ)

試してみてください:
    # 最初のタスクを実行する
    val1 = ループ.run_until_complete(add(10, 20))
    #2番目のタスクを実行する
    val2 = ループ.run_until_complete(add(val1, 5))
    print(f"最終結果: {val2}")
最後に:
    # 手動で閉じる必要があります
    ループ.クローズ()

4. 複数のタスクの結果を取得する

複数のコルーチンを並行して実行し、戻り値を均一に取得したい場合は、一致させる必要があります。asyncio.gather：

非同期定義タスク(id):
    return f"結果{id}"

ループ = asyncio.get_event_loop()
# Gather は複数のコルーチンを 1 つのタスクにラップし、run_until_complete はすべてが完了するまで待機します。
results =loop.run_until_complete(asyncio.gather(タスク(1), タスク(2), タスク(3)))
print(results) #出力: ['結果 1', '結果 2', '結果 3']

5. 共通注意事項

• RuntimeError：すでに実行中の場合async def関数内での呼び出しrun_until_complete、噴き出しますThis event loop is already running。必ず非同期関数内で使用してください。await。
• リソースのクリーンアップ:ループを使用した後、次を呼び出す必要があります。loop.close()リソースを解放しないと、プログラムが正常に終了しなかったり、警告が生成されたりする可能性があります。
• 戻り値の型: run_until_completeコルーチンを返しますreturnコルーチン内でキャッチされない例外が発生した場合、その例外は呼び出し側にスローされます。

asyncio.run()これは、Python 3.7 以降に導入された高レベルの API です。これは、非同期プログラムを開始する最も推奨される方法です。自動的に処理してくれますイベントループを確立し、コルーチンを実行し、完了後にループを閉じます。。最も重要なことは、それがコルーチンに直接戻されることです。return価値。

1. 基本的な入手方法

ただ必要なのは、async def渡される関数呼び出しasyncio.run()、通常の同期関数と同様に結果を返します。

非同期をインポートする

非同期デフォルトの計算スコア(名前):
    print(f"{name} のスコアを計算しています...")
    await asyncio.sleep(1) # 時間のかかるタスクをシミュレートする
    95を返す

# return の結果を直接取得する
Final_score = asyncio.run(calculate_score("張暁明"))

print(f"最終スコアは: {final_score}") # 出力: 95

2. 複数のタスクの結果を処理する

通常は、main()エントリ ポイントとして機能し、内部のすべてのサブタスクの結果を取得し、最後にasyncio.run(main())統一された出力。

非同期定義 task_a():
    「リンゴ」を返す

非同期定義 task_b():
    「バナナ」を返します

非同期def main():
    # mainでgatherを使って同時実行する
    results = await asyncio.gather(task_a(), task_b())
    return results # リストを返す

# asyncio.run を通じて main の戻り値を取得します
all_fruits = asyncio.run(main())
print(all_fruits) # 出力: ['apple', 'banana']

3. asyncio.run()の実行規則

4. 一般的なエラー: RuntimeError

非同期関数内で別の非同期関数の結果を取得しようとしている場合は、次を使用します。await、 の代わりにasyncio.run()。

# エラーのデモ
async def sub_task():
    10を返す

非同期def main():
    # ここでエラーが発生します: RuntimeError: asyncio.run() は実行中のイベント ループから呼び出すことはできません
    res = asyncio.run(sub_task())
    
# 訂正
非同期def main():
    res = await sub_task() # 非同期環境では await を使用してください

5. 実践的な提案

• 最外層は以下を使用します。バンドルasyncio.run()プログラムのスタートボタンとして、if __name__ == "__main__":ブロックの中で。
• 例外処理:コルーチン内でエラーが発生し、キャッチされなかった場合は、asyncio.run()例外は直接スローされます。推奨されるのは、runアウターレイヤープラスtry...except。
• ポストバックタイプ:コルーチンが文字列、辞書、またはカスタム オブジェクトを返すかどうかに関係なく、asyncio.run()そのまま取り外すことができます。

Pythonデータ分析

Python の科学演算 NumPy

NumPy(Numerical Python) は、Python の最も重要な科学計算ライブラリです。効率的な多次元配列オブジェクトを提供します。ndarray、およびこれらの配列を操作するための数学関数の大規模なライブラリ。これは、データ サイエンス、機械学習 (Pandas、Scikit-learn、TensorFlow など) およびその他の分野の基礎となる柱です。

1. ネイティブ List ではなく NumPy を選択する理由は何ですか?

• 高性能:C 言語で書かれているため、配列操作は連続メモリ内で実行され、Python の組み込みリスト (List) よりもはるかに高速です。
• ベクトル化:明示的に記述する必要がなく、配列全体に対して数学的演算を実行できるようになります。for丸。
• 放送：異なる形状の配列間の演算を自動的に処理します。

2. コアオブジェクト: ndarray の基本操作

numpyをnpとしてインポート

# 1次元配列と2次元配列を作成する
arr1 = np.array([1, 2, 3])
arr2 = np.array([[1, 2], [3, 4]])

# 特定の配列をすばやく作成する
zeros = np.zeros((3, 3)) # すべてがゼロの 3x3 行列
ones = np.ones((2, 4)) # すべて 1 の 2x4 行列
eye = np.eye(3) # 3x3 単位行列
range_arr = np.arange(0, 10, 2) # [0, 2, 4, 6, 8]

3. よく使用される配列演算と属性

4. スライスとインデックス作成

NumPy のスライス構文は Python List に似ていますが、より強力で、多次元の同時スライスをサポートしています。

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 2 番目の列 (インデックス 1) を取得します
print(arr[1, :]) # [4, 5, 6]

# 右下隅の 2x2 部分行列を取得します
print(arr[1:, 1:]) # [[5, 6], [8, 9]]

5. インストールとバージョンの確認

• インストール： pip install numpyまたはconda install numpy。
• バージョンを確認します:

  import numpy as np
  print(np.__version__)

6.Numbaと併用する

前述したように、NumbaNumPy の配列構造を完全に認識し、さらに複雑な NumPy 操作をマシンコードにコンパイルして、ネイティブ C 言語に近い実行限界に達します。

Python は大量のデータを効率的に処理します Numba

Numbaこれは、大量のデータを処理する Python コードを高速化するために特別に設計されたオープンソース JIT (ジャストインタイム) コンパイラーです。 C、C++、または Fortran と同等の実行速度で Python 関数をマシンコードに変換でき、特に次の用途に適しています。NumPy配列操作。

1. 主要な機能と利点

• JIT コンパイル:事前コンパイル (AOT) ではなく、プログラム実行時のジャストインタイム コンパイル。
• NumPy のサポート:NumPy の配列や関数に対する優れた最適化効果。
• GPUアクセラレーション：CUDA または ROCm のサポートを通じて、コンピューティング タスクを NVIDIA または AMD グラフィックス カードに転送して実行できます。
• 並列操作:簡単なタグで実現できるマルチコアCPU並列処理をサポートします。

2. 基本的な使用例

Numba を使用する最も簡単な方法は、次のように追加することです。@jitまたは@njitデコレーター。

numbaインポートnjitから
numpyをnpとしてインポート

# @njit は、Python パーサーに入らないようにする「nopython」モードを表し、最も高速です
@njit
def fast_function(n):
    合計=0
    range(n) の i の場合:
        合計 += i
    返品合計

# 最初の呼び出しはコンパイルされ、2 番目の呼び出しはマシンコードを直接実行します
print(fast_function(10000000))

3. パターンの比較: nopython と object

4. 一般的に使用される手法: 並列操作

CPU のマルチコア機能を活用するには、単にオンにします。parallel=Trueそして使用しますprange。

numba import njit、prange から

@njit(平行=True)
デフォルトのParallel_sum(A):
    s = 0
    # prange はループを別の CPU コアに自動的に割り当てます
    prange(A.shape[0]) の i の場合:
        s += A[i]
    を返します

5. インストールと依存関係のチェック

• インストール手順: pip install numbaまたはconda install numba。
• 依存関係:Numba の依存関係LLVMコンパイラ フレームワーク (経由)llvmlite図書館）。
• インストールを確認します。

  import numba
  print(numba.__version__)

6. 利用制限

• 非純粋な数値計算:Numba は Python に取り組んでいますdict、listまたは、オブジェクトをカスタマイズするときのパフォーマンスが低下します。
• コンパイルのオーバーヘッド:関数を初めて実行するときは、コンパイルのために短い遅延が発生します。
• サードパーティのライブラリ:Numba が公式サポート (NumPy など) を持っていない限り、ほとんどのサードパーティ ライブラリ関数はコンパイルできません。

パンダデータ分析ツール

パンダとは何ですか？

Pandas は、表形式データや時系列データなどの構造化データを処理するために設計された Python ベースのデータ分析および操作ツールです。

Pandas のコア データ構造

• Series：タグの 1 次元配列。インデックス付きリストとして表示できます。
• DataFrame：スプレッドシートや SQL テーブルに似た 2 次元のデータ構造。

パンダの主な特徴

• 複数の形式 (CSV、Excel、JSON、SQL など) でデータを読み書きします。
• 欠損値の補充や重複値の削除など、データのクリーニングと前処理。
• データのフィルタリング、グループ化、集計操作。
• 時系列の分析と処理。
• NumPy や Matplotlib などの他のデータ サイエンス ツールを統合します。

使用例

パンダをPDとしてインポートする

# データフレームを作成する
データ = {'名前': ['アリス', 'ボブ', 'チャーリー'],
        「年齢」: [25、30、35]、
        '都市': ['台北'、'台中'、'高雄']}
df = pd.DataFrame(データ)

# データを表示する
印刷(df)

# 28 年より古い情報をフィルタリングします
filtered_df = df[df['age'] > 28]
印刷(filtered_df)

該当するシナリオ

• 大規模なデータセットを分析します。
• データのクリーニングとフォーマット変換のタスクを処理します。
• データを迅速に探索して視覚化します。

なぜパンダを選ぶのか？

Pandas は、特にデータの分析と処理に適した、効率的で柔軟かつ直感的な操作方法を提供します。データ サイエンスと機械学習に欠かせないツールの 1 つです。

結論は

Pandas は強力なデータ分析ツールであり、初心者も上級ユーザーもその使いやすいデザインと広範な機能の恩恵を受けることができます。

Python Googletrans

Googletransをインストールする

まずインストールする必要がありますgoogletransキット。コマンドラインに次のコマンドを入力します。

pip install googletrans==4.0.0-rc1

注意：インストール時にバージョンをご確認ください。4.0.0-rc1、古いバージョンは動作しなくなる可能性があるためです。

基本的な使用例

英語を繁体字中国語に翻訳する例を次に示します。

googletransインポート翻訳者から

#Translator オブジェクトを初期化する
翻訳者 = 翻訳者()

# テキストを翻訳する
text = 「こんにちは、お元気ですか？」
result = translator.translate(text, src="en", dest="zh-tw")

# 翻訳結果を出力する
print("元のテキスト:", text)
print("翻訳:", result.text)

サポートされている言語コード

複数の言語を翻訳できます。共通の言語コードは次のとおりです。

• 英語：en
• 繁体字中国語:zh-tw
• 簡体字中国語:zh-cn
• 日本語：ja
• 韓国語:ko
• フランス語：fr
• ドイツ語:de

注意事項

Googletrans は非公式の Google Translate API であり、Google 側の変更により機能しなくなる可能性があります。翻訳機能が動作しない場合は、Google の公式クラウド翻訳など、他の翻訳 API の使用を検討してください。 API。

Python のその他の翻訳キット

DeepL Translator

DeepL は高精度の翻訳サービスを提供しますが、開発者 API を使用するには API キーが必要です。

Microsoft Translator

Microsoft が提供する翻訳ツールは多言語翻訳をサポートしていますが、Azure API キー設定を使用する必要があります。

Amazon Translate

アマゾン ウェブ サービス (AWS) が提供する翻訳サービスは、多言語テキストの効率的な翻訳を提供します。AWS が提供する API キーを介してアクセスする必要があります。

LibreTranslate

LibreTranslate は、独自のサーバーをセットアップでき、API キーを必要としないオープンソースの翻訳ツールです。一部のサードパーティの公開サーバーでは、API キーなしで使用するオプションも提供しています。

TextBlob

TextBlob は、Google 翻訳機能が組み込まれた自然言語処理ベースのツールです。ただし、古いバージョンでは API キーが必要ないため、バージョンのサポートに注意を払う必要がある場合があります。

MyMemory

MyMemory は記憶ベースの翻訳を提供します。一部の機能はAPIキーを必要としませんが、高度な使用には申請が必要な場合があります。

結論は

Googletrans の競合他社の中で、LibreTranslate と TextBlob の一部のバージョンは、API キーを必要としないオプションを提供しています。完全に無料で追加のセットアップが必要ないツールが必要な場合は、これらのオプションを検討してください。

OpenCC 中国語変換

OpenCC(Open Chinese Convert) は、簡体字中国語から繁体字中国語への変換に特化したオープンソース プロジェクトです。これは単純な単語から単語への変換だけではなく、さらに重要なことに、語彙レベルさまざまな地域（中国本土、台湾、香港）における単語の使用習慣の変換と違い。

1. OpenCC の主な利点

• 正確な変換:「ファ（発展）」と「ファ（髪）」など、単純な状況と複雑な状況を区別できる。
• 地域サポート:台湾の繁体字中国語、香港の繁体字中国語、および中国本土の簡体字中国語間の用語変換をサポートします (例: ソフトウェアとソフトウェア)。
• 高性能:C++ を使用して開発され、Python、Node.js、Java などの複数の言語インターフェイスを提供します。
• カスタム辞書:ユーザーが独自の変換ルールを作成できるようにします。

---

2. Pythonのインストールと基本的な使い方

Python で最も一般的に使用されるパッケージ化ライブラリは次のとおりです。opencc-python-reimplemented。

# インストール手順
pip install opencc-python-reimplemented

# 基本的なコード例
opencc から OpenCC をインポート

# 初期化、s2t は Simplified to Traditional (簡素化から従来型へ) を表します。
cc = OpenCC('s2t')
text = 「人工知能が世界を変えた」
結果 = cc.convert(テキスト)

print(result) #出力: 人工知能は世界を変えました

---

3. 共通変換モード比較表

スキーマ名	説明する	該当する状況
s2t	簡体字中国語から繁体字中国語へ	標準文字を簡体字から繁体字に変換します。
t2s	繁体字中国語から簡体字中国語へ	標準文字は繁体字から簡体字に変換されます。
s2twp	簡体字中国語から台湾語繁体字中国語（語彙を含む）	台湾で最もよく使われています。「ソフトウェア」を「ソフトウェア」に変換します。
tw2s	台湾繁体字中国語から簡体字中国語へ	台湾の慣用句を中国大陸の簡体字中国語に変換します。
s2hk	香港繁体字への簡体字化	香港の言葉の使用習慣に準拠しています（「里」を「里」に変えるなど）。

---

4. コマンドラインツール(CLI)

プログラムを作成したくない場合は、ターミナルで OpenCC を直接操作することもできます。

# 簡体字モードから台湾繁体字モードを使用して、input.txt を output.txt に変換します
opencc -i 入力.txt -o 出力.txt -c s2twp.json

---

5. よくある質問と注意事項

• 1 つの単純なものと多数の複雑なもの:OpenCC は良好なパフォーマンスを示しますが、いくつかの極端な状況では依然としてエラーが発生する可能性があるため、重要なドキュメントについては依然として手動校正が必要であることが推奨されます。
• 環境の依存関係:ネイティブ OpenCC には C 実行環境が必要です。 Python ライブラリのインストール時にエラーが発生した場合は、次を使用してみてください。reimplementedバージョン。
• JSON 構成:変換ロジックは次のようになります。.jsonファイル定義については、OpenCC インストール ディレクトリに移動して、これらの辞書がどのように機能するかを確認できます。

---

---

Python クエリの中国語の発音表記

次の例では、Python を使用して漢字のすべての発音表記をクエリする方法を示します。私たちは使用しますpypinyin漢字のピンインを取得し、ピンインから発音記号への対応表をカスタマイズするキット。

ステップ 1: pypinyin パッケージをインストールする

pip install pypinyin

ステップ 2: Python コードの例

以下は、発音対応表と、HTML 結果のクエリと生成のためのプログラム ロジックを含む Python コードです。

pypinyin からインポート pinyin、スタイル
jinja2 インポート テンプレートから

# ピンインから注音への簡易対応表
ピンインと注音 = {
    "a": "ㄚ"、"ai": "ㄞ"、"an": "ㄢ"、"ang": "ㄤ"、"ao": "ㄠ"、
    「バ」：「ㄅㄚ」、「バイ」：「ㄅㄞ」、「バン」：「ㄅㄢ」、「バン」：「ㄅㄤ」、「バオ」：「ㄅㄠ」、
    # 一部の対応を省略しているため、自分で改善する必要があります
    "ハオ": "ㄏㄠ"、"ハオ": "ㄏㄠ"、"ハオ": "ㄏㄠˇ"、"ハオ": "ㄏㄠˋ"
}

# 中国語の文字のすべてのピンインをクエリし、ピンインに変換します
def get_zhuyin(char):
    pinyins = pinyin(char, style=Style.NORMAL, heteronym=True)
    unique_pinyins = set(pinyins[0])
    zhuyins = {p: pinyin_to_zhuyin.get(p, p) for p in unique_pinyins} # ピンインを注音に変換
    戻りリスト(zhuyins.values())

# クエリ文字
chinese_char = 'good' # 他の文字に置き換えることができます
zhuyin_results = get_zhuyin(chinese_char)

説明する

• ピンインから音声への変換:使用pinyin_to_zhuyinピンインを発音記号にマッピングする辞書。この対応表は独自に拡張する必要があります。
• Jinja2 テンプレート:Jinja2 テンプレートを使用して HTML を生成し、結果を Web ページに出力して表示します。
• 多音文字のサポート:使用heteronym=True多発音文字のすべての発音が表示されていることを確認してください。

---

---

Python ストレージ

ファイルまたはフォルダーが存在するかどうかを確認する

OS.パスを使用する

OSをインポートする

# ファイルかどうかを確認する
os.path.isfile("example.txt") の場合:
    print("ファイルが存在します")

# フォルダーかどうかを確認する
os.path.isdir("my_folder") の場合:
    print("フォルダは存在します")

# ファイルまたはフォルダーが存在するかどうかを確認します
os.path.exists("パス/チェック先"):
    print("パスが存在します")

pathlib の使用 (Python 3.4 以降)

pathlibインポートパスから

パス = パス("example.txt")

path.exists() の場合:
    print("パスが存在します")

path.is_file() の場合:
    print("ファイルです")

path.is_dir() の場合:
    print("フォルダーです")

---

---

Pythonのファイル操作

Python では、ファイルのコピー、移動、名前変更、削除を処理するための最も標準的で強力なモジュールは次のとおりです。shutil(高レベルの操作の場合) およびos(基本的なパス操作の場合)。

---

1. ファイルコピー操作（Copy）

コピー操作には、メタデータを保存する必要があるかどうか (作成時間、権限など) に応じてさまざまな機能があります。

• shutil.copy(コピー元、コピー先):ファイルの内容と権限をコピーします。宛先はディレクトリにすることができます。
• shutil.copy2(ソース、宛先):最も推奨されるのは、アーカイブのすべてのメタデータ (タイムスタンプなど) を可能な限り完全に保存することです。
• shutil.copytree (ソース フォルダー、宛先フォルダー):ディレクトリ全体とそのすべての内容を再帰的にコピーします。

インポートシュティル

# 単一のファイルをコピーする
shutil.copy2('ソース.txt', '宛先.txt')

# フォルダー全体をコピーします (宛先フォルダーが存在してはいけません)
shutil.copytree('my_folder', 'backup_folder')

---

2. ファイルの移動と名前変更（Move/Rename）

移動と名前変更の基本的なロジックは非常に似ています。使用shutil.moveディスク間で実行できますが、os.rename同じディスクの名前を変更するためによく使用されます。

関数	共通コマンド	説明する
ファイルまたはディレクトリを移動する	shutil.move(src, dst)	ファイルまたはディレクトリ全体を新しいパスに移動し、クロスパーティションをサポートします。
ファイル名の変更	os.rename(old, new)	ファイル名またはディレクトリ名を変更します。

インポートシュティル
OSをインポートする

# ファイルを移動する
shutil.move('test.txt', 'archive/test.txt')

# 名前を変更する
os.rename('古い名前.txt', '新しい名前.txt')

---

3. ファイル削除操作（Remove）

これらのコマンドは通常、ごみ箱を経由せず、直接完全に削除するため、削除操作は注意して使用する必要があります。

• os.remove(パス):単一のファイルを削除します。パスがディレクトリの場合、エラーが報告されます。
• os.rmdir(パス):空のディレクトリを削除します。
• shutil.rmtree(パス):ディレクトリ ツリー全体 (内部のすべてのファイルとサブディレクトリを含む) を強制的に削除します。

# 単一のファイルを削除する
os.path.exists('temp.txt') の場合:
    os.remove('temp.txt')

# フォルダごと強制削除
shutil.rmtree('old_data_folder')

---

4. パスとステータスの確認

コピーまたは移動を実行する前に、プログラムのクラッシュを避けるためにパスが存在するかどうかを確認してください。

• os.path.exists(path)：パスが存在するかどうかを確認します。
• os.path.isfile(path)：ファイルであるかどうかを確認します。
• os.path.isdir(path)：ディレクトリであるかどうかを確認します。

---

5. 注意事項と提案

• パス処理:推奨os.path.join()またはpathlibWindows (バックスラッシュ) と Linux (スラッシュ) の間でプログラムが動作することを保証するためにパスを結合するモジュール。
• 例外処理:ファイル操作は、アクセス許可が不十分であることやファイルが占有されていることが原因で簡単に失敗する可能性があります。使用することをお勧めしますtry...exceptパック。
• オーバーライド動作: shutil.copyそしてshutil.move宛先パスに同じ名前のファイルがすでに存在する場合、通常は直接上書きされます。実行前に、名前を変更する必要があるかどうかを確認してください。

---

---

ロギングスイート

パイソンloggingこのスイートは、アプリケーションで効果的なログ管理を行うための強力な組み込みセットです。デバッグ情報のログ、エラー追跡、またはパフォーマンス監視のいずれであっても、logging各スイートは、マルチレベルおよびマルチフォーマットのロギング方法を提供できます。

基本的な概念

• Logger: ロガー。ログ メッセージの作成と管理を担当します。
• Handler: コンソール、ファイル、ネットワークなどのログの出力場所を決定するために使用されるプロセッサ。
• Formatter:Formatter は、ログ メッセージの出力形式を定義します。
• Level:Level、ログの重大度レベルを設定します。たとえば、DEBUG、INFO、WARNING、ERRORそしてCRITICAL。

サンプルコード

ここが基本ですloggingキット構成例：

インポートログ

# ロガーを設定する
ロガー =logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# ハンドラーの設定
console_handler =logging.StreamHandler()
file_handler =logging.FileHandler('app.log')

# フォーマッタを設定する
formatter =logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(フォーマッタ)
file_handler.setFormatter(フォーマッタ)

# ロガーにハンドラーを追加
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# さまざまなレベルのログをテストする
logger.debug('これはデバッグ メッセージです')
logger.info('これは情報メッセージです')
logger.warning('これは警告メッセージです')
logger.error('これはエラー メッセージです')
logger.critical('これは重大なメッセージです')

ログレベル

logging次のログ レベルがサポートされています。

• DEBUG: デバッグ情報に使用される最低レベル。
• INFO：システムの稼働状況などの一般的な情報。
• WARNING: 警告情報ですが、プログラムは停止しません。
• ERROR: エラー情報。通常、エラーが原因で問題が発生します。
• CRITICAL: プログラムの終了を引き起こす可能性がある最も重大なエラー。

カスタム出力形式

使用できますFormatterログの出力形式を定義するクラス。例えば：

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

この形式では、次のような内容が出力されます。

2024-10-25 10:00:00 - my_logger - 情報 - これは情報メッセージです

まとめ

loggingこのスイートはさまざまなログ管理オプションを提供し、開発者がニーズに応じてログ レベル、出力形式、出力先をカスタマイズできるため、アプリケーションの保守性とデバッグ効率が向上します。

---

---

Logging Handler

Pythonでloggingキットの中で、Handlerこれは、ログの出力場所を定義する重要なコンポーネントです。プロセッサが異なれば、コンソール、ファイル、ネットワーク、さらには電子メールなど、異なる出力先にログを出力できます。StreamHandler最も一般的に使用されるプロセッサの 1 つであり、コンソールにログを出力する役割を果たします。

メインプロセッサ（ハンドラ）

存在するlogging、いくつかの一般的なHandler含む：

• StreamHandler: ログを出力する場所stdoutまたはstderr(通常はコンソール)。
• FileHandler：ログをファイルに出力します。
• NullHandler: ログ出力を無視します。表示する必要がない場合に適しています。
• SMTPHandler: ログを電子メールで送信します。

StreamHandler とコンソール出力の関係

StreamHandlerコンソール出力に最も一般的に使用されるプロセッサであり、通常はログ メッセージを標準エラーに送信します (stderr）。設定を通じてStreamHandlerログをコンソールに直接表示できるため、システム ステータスのリアルタイム監視に適しています。

ログをコンソールに表示したくない場合は、ロガーからログを削除できます。StreamHandler、または代わりに使用しますNullHandler出力を避けるため。

サンプルコード: コンソール出力の削除

次の例は、設定方法を示しています。loggingコンソール出力を削除しますStreamHandler：

インポートログ

# ロガーを設定する
ロガー =logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# コンソールに出力する StreamHandler を追加
console_handler =logging.StreamHandler()
logger.addHandler(console_handler)

# テスト出力
logger.info("このメッセージはコンソールに表示されます")

# コンソール出力を削除します
logger.removeHandler(console_handler)
logger.info("このメッセージはコンソールには表示されません")

NullHandler を使用してコンソール出力を回避する方法

使用できますNullHandlerログのすべての出力を無効にするには:

インポートログ

# ロガーを設定し、NullHandler を追加する
ロガー =logging.getLogger('my_logger')
logger.addHandler(logging.NullHandler())

# このメッセージはコンソールには表示されません
logger.info("このメッセージは表示されません")

まとめ

Handlerはいlogging出力場所を定義するスイート内のコンポーネント。を通してStreamHandler、ログ メッセージをコンソールに表示して、リアルタイムの監視を容易にすることができます。コンソール出力が必要ない場合は削除できます。StreamHandlerまたは使用しますNullHandlerログ出力を無効にします。

---

---

Python ログのスレッド ID

ログ形式を変更する

スレッド ID をlogging.Formatterに含めるには、%(thread)d財産。これには、システムによってスレッドに割り当てられた一意の整数 ID が表示されます。

インポートログ

# %(thread)d を追加してスレッド ID を表示します
log_formatter =logging.Formatter(
    '%(asctime)s.%(msecs)03d %(thread)d %(levelno)s %(message)s',
    "%Y-%m-%d %H:%M:%S"
)

#出力例:
# 2025-12-20 16:30:45.123 140735612345678 20 これはログ メッセージです

よく使用されるスレッド関連のプロパティ

整数 ID に加えて、必要に応じてスレッド名の表示を選択することもできます。

• %(thread)d: スレッドの整数 ID を表示します。
• %(threadName)s: スレッドの名前を表示します (MainThread や Thread-1 など)。

完全なサンプルコード

このコードは、この形式をマルチスレッド環境に適用する方法を示しています。

インポートログ
インポートスレッド

#1. フォーマッタを設定する
log_format = '%(asctime)s.%(msecs)03d [スレッド:%(thread)d] %(levelno)s %(message)s'
date_format = "%Y-%m-%d %H:%M:%S"
formatter =logging.Formatter(log_format, date_format)

# 2. ログプロセッサの設定
ハンドラー =logging.StreamHandler()
handler.setFormatter(フォーマッタ)

logger =logging.getLogger("ThreadTest")
logger.addHandler(ハンドラー)
logger.setLevel(logging.INFO)

#3. テスト機能
デフォルトタスク():
    logger.info("サブスレッドが実行中です")

# テストを開始する
logger.info("メインスレッドが開始されました")
t = threading.Thread(ターゲット=タスク)
t.start()
t.join()

---

---

Pythonライブラリ

Python でよく使われるライブラリスイート

リレーショナル データベース (SQL)

SQLite (組み込み)

Python には SQLite のサポートが組み込まれており、小規模なアプリケーションに適しています。

import sqlite3

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

cursor.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
cursor.execute("INSERT INTO users (name) VALUES (?)", ("Alice",))
conn.commit()

cursor.execute("SELECT * FROM users")
print(cursor.fetchall())

cursor.close()
conn.close()

MySQL（PyMySQL）

MySQL データベースに接続するために使用されます。

pip install pymysql

import pymysql

conn = pymysql.connect(host="localhost", user="root", password="password", database="test")
cursor = conn.cursor()

cursor.execute("SELECT * FROM users")
print(cursor.fetchall())

cursor.close()
conn.close()

PostgreSQL（psycopg2）

PostgreSQL への接続に使用されます。

pip install psycopg2

import psycopg2

conn = psycopg2.connect(dbname="testdb", user="user", password="password", host="localhost")
cursor = conn.cursor()

cursor.execute("SELECT * FROM users")
print(cursor.fetchall())

cursor.close()
conn.close()

SQL Server（pyodbc）

Microsoft SQL Server への接続に使用されます。

pip install pyodbc

import pyodbc

conn = pyodbc.connect("DRIVER={SQL Server}; SERVER=localhost; DATABASE=test; UID=user; PWD=password")
cursor = conn.cursor()

cursor.execute("SELECT * FROM users")
print(cursor.fetchall())

cursor.close()
conn.close()

非リレーショナル データベース (NoSQL)

MongoDB（pymongo）

ファイルベースのデータベースに適しています。

pip install pymongo

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")
db = client["testdb"]
collection = db["users"]

collection.insert_one({"name": "Alice", "age": 25})
print(list(collection.find()))

Redis（redis-py）

キャッシュと高パフォーマンスの Key-Value アクセスに適しています。

pip install redis

import redis

r = redis.Redis(host="localhost", port=6379, decode_responses=True)

r.set("name", "Alice")
print(r.get("name"))

Elasticsearch（elasticsearch-py）

全文検索や分析に適しています。

pip install elasticsearch

from elasticsearch import Elasticsearch

es = Elasticsearch("http://localhost:9200")

doc = {"name": "Alice", "age": 25}
es.index(index="users", document=doc)

print(es.search(index="users", query={"match_all": {}}))

ORMフレームワーク

SQLAlchemy

複数の SQL データベースをサポートし、ORM 機能を提供します。

pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, sessionmaker

engine = create_engine("sqlite:///example.db")
Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

session.add(User(name="Alice"))
session.commit()

print(session.query(User).all())

結論は

• 関連データベース:sqlite3(内蔵)、pymysql（MySQL）、psycopg2（PostgreSQL）、pyodbc（SQL Server）。
• 非リレーショナルデータベース:pymongo（MongoDB）、redis（Redis）、elasticsearch（Elasticsearch）。
• ORM フレームワーク:SQLAlchemy(複数の SQL データベースをサポートします)。

---

---

PyMySQL

PyMySQLをインストールする

次の手順に従って PyMySQL をインストールします。

pip install pymysql

MySQLデータベースに接続する

PyMySQL を使用して MySQL サーバーに接続します。

インポートpymysql

# 接続を確立する
conn = pymysql.connect(
    ホスト = "ローカルホスト",
    ユーザー = "あなたのユーザー"、
    パスワード="あなたのパスワード",
    データベース = "あなたのデータベース",
    charset="utf8mb4",
    Cursorclass=pymysql.cursors.DictCursor # 辞書形式を返す
)

#カーソルの作成
カーソル = conn.cursor()

# クエリ情報
Cursor.execute("SELECT * FROM your_table")
結果 = カーソル.fetchall()
結果の行の場合:
    印刷(行)

# 接続を閉じる
カーソル.クローズ()
conn.close()

SQL文の実行

INSERT、UPDATE、および DELETE ステートメントを実行するときは、変更を送信する必要があります。

試してみてください:
    conn.cursor() をカーソルとして使用:
        sql = "ユーザー (名前、年齢) の値 (%s、%s) に挿入"
        カーソル.execute(sql, ("アリス", 25))
    conn.commit() # 変更を送信する
e としての例外を除く:
    conn.rollback() # エラー発生時のロールバック
    print("エラーが発生しました:", e)

ストアド プロシージャを実行する

使用できますcallprocストアド プロシージャを呼び出します。

with conn.cursor() as cursor:
    cursor.callproc("your_stored_procedure", (param1, param2))
    result = cursor.fetchall()
    print(result)

データをバッチで挿入する

使用executemany一括挿入を実行するには:

data = [("Bob", 30), ("Charlie", 28), ("David", 35)]
sql = "INSERT INTO users (name, age) VALUES (%s, %s)"

with conn.cursor() as cursor:
    cursor.executemany(sql, data)
conn.commit()

SQLインジェクションを防ぐ

SQL インジェクション攻撃を防ぐには、パラメーター化されたクエリを使用します。

name = "Alice"
sql = "SELECT * FROM users WHERE name = %s"

with conn.cursor() as cursor:
    cursor.execute(sql, (name,))
    result = cursor.fetchall()
    print(result)

接続を閉じる

プログラムが終了したら、必ずデータベース接続を閉じてください。

conn.close()

---

---

PyMySQLの日時の使用法

1. 日時の挿入 (Python 日時 → MySQL 日時)

PyMySQL は自動的にdatetime.datetimeMySQL DATETIME に変換し、直接渡すことができます。

import pymysql
import datetime

conn = pymysql.connect(
    host="localhost",
    user="root",
    password="pwd",
    database="testdb",
    cursorclass=pymysql.cursors.DictCursor
)

with conn:
    with conn.cursor() as cur:
        now = datetime.datetime.now()

        sql = """
            INSERT INTO logs (msg, created_at)
            VALUES (%s, %s)
        """

        cur.execute(sql, ("hello world", now))
        conn.commit()

2. 日付の挿入 (Python 日付 → MySQL DATE)

today = datetime.date.today()

sql = "INSERT INTO records (start_date) VALUES (%s)"
cur.execute(sql, (today,))
conn.commit()

3. 日時のクエリ (MySQL DATETIME → Python 日時)

見つかったフィールドは自動的に次のようになります。datetime.datetimeタイプ。

sql = "ログから id、created_at を選択 ORDER BY id DESC LIMIT 1"
cur.execute(SQL)
row = cur.fetchone()

dt = row["created_at"]
print(dt, type(dt))
# 例: 2025-07-01 15:22:33

4. 検出された日時を文字列にフォーマットします

formatted = dt.strftime("%Y-%m-%d %H:%M:%S")
print(formatted)

5. クエリ条件として日時を使用する

start = datetime.datetime(2025, 1, 1, 0, 0, 0)

sql = """
    SELECT * FROM logs
    WHERE created_at >= %s
"""
cur.execute(sql, (start,))
rows = cur.fetchall()

6. 一定期間内のデータのクエリ

begin = datetime.datetime(2025, 1, 1)
end   = datetime.datetime(2025, 1, 31, 23, 59, 59)

sql = """
    SELECT * FROM logs
    WHERE created_at BETWEEN %s AND %s
"""
cur.execute(sql, (begin, end))
rows = cur.fetchall()

7. データベースの日時が文字列 (VARCHAR/CHAR) で保存されている場合は、手動で解析する必要があります。

sql = "SELECT created_at FROM logs_str LIMIT 1"
cur.execute(sql)
row = cur.fetchone()

dt = datetime.datetime.strptime(row["created_at"], "%Y-%m-%d %H:%M:%S")
print(dt)

8. 日時を大量に挿入する (executemany)

items = [
    ("log1", datetime.datetime.now()),
    ("log2", datetime.datetime.now()),
]

sql = "INSERT INTO logs (msg, created_at) VALUES (%s, %s)"
cur.executemany(sql, items)
conn.commit()

結論は

• PyMySQL は datetime ↔ MySQL DATETIME を自動的に処理します。手動で変換する必要はありません。
• データを挿入するときは、Python の日時を渡すだけです。
• MySQL DATETIME にクエリを実行すると、datetime.datetime オブジェクトが取得されます。
• これは、MySQL の日時が文字列として保存されている場合にのみ必要です。strptime手動解析。

---

---

pymysqlクエリ結果から日時フィールドを取得します

基本的な使い方

インポートpymysql
インポート日時

# データベース接続を確立する
conn = pymysql.connect(
    ホスト='ローカルホスト',
    ユーザー='ルート'、
    パスワード='your_password',
    データベース='your_db',
    Cursorclass=pymysql.cursors.DictCursor # フィールドを辞書として返します
)

コン付き:
    conn.cursor() をカーソルとして使用:
        sql = "your_table LIMIT 1 から ID、created_at を選択"
        カーソル.実行(SQL)
        結果 = カーソル.fetchone()

        dt = result['created_at'] # created_at フィールドは datetime 型であると仮定します
        印刷(dt)
        print(タイプ(dt))

文字列に変換する

dt_str = dt.strftime("%Y-%m-%d %H:%M:%S")
print(dt_str)

データが文字列形式の場合

# created_at が文字列形式 (CHAR / VARCHAR など) で格納されている場合
dt = datetime.datetime.strptime(result['created_at'], "%Y-%m-%d %H:%M:%S")
印刷(dt)

補足: カーソルクラスの選択

# DictCursor が設定されていない場合、データはタプルとなり、値のメソッドは次のようになります。
カーソル = conn.cursor()
Cursor.execute("SELECT ID, created_at FROM your_table")
行 = カーソル.fetchone()
dt = 行[1]

---

---

SQLの日時と現在時刻の差を取得します。

サンプルプログラム - 現在時刻からの日数差

インポートpymysql
インポート日時

# Establish database connection
conn = pymysql.connect(
    ホスト='ローカルホスト',
    ユーザー='ルート'、
    password='your_password',
    データベース='your_db',
    cursorclass=pymysql.cursors.DictCursor
)

コン付き:
    with conn.cursor() as cursor:
        sql = "your_table LIMIT 1 から created_at を選択します"
        カーソル.実行(SQL)
        result = cursor.fetchone()

        dt_from_sql = result['created_at'] # 日時型
        now = datetime.datetime.now()

        # Calculate time difference
        diff = 今 - dt_from_sql
        print(f"日数の差: {diff.days}")

時間を含めずに日付のみを比較する場合

diff = now.date() - dt_from_sql.date()
print(f"純粋な日付の差日数: {diff.days}")

サンプルプログラム - 現在時刻との時差

インポートpymysql
インポート日時

# データベース接続を確立する
conn = pymysql.connect(
    ホスト='ローカルホスト',
    ユーザー='ルート'、
    パスワード='your_password',
    データベース='your_db',
    カーソルクラス=pymysql.cursors.DictCursor
)

コン付き:
    conn.cursor() をカーソルとして使用:
        sql = "your_table LIMIT 1 から created_at を選択します"
        カーソル.実行(SQL)
        結果 = カーソル.fetchone()

        dt_from_sql = result['created_at'] # 日時型
        now = datetime.datetime.now()

        # 時差を計算する
        diff = 今 - dt_from_sql
        時間 = diff.total_秒() / 3600
        print(f"時間の差: {時間}")

時間を切り上げます

print(f"その差は整数の時間数です: {int(hours)}")

---

---

データベースの強制更新

原理

MySQL のデフォルトのストレージ エンジンである InnoDB では、デフォルトの分離レベルは次のとおりです。REPEATABLE READ(繰り返し読み取り)。

これは、同じトランザクション (トランザクション) で最初のクエリを実行した後、MySQL がトランザクションの「スナップショット」を作成することを意味します。データベース内のデータが 1 秒後に他のプログラムによって変更された場合でも、トランザクションが終了していない限り、2 回目のクエリでは最初と同じスナップショット データが表示されます。これは「繰り返し読み」の一貫性を確保するためです。

最新のデータを強制的に使用するにはどうすればよいですか?

方法 1: トランザクションを手動でコミットする (最も推奨される)

これは最も標準的なアプローチです。 2 番目のクエリを実行する前に、connection.commit()。送信すると現在のトランザクションが終了し、MySQL は次のクエリ中に新しいスナップショットを作成し、最新のデータを読み取ります。

# 最初のクエリ
カーソル.実行(SQL)
result1 = カーソル.fetchall()

# 強制更新: 現在のトランザクションをコミットします
接続.commit()

# 2 番目のクエリは最新の情報を取得します。
カーソル.実行(SQL)
result2 = カーソル.fetchall()

方法 2: 自動送信モード (自動コミット) をオンにする

すべての SQL コマンドをすぐに有効にして最新の結果を確認したい場合は、接続の確立後に自動送信をオンにできます。だからみんなexecute()独立した事項として扱われます。

connection.autocommit = True
# 後続のすべてのexecute(sql)はデータベースの最新ステータスを直接読み取ります。

方法 3: 分離レベルを調整する

分離レベルを次のように変更できます。READ COMMITTED(コミット内容を読み取ります)。このレベルでは、同じトランザクション内でクエリが実行されるたびに、最後に送信されたデータが読み取られます。

# クエリ実行前に設定
Cursor.execute("SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED")

よくある誤解: カーソルをチェックするだけではない

• カーソルと接続: キャッシュは通常、次の場所で発生します。connection(有線) トランザクション スコープではなく、cursorオブジェクトそのもの。カーソルを再作成しても同じ接続を使用し、コミットしない場合、問題は依然として残ります。
• クエリキャッシュ注: サーバー側のクエリ キャッシュ機能は MySQL 8.0 以降削除されているため、最新の環境は一般に SQL キャッシュとは無関係です。

---

---

マルチスレッドデータベース接続

なぜ複数のスレッドを独立して配線する必要があるのでしょうか?

Python のマルチスレッド環境では、複数のスレッドが同じデータベース接続を共有すると、重大な競合が発生します。これは、接続されたオブジェクトは通常、スレッドセーフではないためです。複数のスレッドが同時に SQL コマンドを送信したり、結果を読み取ったりすると、データの混乱、トランザクション例外、または接続の中断が発生します。したがって、接続プールを使用して独立した接続を各スレッドに割り当てることがベスト プラクティスです。

1. MySQL Connectorの接続プールを使用する

mysql-connector-python簡易コネクションプール機能を内蔵。事前にプールを作成しておき、スレッドが必要なときにそこから接続を「借りる」ことができます。

インポートスレッド
mysql.connectorをインポートする
mysql.connector インポート プーリングから

# 1. 接続プール(グローバル変数)を作成する
db_config = {
    "ホスト": "ローカルホスト",
    "ユーザー": "ルート",
    "パスワード": "パスワード",
    "データベース": "テストデータベース"
}

connection_pool = mysql.connector.pooling.MySQLConnectionPool(
    プール名 = "私のプール",
    pool_size=5, # プール サイズを設定します。これはスレッド数以上である必要があります。
    **db_config
)

# 2. スレッドタスク関数の実行
def thread_task(task_id):
    conn=なし
    試してみてください:
        # プールから独立した接続を取得します
        conn = connection_pool.get_connection()
        カーソル = conn.cursor()
        
        # 操作を実行する
        Cursor.execute("SELECT NOW()")
        結果 = カーソル.fetchone()
        print(f"実行スレッド {task_id} の読み取り時間: {result}")
        
        # 注: この分離レベルでは、変更がある場合は忘れずにコミットしてください。
        # conn.commit()

    e としての例外を除く:
        print(f"スレッド {task_id} でエラーが発生しました: {e}")
    最後に:
        # 重要: カーソルと接続を閉じます (ここで閉じると、実際に接続を中断するのではなく、接続がプールに戻ります)。
        conn と conn.is_connected() の場合:
            カーソル.クローズ()
            conn.close()

# 3. 複数の実行スレッドを開始する
スレッド = []
range(3) の i の場合:
    t = threading.Thread(target=thread_task, args=(i,))
    スレッド.append(t)
    t.start()

スレッド内の t の場合:
    t.join()

2. SQLAlchemy の接続プールを使用する (業界で一般的に使用されている)

大規模なアプリケーションを開発している場合、SQLAlchemy はより強力で自動化された接続管理 (QueuePool) を提供します。接続障害、リサイクル、スレッド割り当てを自動的に処理します。

sqlalchemyインポートcreate_engineから
sqlalchemy.orm からセッションメーカーをインポート

# 接続プールはエンジンの作成時に自動的に有効になります
エンジン = create_engine(
    "mysql+mysqlconnector://root:password@localhost/test_db",
    プールサイズ=10、
    max_overflow=20
)

# sessionmaker を使用して、各スレッドが独立したセッションを確実に取得できるようにする
セッション = セッションメーカー(バインド = エンジン)

def sqlalchemy_task():
    セッション = セッション()
    試してみてください:
        # 操作を実行する
        # session.execute(...)
        session.commit()
    最後に：
        session.close() # 接続を返します

実装に関する考慮事項

• pool_size: 接続プールのサイズは、実行スレッドの同時実行性に応じて調整する必要があります。スレッドの数が接続よりも多い場合、後続のスレッドは待機状態になります。
• コンテキスト マネージャー: 可能な限り使用することをお勧めしますwith例外が発生した場合でも接続を確実に返すことができるように、カーソルと接続を管理するための構文。
• トランザクションの整合性: 各スレッドは作業が完了する前に明示的に実行される必要があります。commit()またはrollback()そうでない場合、接続はプールに戻されたときに未完了のトランザクション状態になり、次のユーザーに影響を与える可能性があります。

---

---

Python呼び出しストアドプロシージャ

MySQL を使用する

Python で MySQL ストアド プロシージャを実行するには、次を使用できます。mysql-connector-pythonまたはPyMySQL。

取り付けキット

pip install mysql-connector-python

例: ストアド プロシージャを実行する

mysql.connectorをインポートする

# データベースに接続する
conn = mysql.connector.connect(
    ホスト = "ローカルホスト",
    ユーザー = "あなたのユーザー"、
    パスワード="あなたのパスワード",
    データベース = "あなたのデータベース"
)
カーソル = conn.cursor()

# ストアド プロシージャを呼び出す
Cursor.callproc("your_stored_procedure", (param1, param2))

# 結果を取得する
結果の場合はcursor.stored_results():
    print(result.fetchall())

# 接続を閉じる
カーソル.クローズ()
conn.close()

SQLサーバーの使用

Python で SQL Server ストアド プロシージャを実行するには、次を使用できます。pyodbc。

取り付けキット

pip install pyodbc

例: ストアド プロシージャを実行する

pyodbcをインポートする

# SQL Server に接続する
conn = pyodbc.connect("DRIVER={SQL Server};"
                      "SERVER=あなたのサーバー;"
                      "DATABASE=あなたのデータベース;"
                      "UID=あなたのユーザー;"
                      "PWD=あなたのパスワード")
カーソル = conn.cursor()

# ストアドプロシージャを実行する
Cursor.execute("{CALL your_stored_procedure (?, ?)}", (param1, param2))

# 結果を取得する
行 = カーソル.fetchall()
行内の行の場合:
    印刷(行)

# 接続を閉じる
カーソル.クローズ()
conn.close()

PostgreSQLの使用

Python で PostgreSQL ストアド プロシージャを実行するには、次を使用できます。psycopg2。

取り付けキット

pip install psycopg2

例: ストアド プロシージャを実行する

psycopg2 をインポート

# PostgreSQLに接続する
conn = psycopg2.connect(
    dbname="あなたのデータベース",
    ユーザー = "あなたのユーザー"、
    パスワード="あなたのパスワード",
    ホスト = "ローカルホスト",
    ポート="5432"
)
カーソル = conn.cursor()

# ストアドプロシージャを実行する
Cursor.callproc("your_stored_procedure", (param1, param2))

# 結果を取得する
行 = カーソル.fetchall()
行内の行の場合:
    印刷(行)

# 接続を閉じる
カーソル.クローズ()
conn.close()

注意事項

• ストアド プロシージャ名が正しいことを確認し、必要に応じて適切なパラメータを渡します。
• ストアド プロシージャに戻り値がある場合は、次を使用してください。fetchall()またはstored_results()結果を得るために。
• データベースが異なると呼び出し構文が若干異なる場合があります。使用するデータベースに応じて調整してください。

---

---

Pythonネットワーク

HTTP リクエスト スイートのリクエスト

説明する

requestsこれは、Python で最も一般的に使用される HTTP リクエスト スイートであり、REST API へのアクセス、Web ページのダウンロード、フォーム データの送信などに使用されます。組み込みのものよりも優れています。urllibより簡潔で使いやすくなりました。

設置方法

pip install requests

基本的な使い方

インポートリクエスト

#GETリクエストを送信する
URL = "https://api.pionex.com/api/v1/common/symbols"
応答 = リクエスト.get(url)

# 成功したかどうかを確認する
response.status_code == 200の場合:
    データ = 応答.json()
    print("リクエストは成功しました。フィールドが返されます:", list(data.keys()))
それ以外の場合:
    print("リクエストが失敗しました:", response.status_code)

POSTリクエストの例

import requests

url = "https://httpbin.org/post"
payload = {"key": "value", "symbol": "BTC_USDT"}
headers = {"Content-Type": "application/json"}

res = requests.post(url, json=payload, headers=headers)
print(res.json())

一般的な方法

方法	使用
requests.get()	情報の取得 (最も一般的に使用される)
requests.post()	情報またはフォームを送信する
requests.put()	アップデート情報
requests.delete()	データの削除
response.status_code	HTTPステータスコード
response.json()	JSON 応答を解析する
response.text	オリジナルのテキストコンテンツを取得する
response.raise_for_status()	HTTP エラー例外を自動的にスローする

エラー処理例

インポートリクエスト

試してみてください:
    r = request.get("https://api.pionex.com/api/v1/unknown")
    r.raise_for_status()
e としてのrequests.Exceptions.HTTPErrorを除く：
    print("HTTP エラー:", e)
eとしてのrequests.Exceptions.RequestExceptionを除く：
    print("一般的なリクエスト エラー:", e)

補充する

• REST API、自動クローラ、Webhook 呼び出しなどに使用できます。
• JSON、フォーム、ファイルアップロード、その他の形式をサポートします。
• そしてpandasまたはasyncio大量のデータを取得するために使用できます。

---

---

HTTPステータスコードを確認する

説明する

raise_for_status()はいrequestsモジュール内ResponseHTTP レスポンスのステータス コードがエラー (4xx または 5xx など) であるかどうかを確認するために使用されるオブジェクトのメソッド。

ステータス コードがリクエストが失敗したことを示している場合、自動的にスローされます。requests.exceptions.HTTPError例外は、デバッグや実行の停止を容易にするために使用されます。

例

インポートリクエスト

URL = "https://api.pionex.com/api/v1/common/symbols"
応答 = リクエスト.get(url)

# HTTPステータスコードが成功したかを確認(200~299)
応答.raise_for_status()

# 成功すると、JSON を安全に解析できます
データ = 応答.json()
print("リクエストは成功しました。取得された取引ペアの数:", len(data.get("data", [])))

実行結果

リクエストは成功し、取得した取引ペアの数: 248

エラー処理例

インポートリクエスト

試してみてください:
    r = request.get("https://api.pionex.com/api/v1/invalid_endpoint")
    r.raise_for_status()
e としてのrequests.Exceptions.HTTPErrorを除く:
    print("HTTP エラー:", e)
eとしてのrequests.Exceptions.RequestExceptionを除く：
    print("リクエスト例外:", e)

補充する

• 成功ステータス（200～299）ではエラーはスローされません。
• API が 404 や 500 などのエラー ステータスに応答すると、自動的にスローされます。HTTPError。
• これは、REST API プログラムを作成するときに非常に便利なセキュリティ チェック メカニズムです。

---

---

Python Web API

リクエストモジュールを使用してAPIを呼び出す

Python の「requests」モジュールは、Web API を呼び出すための一般的なツールであり、シンプルで使いやすいです。基本的な例を次に示します。

インポートリクエスト

# APIを呼び出す
URL = "https://api.example.com/data"
応答 = リクエスト.get(url)

# 応答が成功したことを確認する
response.status_code == 200の場合:
    print("データ取得成功")
それ以外の場合:
    print(f"エラー: {response.status_code}")

JSON 応答を解析する

「requests」モジュールに付属する「.json()」メソッドを使用すると、JSON 形式の応答を Python データ構造 (辞書またはリスト) に簡単に変換できます。

# JSON 応答を解析する
データ = 応答.json()

#JSON データにアクセスする
print(data["key1"])
print(データ["キー2"]["サブキー"])

例: 呼び出しと解析

API を呼び出して JSON 応答を解析する方法を示す完全な例を次に示します。

インポートリクエスト

# API URL
URL = "https://jsonplaceholder.typicode.com/posts"

# リクエストの送信
応答 = リクエスト.get(url)

# 応答ステータスを確認して解析する
response.status_code == 200の場合:
    データ = 応答.json()
    # 各記事のタイトルを列挙します
    データの投稿の場合:
        print(f"投稿ID: {post['id']}, タイトル: {post['title']}")
それ以外の場合:
    print(f"API 呼び出しが失敗しました。ステータス コード: {response.status_code}")

JSON例外の処理

JSON 応答を解析するときに例外が発生する場合がありますが、これは「try-Except」を使用して処理できます。

試してみてください:
    データ = 応答.json()
    印刷(データ)
ValueError を除く:
    print("応答は有効な JSON 形式ではありません")

注意事項

1. **API ドキュメントを確認してください**: API によってリクエスト パラメーターと応答形式が異なる場合があります。API ドキュメントをよくお読みください。 2. **エラー応答の処理**: HTTP ステータス コードを必ず確認し、200 以外の応答を処理してください。 3. **セキュリティ**: API キーや機密データを提供する必要がある場合は、プログラムに直接ハードコーディングしないでください。 Instead, use environment variables or secure configuration files.

要約する

Python の「requests」モジュールを使用すると、Web API の呼び出しと JSON 応答の解析が簡単になります。応答とエラーを適切に処理すると、プログラムの安定性と信頼性が向上します。

---

---

JSON cache

説明する

Python が提供するjsonデータをJSON形式に変換(シリアル化)するモジュール、 また、ファイルとして保存 (ダンプ) したり、再ロード (ロード) してキャッシュ効果を得ることができます。

よく使われる機能

• json.dump(obj, file): Python オブジェクトをファイル (JSON 形式) に書き込みます。
• json.dumps(obj): オブジェクトを JSON 文字列に変換します。
• json.load(file): ファイルから JSON を読み取り、Python オブジェクトに変換し直します。
• json.loads(str): JSON 文字列を Python オブジェクトに変換します。

例: データをファイルにキャッシュしてから読み取る

jsonをインポートする
OSをインポートする

キャッシュファイル = "データキャッシュ.json"

# シミュレーションデータソース
データ = {
    "名前": "アリス",
    「年齢」：30歳、
    「趣味」: [「読書」、「音楽」、「コーディング」]
}

#JSON ファイルへのデータの書き込み (ダンプ)
open(cache_file, "w", encoding="utf-8") を f として使用:
    json.dump(data, f, ensure_ascii=False, indent=2)

print("データはファイルにキャッシュされました。")

# ファイルからJSONデータを読み取る(ロード)
os.path.exists(cache_file)の場合:
    open(cache_file, "r", encoding="utf-8") を f として使用:
        ロードされたデータ = json.load(f)
    print("ロードされたデータ:",loaded_data)

出力結果

データはファイルにキャッシュされました。
ロードされたデータ: {'名前': 'アリス', '年齢': 30, '趣味': ['読書', '音楽', 'コーディング']}

説明する

• ensure_ascii=False: 中国語の文字が Unicode エンコードに変換されていないことを確認してください。
• indent=2: JSON ファイルをインデントして読みやすくします。
• json.load()JSON を dict、list、int、str などの対応する型に自動的に復元します。

例: JSONを使用した計算結果のキャッシュ

json、osをインポート

CACHE_PATH = "result_cache.json"

デフォルトの高価な計算():
    print("複雑な操作を実行しています...")
    return [range(5) の x には x**2]

def get_cached_result():
    #キャッシュが存在する場合はロードします
    os.path.exists(CACHE_PATH)の場合:
        open(CACHE_PATH, "r") を f として使用:
            json.load(f)を返す
    # それ以外の場合は、計算後にキャッシュに書き込みます
    結果 = 高価な計算()
    open(CACHE_PATH, "w") を f として使用:
        json.dump(結果, f)
    結果を返す

データ = get_cached_result()
print("データの取得:", data)

出力結果（初回実行）

複雑な操作を実行しています...
データを取得: [0、1、4、9、16]

出力結果（2回目実行）

データを取得: [0、1、4、9、16]

要約する

• json.dump():JSONファイルに書き込みます。
• json.load(): JSON ファイルから読み取ります。
• 計算結果をキャッシュし、繰り返しの操作を減らすために使用できます。
• 必要に応じて迅速な検査が可能ですdumps()そしてloads()文字列を処理します。

---

---

標準的な JSON 構造の推奨事項

1. 推奨構造：リストストレージ

これは、一連のレコードを同じ形式で保存する最も標準的で一般的な方法です。すべてのデータポイントをリストとして扱います (JSON の対応する角括弧)[]） 要素。

[
    {"time": 1759028400000, "open": "109398.3", "close": "109364.8", "high": "109489.2", "low": "109364.8", "volume": "518.7594"},
    {"time": 1759024800000, "open": "109305.6", "close": "109398.3", "high": "109496.4", "low": "109296.0", "volume": "757.0290"},
    ...
]

Pythonの実装

Python では、辞書のリストを作成してから使用するだけです。json.dumps()シリアル化を実行します。

import json

data_list = [
    {'time': 1759028400000, 'open': '109398.3', 'close': '109364.8', 'high': '109489.2', 'low': '109364.8', 'volume': '518.7594'},
    {'time': 1759024800000, 'open': '109305.6', 'close': '109398.3', 'high': '109496.4', 'low': '109296.0', 'volume': '757.0290'}
]

json_output = json.dumps(data_list, indent=4)
# print(json_output)

2. 代替構造: タイムスタンプをキーとする辞書

各データポイントのtime値は一意であり、それを最上位オブジェクトのキーとして使用して辞書構造を作成できます。この構造により、タイムスタンプによる特定のデータの直接クエリが容易になります。

{
    "1759028400000": {"open": "109398.3", "close": "109364.8", "high": "109489.2", "low": "109364.8", "volume": "518.7594"},
    "1759024800000": {"open": "109305.6", "close": "109398.3", "high": "109496.4", "low": "109296.0", "volume": "757.0290"},
    ...
}

Pythonの実装

データ リストを繰り返し処理し、各データ ポイントのデータを変換する必要があります。timeその値を辞書キーとして取り出します。

jsonをインポートする

ソースデータ = [
    {'時間': 1759028400000, '開値': '109398.3', '終値': '109364.8', '高値': '109489.2', '安値': '109364.8', '音量': '518.7594'},
    {'時間': 1759024800000、'開値': '109305.6'、'終値': '109398.3'、'高値': '109496.4'、'安値': '109296.0'、'音量': '757.0290'}
】

data_dict = {}
source_data の項目の場合:
    # JSON キーは文字列である必要があるため、タイムスタンプが文字列であることを確認してください
    time_key = str(アイテム['時間'])
    
    # 新しい辞書をコピーまたは作成し、キーとなっている「time」フィールドを削除します
    value_data = item.copy()
    del value_data['時間']
    
    data_dict[time_key] = value_data

json_output = json.dumps(data_dict, indent=4)
# print(json_output)

---

---

データベースデータをJSONリストに変換する

Python では、組み込みのjsonモジュールは、リストや辞書などの Python データ構造を JSON 形式にシリアル化するための最良の方法です。ターゲット構造は、Python では辞書を含むリストに対応します。

1. データベースのクエリ結果

データベース クエリから取得したデータがすでにリストであり、その各要素が辞書であり、キー名が必要な JSON フィールド名と一致していると仮定します。

db_data = [
    {'時間': 1759028400000, '開値': '109398.3', '終値': '109364.8', '高値': '109489.2', '安値': '109364.8', '音量': '518.7594'},
    {'時間': 1759024800000, '開値': '109305.6', '終値': '109398.3', '高値': '109496.4', '安値': '109296.0', '音量': '757.0290'},
    # ... さらに多くのデータ
]

2. 変換手順: を使用します。json.dumps()

インポートするだけですjsonモジュールと使用方法json.dumps()この関数は、Python リスト オブジェクトを JSON 形式の文字列に変換します。

jsonをインポートする

# db_data の準備ができていると仮定します

# json.dumps() を使用して Python リストを JSON 文字列にシリアル化します
# indent=4 は出力を美しくし、読みやすくするために使用されます。
json_output_string = json.dumps(db_data, indent=4)

print(json_output_string)

3. 出力結果（JSON形式の文字列）

これにより、目的に一致する JSON 文字列が生成されます。

[
    {
        "time": 1759028400000,
        "open": "109398.3",
        "close": "109364.8",
        "high": "109489.2",
        "low": "109364.8",
        "volume": "518.7594"
    },
    {
        "time": 1759024800000,
        "open": "109305.6",
        "close": "109398.3",
        "high": "109496.4",
        "low": "109296.0",
        "volume": "757.0290"
    }
]

4. 元のデータベースのクエリ結果からリストまでの共通処理

データベースドライバーがタプルのリストを返す場合 (例:[(1759028400000, '109398.3', ...), ...])、上記のシリアル化を実行する前に、辞書リストに変換する必要があります。

# フィールド名が次のようになっていると仮定します
field_names = ['時間'、'開'、'閉'、'高'、'低'、'音量']
タプルデータ = [
    (1759028400000、'109398.3'、'109364.8'、'109489.2'、'109364.8'、'518.7594')、
    #...
】

# リストの内包表記
list_of_dicts = [
    dict(zip(フィールド名, 行))
    tuple_data の行の場合
】

# list_of_dicts を直列化するために json.dumps() に直接渡すことができるようになりました。

---

---

Python Web APIのJSON出力

Python では、Web API を実装して JSON を出力する方法は、使用するフレームワークによって異なります。最も直接的には PHP に対応しますecho json_encode()ロジックはPythonを使用して組み込まれていますjsonモジュールですが、Web 環境では、ヘッダーは通常、フレームワークによって提供されるツールを通じて自動的に処理されます。

1. FastAPI を使用する (現在最も推奨されている)

FastAPI は最新の Python 開発の最初の選択肢であり、Python のdict(辞書) またはlist(リスト) を JSON に変換し、正しく設定しますContent-Type。

fastapi から FastAPI をインポート

app = FastAPI()

@app.get("/api/stocks")
def get_stocks():
    # Python 辞書を直接返すと、FastAPI が自動的に json_encode を処理します
    データ = ["AAPL"、"TSLA"、"NVDA"、"GOOGL"]
    return {"株式": データ}

2. Flask を使用します (最も古典的な)

Flaskでは公式に提供されていますjsonifyこの関数は、データの変換に加えて、応答ヘッダーを次のように設定するのにも役立ちます。application/json。

FlaskインポートからFlask、jsonify

app = Flask(__name__)

@app.route('/api/stocks')
def get_stocks():
    データ = ["AAPL"、"TSLA"、"NVDA"、"GOOGL"]
    # PHP の echo json_encode($data) に相当し、ヘッダーを追加します
    jsonify(データ)を返す

3. Django Ninja / REST フレームワークの使用

大きなフレームワーク Django を使用している場合、通常は次を使用します。JsonResponse物体。

from django.http import JsonResponse

def stock_api(request):
    data = {"stocks": ["AAPL", "TSLA"]}
    return JsonResponse(data)

4. ネイティブ Python (非 Web 環境)

JSON 文字列を単に取得したいだけの場合 (ファイルへの書き込みやカスタム出力など)、次のように使用できます。json.dumps()。

jsonをインポートする

データ = {"名前": "ジェミニ", "年齢": 18}
# これは PHP の低レベル実装に最も近い json_encode()
json_string = json.dumps(データ)
print(json_string)

対応比較表

関数	PHP (Vanilla)	Python (FastAPI / Flask)
JSONヘッダーを設定する	header('Content-Type: application/json')	フレーム自動処理（使用return dictまたはjsonify)
オブジェクトからJSON文字列へ	json_encode($data)	json.dumps(data)
出力して終了	echo ...; exit;	return ...

開発提案

• オートメーション：Python フレームワークはネイティブ PHP よりも賢いことが多く、必要なのはreturn辞書を使用すると、すべての形式変換が処理されます。
• 有効性:高パフォーマンスの API を構築している場合は、次のオプションを選択することをお勧めします。FastAPI、非同期 (async/await) に基づいており、Node.js とほぼ同じくらい高速です。

---

---

Google API

核となる動作メカニズム

Google APIは主にGoogle Cloud Platform（GCP）を通じて提供されるサービスで、開発者はGoogleのさまざまな機能（検索、地図、クラウドドライブなど）にアクセスできるようになります。ほとんどの Google API は RESTful アーキテクチャに従い、データ交換に JSON 形式を使用します。

1. アクセス権制御（認証）

Google API を使用する前に、まず Google Cloud Console でプロジェクトを作成し、認証方法を設定する必要があります。大きく分けて以下の2種類に分かれます。

• API Key: 公開データ (YouTube 公開ビデオ情報、Google マップなど) へのアクセスに適しています。セキュリティ レベルは低く、ソースのみを制限します。
• OAuth 2.0: ユーザーのプライベート データへのアクセス (ユーザーの Gmail の読み取り、クラウド ドライブ ファイルの変更など) に適しています。ユーザーの承認が必要です。
• サービスアカウント: サーバー間通信に適しており、認可のために手動介入は必要ありません。

2. よく使用されるライブラリとツール

Python では、開発を簡素化するために次のライブラリが公式に推奨されています。

• google-api-python-client: ほとんどの Discovery サービス用のユニバーサル API クライアント。
• google-auth: 認証とトークン管理を特別に処理します。
• google-cloud-storage / google-cloud-vision: 特定のクラウド サービス向けに最適化されたクライアント ライブラリ。

3. プロセスステップを使用する

1. APIを有効にする: GCP Console の「API とサービス」ライブラリで必要なサービス (YouTube Data API v3 など) を検索して開始します。
2. 認証情報の作成：秘密キー（サービスアカウント）をJSON形式でダウンロードするか、APIキーを取得します。
3. SDKのインストール：使用pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib。
4. コードを書く: Service オブジェクトを初期化して呼び出しますexecute()。

4. 重要な制限と割り当て (クォータ)

Google API は完全に無料でも無制限でもありません。各 API には独自のクォータ請求方法があります。

• 単位: たとえば、YouTube API には 1 日あたり 10,000 ポイントの基本割り当てがあり、単純な読み取りで 1 ポイントが消費され、ビデオのアップロードでは 1,600 ポイントが消費される場合があります。
• レート制限: 1 秒あたりまたは 1 分あたりのリクエストの数を制限します。これを超えると、429 Too Many Requests エラーが返されます。

5. 共通APIカテゴリー表

カテゴリ	代表的なAPI	主な目的
作業の自動化	Google Sheets / Calendar / Gmail	フォーム、スケジュール、電子メールの送信を自動化します。
データとストレージ	Cloud Storage / BigQuery	大きなファイルを保存し、ビッグデータ分析を実行します。
AI	Vision / Translation / Natural Language	画像認識、テキスト翻訳、感情分析。
マルチメディア	YouTube Data API	動画を検索し、チャンネル コンテンツを管理します。

---

---

Google API Service

コアコンセプト

通常は Python で Google API (YouTube、Drive、Gmail など) を使用します。google-api-python-client図書館でbuildService オブジェクトを作成する関数。このオブジェクトはすべての API メソッドをカプセル化し、Google サーバーとの主要な通信チャネルとなります。

1. 基本的な初期化方法

Service オブジェクトを作成するには、API 名、バージョン、認証キー (API キー) または資格情報 (OAuth2) が必要です。

googleapiclient.discovery インポート ビルドから

# YouTube Data API v3 を初期化する
youtube = ビルド(
    「ユーチューブ」、
    'v3'、
    開発者Key='YOUR_API_KEY'
)

# API呼び出しの例
request = youtube.videos().list(part="スニペット", id="dQw4w9WgXcQ")
応答 = request.execute()

2. ハンドルスレッドセーフティ（Thread Safety）

これが、以前にクラッシュを経験した主な理由です。build()生成された Service オブジェクトとその内部httpトランスポート層オブジェクトスレッドセーフではありませんの。マルチスレッド環境では、次のガイドラインに従ってください。

• 世界中で共有しないでください: 複数の実行スレッドが同じものを呼び出すことを防止します。youtube.execute()。
• 遅延初期化: 各スレッドでrun()メソッドで実行されるbuild()。
• 限定されたサービスを使用する: 各実行スレッドに独立したスレッドがあることを確認します。googleapiclient.discovery.Resource例。

3. 接続パフォーマンスの最適化

頻繁に電話するbuild()「Discovery Document」のダウンロードを繰り返すと、パフォーマンスが低下します (約 1 ～ 2 秒の追加遅延)。次の方法で最適化できます。

# 探索ファイルのダウンロードを無効にします (プリコンパイルされたライブラリをインストールしている場合、または処理を高速化したい場合)
# 注: これには、環境内に関連する定義がすでに存在している必要があります。
youtube = build('youtube', 'v3',developerKey='KEY', static_discovery=True)

4. エラー処理とクォータ管理

Service メソッドを呼び出すときに発生する最も一般的なエラーは次のとおりです。HttpError。クォータの枯渇や権限の問題を処理するには、これをキャッチする必要があります。

googleapiclient.errors から HttpError をインポート

試してみてください:
    応答 = youtube.channels().list(part="統計", Mine=True).execute()
HttpError を除く e:
    e.resp.status == 403の場合:
        print("API クォータが枯渇したか、権限が不十分です")
    elif e.resp.status == 401:
        print("認証が無効です")
    それ以外の場合:
        print(f"HTTP エラー: {e}")

5. 共通サービス一覧

API関数	名前パラメータ	バージョンパラメータ
YouTube Data	'youtube'	'v3'
Google Drive	'drive'	'v3'
Google Sheets	'sheets'	'v4'
Gmail API	'gmail'	'v1'

---

---

マルチスレッドでの YouTube API

試してみてください...捕まえられないこと以外は？

同じ Google API サービス オブジェクトを複数のスレッド間で共有する場合 (例:YoutubeApi.youtube)、スレッド セーフティの問題が発生する可能性があります。底httplib2またはurllib3複数のスレッドが同じ接続オブジェクトに同時にアクセスすると、トランスポート層は競合状態 (Race Condition) を生成し、プログラムが基盤となるネットワーク層で直接クラッシュします。場合によっては、C 言語レベルでエラーが発生し、Python インタープリターが直接終了することもあります。これが理由ですtry...except傍受できない理由。

解決策 1: 実行スレッドごとに個別の Service オブジェクトを作成する (最も推奨される)

メインスレッドでグローバル ドメインを作成しないでくださいyoutubeオブジェクトは誰でも利用できます。各スレッドは、開始時に独自の API サービス インスタンスを作成する必要があります。このようにして、各スレッドは、相互に干渉することなく、独自のネットワーク接続とキャッシュを持ちます。

インポートスレッド
googleapiclient.discovery インポート ビルドから

def get_youtube_service():
    # 各スレッドの内部でこの関数を呼び出して独立したオブジェクトを作成します
    return build('youtube', 'v3',DeveloperKey='YOUR_API_KEY')

def thread_task(video_id):
    試してみてください:
        # 実行スレッド内に専用サービスを作成する
        local_youtube = get_youtube_service()
        request = local_youtube.videos().list(
            part="スニペット、統計",
            id=ビデオID
        )
        応答 = request.execute()
        print(f"正常に取得されました: {video_id}")
    e としての例外を除く:
        print(f"スレッド エラー: {e}")

# 複数のスレッドを開始する
t1 = threading.Thread(target=thread_task, args=("vid1",))
t2 = threading.Thread(target=thread_task, args=("vid2",))
t1.start()
t2.start()

解決策 2: ネジロック (ロック) を使用する

オブジェクトを繰り返し作成したくない場合は、次のように使用できます。threading.Lock同時に実行できるスレッドは 1 つだけであることを確認するexecute()。これにより、API 呼び出しがキューに入れられます (同時実行の高速化効果が失われます) が、クラッシュすることはありません。

インポートスレッド

# グローバルロックを作成する
api_lock = threading.Lock()

def thread_task_with_lock(video_id):
    # とともに使用すると、ロックが自動的に解放されます。
    api_lock を使用する場合:
        試してみてください:
            リクエスト = YoutubeApi.youtube.videos().list(
                部分 = "スニペット"、
                id=ビデオID
            )
            vlist = request.execute()
        e としての例外を除く:
            print(f"エラー: {e}")

解決策 3: HttpLib2 のスレッド チェックを無効にする (上級)

古いバージョンのクライアント ライブラリを使用している場合は、サービスを構築するときに明示的に指定できます。httpオブジェクトをオブジェクトにして非スレッドセーフにするか、使用しますhttplib2.Http()独立したインスタンス。ただし、これは通常より複雑であるため、オプション 1 を優先することをお勧めします。

要約提案

• オプション 1これはベスト プラクティスです。複数のスレッドの同時実行速度を維持し、リソース共有によるクラッシュを完全に回避できます。
• API クォータを確認する: 複数のスレッドの同時呼び出しは、1 日あたり 10,000 のクォータを急速に消費する可能性があるため、403 エラーを必ず監視してください。
• タイムアウト設定：サービス作成時に追加することを推奨しますsocket.setdefaulttimeout(10)、ネットワークのスタックによって特定の実行スレッドがリソースを永続的に占有することを防ぎます。

---

---

Python メール送信

必要なパッケージをインストールする

pip install smtplib email

これら 2 つのモジュールは通常、Python に組み込まれているため、追加のインストールは必要ありません。

基本的なサンプルコード

smtplib をインポートする
email.mime.text から MIMEText をインポート
email.mime.multipart から MIMEMultipart をインポート

# 送信者、受信者、件名、内容を設定します
送信者 = '[email protected]'
受信者 = '[email protected]'
件名 = 'テストメール'
body = 'これは Python によって送信されたテストメールです。 '

# メールコンテンツを作成する
msg = MIMEMultipart()
msg['From'] = 送信者
msg['To'] = 受信者
msg['件名'] = 件名
msg.attach(MIMEText(body, 'plain'))

#Gmail SMTP を使用して送信する
smtp_server = 'smtp.gmail.com'
smtp_port=587
ユーザー名 = '[email protected]'
password = 'your_app_password' # 一般的なパスワードの代わりにアプリのパスワードを使用することをお勧めします

smtplib.SMTP(smtp_server, smtp_port) をサーバーとして使用:
    サーバー.starttls()
    server.login(ユーザー名、パスワード)
    サーバー.send_message(msg)

print('メールは送信されました')

注意事項

• Gmailに正常にログインするには「アプリケーション固有のパスワード」をオンにする必要があります。
• Outlook、Yahoo などでも SMTP サーバーとポートが提供されています。各社の指示に従って設定する必要があります。
• アカウントのパスワードが漏洩しないように、必ず適切に保管してください。

---

---

Gmail アプリ固有のパスワードを取得する

前提条件

• Google アカウントの 2 段階認証が有効になっています。

手順の説明

1. ブラウザを開いて、次の場所に移動しますGoogleアカウント
2. 左側のメニューの「セキュリティ」をクリックします
3. 「Google でサインイン」セクションを見つけて、「2 段階認証プロセス」が有効になっていることを確認します。
4. 有効にすると、「アプリケーションパスワード」オプションが表示されるので、それをクリックします
5. Google ログイン パスワードを入力して再確認してください
6. 「アプリケーションの選択」で「メール」を選択し、「デバイスの選択」で「その他（カスタム名）」を選択します
7. 「Python Script」などの名前を入力し、「生成」をクリックします。
8. システムにより 16 桁のアプリケーション パスワードが生成されるので、それをコピーします。
9. 元の Gmail パスワードを Python プログラムのこのパスワードに置き換えます

セキュリティに関するアドバイス

• アプリのパスワードを他の人と共有しないでください
• パスワードが漏洩した場合でも、すぐにパスワードを削除して再生成することができます。

---

---

Gmail ルールを設定する

準備

• 有効にする必要がありますGmail API。
• 到着Google Cloud Consoleプロジェクトを作成し、Gmail API を有効にします。
• OAuth 2.0 認証情報 (credentials.json) をダウンロードします。
• 必要なパッケージをインストールします。pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib

Gmail ルールの作成 (フィルター)

フィルタは Gmail API を通じて作成できます。たとえば、送信者が特定のメールボックスである場合、ラベルを自動的に追加します。

googleapiclient.discovery インポート ビルドから
google_auth_oauthlib.flow から InstalledAppFlow をインポート
google.auth.transport.requests からのインポート リクエスト
OSをインポートする
輸入ピクルス

# 必要な認可スコープ
スコープ = ['https://www.googleapis.com/auth/gmail.settings.basic',
          「https://www.googleapis.com/auth/gmail.modify」]

def gmail_service():
    資格情報=なし
    os.path.exists("token.pickle") の場合:
        open("token.pickle", "rb") をトークンとして使用:
            creds = pickle.load(トークン)

    creds または creds.valid でない場合:
        creds と creds.expired および creds.refresh_token の場合:
            creds.refresh(リクエスト())
        それ以外の場合:
            flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
            creds = flow.run_local_server(port=0)

        open("token.pickle", "wb") をトークンとして使用:
            pickle.dump(creds, トークン)

    return build("gmail", "v1", credentials=creds)

# Gmailフィルターを作成する
def create_filter():
    サービス = gmail_service()

    フィルター設定 = {
        「基準」: {
            "from": "[email protected]" # 条件: 送信者
        }、
        「アクション」: {
            "addLabelIds": ["Label_123456"], # Gmail 内部ラベル ID
            "removeLabelIds": ["INBOX"] # オプション: 受信トレイを削除します
        }
    }

    結果 = service.users().settings().filters().create(
        userId="私"、
        body=フィルター構成
    ).execute()

    print("正常に作成されました、フィルター ID:"、result["id"])

__name__ == "__main__"の場合:
    create_filter()

注意事項

• Label_123456Gmail のラベル ID です。次の方法でアクセスできます。users().labels().list()得る。
• 初めて実行するときは、ブラウザがポップアップ表示され、Google アカウントでログインして認証するように求められます。
• ルールが作成されると、[Gmail 設定] → [フィルタとブロックされたアドレス] にルールが表示されます。

---

---

Gmail ルールを適用する

前提条件

• Gmail API が有効になり、OAuth 検証が完了しました。
• 最初にルール (フィルタ) を作成する必要があります。Gmail はそのルールを新しいメールに自動的に適用します。
• 既存のメッセージにルールを適用するには、Gmail API を通じて検索を実行し、ラベルを手動で編集する必要があります。

ルールを自動的に適用する

Gmail API によって作成されたルール (フィルター) は、新しいメールが受信されると自動的にトリガーされ、追加の「実行」は必要ありません。

既存のメッセージにルールを適用する

Gmail API を使用して一致するメッセージを検索し、ラベルを付けるかバッチで移動します。

googleapiclient.discovery インポート ビルドから
google_auth_oauthlib.flow から InstalledAppFlow をインポート
google.auth.transport.requests からのインポート リクエスト
OSをインポートする
輸入ピクルス

スコープ = ['https://www.googleapis.com/auth/gmail.modify']

def gmail_service():
    資格情報=なし
    os.path.exists("token.pickle") の場合:
        open("token.pickle", "rb") をトークンとして使用:
            creds = pickle.load(トークン)

    creds または creds.valid でない場合:
        creds と creds.expired および creds.refresh_token の場合:
            creds.refresh(リクエスト())
        それ以外の場合:
            flow = InstalledAppFlow.from_client_secrets_file("credentials.json", SCOPES)
            creds = flow.run_local_server(port=0)

        open("token.pickle", "wb") をトークンとして使用:
            pickle.dump(creds, トークン)

    return build("gmail", "v1", credentials=creds)

#既存のメールに Gmail ルールを適用する
def run_rule():
    サービス = gmail_service()

    # 検索条件 (from:[email protected] など)
    クエリ = "from:[email protected]"
    結果 = service.users().messages().list(userId="me", q=query).execute()
    メッセージ = results.get("メッセージ", [])

    メッセージでない場合:
        print("条件に一致するメールはありません")
        戻る

    メッセージ内のメッセージの場合:
        service.users().messages().modify(
            userId="私"、
            id=msg["id"],
            本文={
                "addLabelIds": ["Label_123456"], # 新しいラベルを追加します
                "removeLabelIds": ["INBOX"] # 受信トレイを削除します
            }
        ).execute()

    print(f"{len(messages)} 個のメッセージが処理されました")

__name__ == "__main__"の場合:
    run_rule()

注意事項

• Gmail API のフィルターは、新しいメールに対してのみ自動的にトリガーできます。
• 「古いメールにルールを適用したい」場合は自分で探す必要があるq条件とバッチ変更。
• Gmail の検索構文が利用可能です。from:, subject:, has:attachment。

---

---

Python HTTP API サーバー

Python で HTTP API サーバーを構築する最も一般的で推奨される方法は、効率的で機能が豊富な Web フレームワークを使用することです。以下に、主流の 3 つのフレームワークとその特徴を紹介します。

1. FastAPI を使用します (推奨: 高パフォーマンス、最新)

FastAPI は、API を構築するための最新の高速 (Starlette および Pydantic を利用した) Web フレームワークです。非同期操作 (async/await) をネイティブにサポートし、OpenAPI (Swagger UI) ファイルを自動的に生成します。

特徴

• 非常に高速で、Go に匹敵するパフォーマンスを備えています。
• Python の型ヒントに基づいたデータの検証とシリアル化。
• API ドキュメント (Swagger UI / ReDoc) を自動的に生成します。

基本的な例

# インストール: pip install fastapi uvicorn
fastapi から FastAPI をインポート

app = FastAPI()

# ルートルートの定義(GETリクエスト)
@app.get("/")
def read_root():
    return {"こんにちは": "世界"}

# パラメーターを使用してルートを定義する
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# 実行サーバー (ファイル名が main.py であると仮定します)
# ターミナルで実行: uvicorn main:app --reload

2. Flaskを使用する（軽量で柔軟性が高い）

Flask は、コアをシンプルに保ち、開発者がデータベースや検証ライブラリなどのコンポーネントを自由に選択できるマイクロフレームワークです。小規模なプロジェクトや、高度なカスタマイズが必要なアプリケーションに適しています。

特徴

• 習得が簡単で、初期費用が低い。
• 内蔵コンポーネントが非常に少なく、柔軟性が高い。
• 成熟しており、コミュニティからの大きなサポートを受けています。

基本的な例

# インストール: pip install flask
from flask import Flask、jsonify、リクエスト

app = Flask(__name__)

#API ルートを定義する
@app.route("/data",methods=['GET'])
def get_data():
    return jsonify({"メッセージ": "これは Flask API データです"})

#POSTルートを定義する
@app.route("/submit",methods=['POST'])
def post_data():
    データ = request.get_json()
    return jsonify({"受信": データ})、201

#サーバーの実行
# __name__ == '__main__'の場合:
# app.run(debug=True)

3. Django Rest Framework (DRF) を使用する (大規模プロジェクト)

DRF は、完全に機能する Django Web フレームワークに基づいて RESTful API を迅速に構築するための強力なツールです。シリアライザー、モデル ビュー セット、認証、権限制御など、大規模な API に必要なすべての機能を提供します。

特徴

• Django ORM およびデータベース機能との緊密な統合に適しています。
• 強力な自動管理インターフェイスと Web ブラウズ可能な API を提供します。
• エンタープライズレベルのアプリケーション向けの完全な機能を備えています。

注: DRF サンプル コードは長く、最初に Django プロジェクトとアプリケーションを作成する必要があるため、ここでは省略しますが、大規模なプロジェクトの場合はこれが最初の選択肢になります。

要約と提案

• 優れたパフォーマンスと最新の非同期機能を求めていて、プロジェクトの規模が中程度の場合は、**FastAPI** を選択してください。
• 簡単なサービスをすばやく構築する必要がある場合、または Web 開発の基礎を学ぶ必要がある場合は、**Flask** を選択してください。
• API が大規模なアプリケーションの一部であり、複雑な ORM、権限管理などが必要な場合は、**Django + DRF** を使用してください。

---

---

Django

主な特長

• ORM (オブジェクト リレーショナル マッピング): 開発者は、ネイティブ SQL コマンドを作成せずに、Python コードを使用してデータベースを操作できます。
• 管理インターフェイス: データ内容の追加、削除、変更、確認を容易にするために自動的に生成される管理インターフェイス。
• セキュリティ: クロスサイト スクリプティング (XSS)、クロスサイト リクエスト フォージェリ (CSRF)、SQL インジェクションに対する保護機能が組み込まれています。
• 高い拡張性: 疎結合設計を採用しており、小規模プロジェクトから大規模なエンタープライズレベルのアプリケーションまでの拡張に適しています。

MVT アーキテクチャ要素

• モデル: データ構造とデータベース スキーマを定義し、データ層のロジックを担当します。
• ビュー: ビジネス ロジックと HTTP リクエストを処理し、ユーザーにどのデータを送信するかを決定します。
• テンプレート: インターフェイスのレンダリングと、表示用の HTML へのデータの埋め込みを担当します。

システムコアコンポーネント

• URL ディスパッチャー: URL を特定のビュー関数にマップする正規表現ベースのルーティング システム。
• 認証システム: 権限グループやパスワード ハッシュを含む、完全なユーザー認証および認可システム。
• ミドルウェア: リクエストとレスポンスを処理するためのフック システム。ロギング、Gzip 圧縮などに使用できます。
• 移行: モデルの変更を追跡し、データベース構造と同期するデータベース移行システム。
• フォーム: 強力なフォーム処理および検証機能を提供し、HTML フォームとデータ処理の間の対話を簡素化します。

---

---

Django REST

主な特長

• Web ブラウズ可能な API: 組み込みのビジュアル Web インターフェイスにより、開発者はブラウザで API エンドポイントを直接テストできます。
• シリアル化: 複雑なデータ構造 (クエリセットやモデル インスタンスなど) の JSON、XML、またはその他のコンテンツ タイプへの変換をサポートします。
• 認証および許可システム: OAuth1、OAuth2、セッション、トークンなどの複数の組み込み認証スキームが含まれています。
• 高度なカスタマイズ性: ビュー ロジックからシリアル化メソッドに至るまで、拡張のために豊富なフック関数が提供されています。

コアコンポーネント

• シリアライザー: データの双方向変換、データベース モデルから JSON へのシリアル化、およびリクエスト データからモデルへの検証と逆シリアル化を処理します。
• ViewSets: 複数の関連するビューのロジックを 1 つのカテゴリ (リスト、作成、取得、更新、破棄など) にカプセル化します。
• ルーター: ViewSet の URL 構成を自動的に処理し、手動でルートを作成する作業負荷を軽減します。
• APIView: DRF ビューの基本クラス。Django のネイティブ View よりも強力なリクエストと応答の処理メカニズムを提供します。
• 権限: ユーザーが IsAuthenticated や IsAdminUser などの特定のアクションを実行する権限を持っているかどうかを決定します。
• スロットル: API リクエストの頻度を制限して、システムが悪意のある攻撃や過負荷にさらされるのを防ぎます。
• パーサーとレンダラー: 受信リクエストのコンテンツ (JSON やフォーム データなど) を解析し、出力形式を決定します。

先進的な機能

• 汎用ビュー: 標準の CRUD インターフェイスを迅速に構築するために、よく使用される事前定義されたビューを提供します。
• フィルタリングと検索: サードパーティのパッケージまたは組み込みメカニズムを統合して、データのフィルタリング、並べ替え、および全文検索を簡単に実装します。
• ページネーション: 大規模なデータ処理のパフォーマンスを向上させるための複数のページング メソッド (PageNumber、LimitOffset、Cursor など) が組み込まれています。
• バージョニング: バックエンド更新時の下位互換性を確保するために、複数の API バージョン管理戦略をサポートします。

---

---

Django Ninja

主な利点

• 高いパフォーマンス: データの検証とシリアル化のために Pydantic をベースにし、実行速度を徹底的に最適化します。
• 非同期サポート: 非同期/待機操作のネイティブ サポート。これにより、同時実行性の高いシナリオでの処理能力が効果的に向上します。
• 自動ドキュメント: 組み込みの Swagger UI と ReDoc により、ルートとタイプを定義するだけで、インタラクティブな API ドキュメントが自動的に生成されます。
• タイプ セーフティ: Python 3.6 以降のタイプ ヒントを完全に利用して、強力なエディター補完と静的チェックを提供します。
• 統合が簡単: Django ORM および認証システムとシームレスに統合され、RESTful API の迅速な開発に適しています。

コアコンポーネント

• NinjaAPI: フレームワークのコア インスタンス。ルートの登録、ファイル パスの設定、およびグローバル例外処理の管理に使用されます。
• スキーマ: Pydantic によって定義されたデータ構造に基づいて、リクエスト パラメーターの検証と応答データのシリアル化を担当します。
• ルーター: API ロジックをさまざまなモジュールに分割して、大規模なプロジェクトのルーティング構造の管理を容易にするために使用されます。
• ModelSchema: Django モデル専用に設計されたスキーマ。データベース モデルから対応するフィールド定義を自動的に生成できます。
• 認証: APIKey、HttpBasic、HttpBearer、セッション認証などの複数の組み込み認証メカニズムを提供します。
• リクエスト/レスポンスパーサー: JSON、フォームデータ、パスパラメータ、クエリ文字列の解析を自動的に処理します。

特徴

• 依存関係の注入: さまざまな操作でのロジック (データベース接続や構成など) の共有を容易にする、単純な依存関係注入メカニズムを提供します。
• ファイル処理: ファイルのアップロードとダウンロードのプロセスを簡素化し、Django のストレージ システムと統合します。
• エラー処理: カスタム例外ハンドラーがエラー メッセージを標準の JSON 形式に変換し、クライアントに送り返すことができるようにします。
• バージョニング: 同じ Django プロジェクト内で、異なるパス プレフィックスで区切られた複数の API バージョンの実行をサポートします。

---

---

カテゴリでの FastAPI ルーティングの実装

FastAPI への慣用的なアプローチはデコレータを使用することですが、@app.get()関数を直接装飾しますが、大規模なアプリケーション (特に依存関係注入またはルートのモジュール化を使用する場合) をより適切に整理および構造化するために、ルート ハンドラーをクラスにカプセル化できます。これは、「APIRouter」パターンまたは「クラスベース ビュー」と呼ばれることがよくあります。

これには ** を使用する必要がありますfastapi.APIRouter** および **メソッド デコレータ** を使用してこれを実現します。

1. ファイル構造とカテゴリの定義

私たちは使用しますAPIRouterルートを定義し、クラス メソッドをハンドラーとして登録します。

# インストール: pip install fastapi uvicorn
from fastapi import APIRouter、FastAPI、依存
入力から import 注釈付き

# ステップ 1: APIRouter インスタンスを作成する
ルーター = APIRouter(
    prefix="/api/v1", # このルーティング グループのプレフィックスを設定します
    tags=["items"] # ファイルの分類に使用されます
)

# ステップ 2: ルーティング ロジックを含むカテゴリを定義する
クラスItemService:
    """すべてのアイテム関連のビジネス ロジックとルーティング処理を処理します"""
    
    def __init__(self, db_dependency: str):
        # 依存関係の注入をシミュレートする (Dependency Injection)
        self.db_connection = db_dependency

    # @router.get を使用してクラスメソッドを装飾します
    @router.get("/")
    def read_root(self):
        # read_root ロジックを実装する
        return {"メッセージ": "ItemService クラスから Hello World!", "db_status": self.db_connection}

    # read_item ロジックを実装する
    # パラメータ {item_id} は URL パスから取得されます
    @router.get("/{item_id}")
    def read_item(self, item_id: int, q: str | None = None):
        戻り値 {
            "アイテムID": アイテムID、
            「クエリ」: q、
            "ステータス": "処理が完了しました"
        }

#補助機能: 依存性注入のシミュレーション (Dependency)
def get_db():
    # 実際には、データベース接続が返されます。
    「データベースが正常に接続されました」を返します

# ステップ 3: クラス インスタンスのファクトリ関数を作成し、依存関係を注入する
# Annotated[str, depends(get_db)] は、db_connection が get_db によって提供されることを示します
def get_item_service(db_connection: Annotated[str, depends(get_db)]):
    # ItemService のインスタンスを返す
    itemService(db_connection) を返す

# ステップ 4: FastAPI アプリケーション プリンシパルを作成する
app = FastAPI()

# ステップ 5: コア! depends を使用して、ItemService クラスのメソッドをアプリケーションにマウントします。
# ここでの依存は、FastAPI にItemService のインスタンスの取得方法を知らせるために使用されます。
app.include_router(
    ルーター、
    依存関係=[依存(get_item_service)]
)

2. 操作とテスト

上記のコードを次の名前で保存しますmain.pyをクリックして、Uvicorn サーバーを実行します。

uvicorn main:app --reload

• `/api/v1/` にアクセスするとトリガーされますItemService.read_root方法。
• `/api/v1/123?q=test` にアクセスするとトリガーされますItemService.read_item方法。

3. まとめ

このパターンの鍵は次のとおりです。

1. 使用APIRouterルートを定義します。
2. カテゴリメソッドで使用する@router.get/@router.postそして他の装飾者。
3. **依存関係の注入 (依存)** を使用してクラスのインスタンスを取得し、それをクラスに含めますapp.include_routerのdependenciesパラメータ。

この利点は、ビジネス ロジック (ItemService(内部) はルーティング定義から分離されるため、プログラム コードのモジュール化とテスト容易性が向上します。

---

---

Flaskサーバーの停止

1. 開発環境での手動停止 (最も一般的に使用される)

ターミナルで Flask アプリケーションを実行しており、`app.run()` を使用して開始した場合、最も簡単な方法はキーボード割り込み信号を使用することです。

• 使用: Ctrl + C
• アクション: Flask サーバーを実行しているターミナル ウィンドウでこのキーの組み合わせを押します。
• 仕組み: これにより、Python プログラムに SIGINT (割り込み信号) が送信され、サーバーを正常にシャットダウンして終了できるようになります。

2. プログラム中に自動停止（テストまたは特殊シナリオ）

単体テストや、特定の操作を実行した後にサーバーを自動的にシャットダウンする必要があるシナリオでは、コードを通じて停止コマンドを送信する必要があります。

A. werkzeug.serving の Shutdown メソッドを使用します (推奨)

Flask の組み込み開発サーバーは実際に Werkzeug ライブラリを使用します。特定の HTTP リクエストをサーバーに送信して、サーバー自体をシャットダウンさせることができます。これには、アプリケーションで特別なルートを定義する必要があります。

フラスコからのインポート Flask、リクエスト

app = Flask(__name__)

# 秘密のシャットダウンルートを定義する
@app.route('/shutdown',methods=['POST'])
def shutdown_server():
    # 許可されたユーザーのみがこのエンドポイントを呼び出せるようにする
    
    func = request.environ.get('werkzeug.server.shutdown')
    func が None の場合:
        raise RuntimeError('Werkzeug 開発サーバーで実行されていません')
    
    func() # 終了関数を呼び出す
    return 'サーバーがシャットダウンしています...'

# ... 他のルート ...

# 別のプログラムまたはスクリプトで http://127.0.0.1:5000/shutdown に POST リクエストを送信して、サーバーをシャットダウンします。

B. 別のスレッドまたはプロセスで実行する (ノンブロッキング)

デフォルトでは、`app.run()` はブロックされます。サーバーをバックグラウンドで実行したままにして、メイン コードで他のロジックの実行を続行するには、次を使用する必要があります。threadingまたはmultiprocessingモッド。

インポートスレッド
インポート時間
FlaskインポートからFlask

app = Flask(__name__)
# ...あなたのルート ...

def run_server():
    # 注: debug=True は運用環境では使用しないでください
    app.run(ポート=5000)

# 新しいスレッドでサーバーを起動します
スレッド = threading.Thread(target=run_server)
thread.start()

print("Flask サーバーがバックグラウンドで起動されました...")

# サーバーをしばらく実行させます
タイムスリープ(5)

# (プログラムのシャットダウン) このスレッド モードには、組み込みの簡易シャットダウン機能はありません。
# 上記の /shutdown ルートを使用するか、スレッドを直接終了する必要があります (推奨されません。クリーンではない可能性があります)。

# 例: サーバースレッドが終了するまで待ちます (Ctrl+C が停止した後)
# thread.join()

3. 本番環境での停止 (Gunicorn、uWSGI などを使用)

運用環境では、`app.run()` は使用しません。 WSGI サーバー (Gunicorn や uWSGI など) を使用します。これらのサーバーを停止するには:

• 使用法: SIGTERM または SIGKILL シグナルを Gunicorn または uWSGI のメインプログラムに送信します。
• アクション: 通常はオペレーティング システム コマンド (例: 「kill」) を使用します。` または、systemd/supervisor サービス管理を使用して完了します。

---

---

Flask の現在のサーバー環境を確認する

Flask アプリケーションがデフォルトの Werkzeug 開発サーバー (Gunicorn、uWSGI、または他の ASGI サーバーを使用する運用環境など) で実行されていない場合、現在の環境を確認する最も信頼できる方法は、**WSGI/ASGI 環境変数** (つまり、request.environまたはrequest.scope）。

1. 使用するrequest.environ(Gunicorn などの WSGI サーバーに適用されます)

Flask ルート関数では、次のようにアクセスできます。request.environWSGI サーバーによって設定された特定のキーをチェックしてサーバーの種類を判断するディクショナリ。

Pythonの実装例

from flask import Flask、リクエスト、jsonify

app = Flask(__name__)

@app.route('/server_info')
def get_server_info():
    
    # デフォルト: Werkzeug 開発サーバーを想定
    server_name = "Werkzeug (開発サーバー)"
    
    # 共通の WSGI サーバー識別子を確認する
    
    # ガニコーンをチェック
    request.environ に「gunicorn.version」がある場合:
        server_name = f「Gunicorn (バージョン: {request.environ.get('gunicorn.version')})」
    
    # uWSGI を確認する
    request.environ の elif 'uwsgi.version':
        # uWSGI には通常、標準のバージョン キーはありませんが、特定の環境変数があります
        サーバー名 = "uWSGI"
    
    # ウェイトレスのチェック (共通の実稼働 WSGI サーバー)
    request.environ の elif 'waitres.version':
        server_name = f"ウェイトレス (バージョン: {request.environ.get('waitress.version')})"

    # 他の WSGI サーバーの共通識別子を確認する
    request.environ の elif 'SERVER_SOFTWARE':
        # 多くのサーバーはこの標準 WSGI キーを設定します
        サーバー名 = request.environ.get('SERVER_SOFTWARE')
        
    # werkzeug.server.shutdown が存在する場合、それはほぼ確実に Werkzeug です
    request.environ の elif 'werkzeug.server.shutdown':
        server_name = "Werkzeug (開発サーバー、シャットダウン可能)"
        
    return jsonify({
        "現在のサーバー": サーバー名、
        "is_dev_server": (server_name.startswith("Werkzeug"))
    })

# アプリケーションを起動する
# __name__ == '__main__'の場合:
# app.run(debug=True)

2. コア判定ロジック

サーバーのシャットダウン ロジックでは、このチェックを直接使用して、`shutdown_func` を実行するかどうかを決定できます。

Flaskインポートリクエストから、jsonify

@app.route('/shutdown',methods=['POST'])
def shutdown_server():
    shutdown_func = request.environ.get('werkzeug.server.shutdown')

    shutdown_func が None の場合:
        # 非 Werkzeug 環境 (通常は実稼働環境)
        return jsonify({
            "error": "このエンドポイントは開発環境専用です。オペレーティング システムのコマンドを使用してサーバーを停止してください。"
        })、400
    
    #WerkzeugEnvironment
    シャットダウン機能()
    return jsonify({"メッセージ": "サーバーはシャットダウンしています..."}), 200

3. SERVER_SOFTWARE だけを確認できないのはなぜですか?

`SERVER_SOFTWARE` は標準の WSGI 環境変数ですが、すべてのサーバーで設定されるとは限らず、設定形式も標準であるとは限りません。特定のサーバー構成 (`gunicorn.version` など) の一意のキーを確認するのが最も信頼性の高い方法です。

---

---

Flask は API 受信パラメータを取得します

Flask では、URL 内のクエリ文字列パラメータを処理するために使用されます (例:/my_api?abc=3&def=xyでabcそしてdef）主なツールは次のとおりです。flaskモジュラーrequest物体。使用できますrequest.argsこれらのパラメータにアクセスするための辞書。

1. 使用方法request.args辞書

request.argsは疑問符 (?) すべてのキーと値のペアの後。

Pythonの実装例

from flask import Flask、リクエスト、jsonify

app = Flask(__name__)

@app.route('/my_api',methods=['GET'])
def get_query_parameters():
    
    #クエリパラメータディクショナリ全体にアクセスする
    all_params = request.args
    print(f"すべてのパラメータ: {all_params}")
    
    # --- 特定のパラメータを取得する方法 ---
    
    # 1. .get() を使用してパラメータを取得します (推奨: 安全でデフォルト値が提供されます)
    # 'abc' パラメータを取得します。パラメータが存在しない場合はデフォルトで None になります。
    abc_value = request.args.get('abc')
    
    # 'def' パラメータを取得します。パラメータが存在しない場合は、デフォルトで 'default_value' が設定されます。
    def_value = request.args.get('def', 'default_value')
    
    # 2. [] を使用して直接アクセスします (非推奨: パラメータが存在しない場合は KeyError がスローされます)
    # 試してみます:
    # required_param = request.args['required']
    # except KeyError:
    # required_param = "不足しています"

    # --- 複数値パラメータの処理 ---
    # URLが/my_api?item=apple&item=bananaの場合
    item_list = request.args.getlist('item') # ['リンゴ', 'バナナ'] を返す
    
    return jsonify({
        "ステータス": "成功"、
        "abc": abc_value,
        "def": def_value、
        "アイテムリスト": アイテムリスト
    })

__name__ == '__main__'の場合:
    # テスト URL 1: http://127.0.0.1:5000/my_api?abc=3&def=xy&item=A&item=B
    # テスト URL 2: http://127.0.0.1:5000/my_api
    app.run(debug=True)

2. 主要なメソッドの説明

方法	使用	行動	例
request.args.get('key')	単一パラメータを安全に取得する	パラメータが存在しない場合は戻りますNone、エラーはスローされません。	request.args.get('user')
request.args.get('key', 'default')	パラメータを取得してデフォルト値を指定する	パラメータが存在しない場合は、指定したデフォルト値を返します。	request.args.get('page', 1)
request.args['key']	パラメータへの直接アクセス	パラメータが存在しない場合はスローされますKeyErrorエラーが発生し、500 サーバー エラーが発生します。	request.args['id']
request.args.getlist('key')	同じ名前の複数のパラメータを取得する	すべての値を含むリストを返します。	request.args.getlist('filter')

3. ハンドルタイプの変換

からrequest.args取得される値はすべて文字列です。引数が数値またはブール値である必要がある場合は、型変換を手動で行う必要があります。

# パラメータ(文字列)を取得します
num_str = request.args.get('num', '0')

#整数に変換
試してみてください:
    num_int = int(num_str)
ValueError を除く:
    num_int = 0 # 変換失敗のハンドル

# ブール値に変換します (注: Python では空でない文字列はすべて True です)
bool_str = request.args.get('is_admin', 'false'). lower()
is_admin = bool_str == 'true'

---

---

Flask ルート名を動的に生成する

Flask では、ルートを区別するための鍵は、Python コードで定義する関数名ではなく、エンドポイントです。ループと Python のクロージャ (Closure) 機能を使用して、ルートを動的に定義および登録し、それらに一意のエンドポイントを割り当てることができます。

1. 解決策: エンドポイント パラメーターとクロージャを使用する (推奨)

ファクトリ関数を使用して各ルート プロセッサを作成し、登録時に一意の「エンドポイント」名を指定します。

Pythonの実装例

FlaskインポートからFlask、jsonify
OSをインポートする

app = Flask(__name__)

# これがデータソースであると仮定します
Dynamic_apis = {
    "user_info": {"メソッド": "GET", "ハンドラー": ラムダ: {"データ": "取得されたユーザー情報"}},
    "product_list": {"method": "GET", "handler": lambda: {"data": "リストされた製品"}},
    "submit_form": {"method": "POST", "handler": lambda: {"data": "フォーム送信"}, "methods": ['POST']},
}

ファイル名_ベース = "db_agent"

# --- コアロジック: ルーティングファクトリー関数 ---

def create_dynamic_route(funstr、handler_func、メソッド):
    「」
    ルート ハンドラー関数 (クロージャ) を作成して返します。
    この関数は、funstr と handler_func の値を取得します。
    「」
    デフォルトのdynamic_route_handler():
        # 関数名は固定ですが、実行時に funstr にアクセスできます
        print(f"処理リクエスト: {funstr}")
        
        # 実際のビジネスロジックを実行する
        結果 = handler_func()
        
        jsonify(結果)を返す
    
    # 作成した関数を返す
    動的ルートハンドラーを返す

# --- 動的登録ループ ---

funstr の場合、dynamic_apis.items() の api_info:
    
    # 1. URL パスを構築する
    url_path = f"/{filename_base}/{funstr}"
    
    # 2. エンドポイント名を定義します (一意性を確保するために funstr を使用します)
    endpoint_name = f"{filename_base}_{funstr}_api"
    
    # 3. HTTPメソッドを取得する
    Methods = api_info.get("methods", ['GET']) # デフォルトは GET
    
    # 4. ルーティング処理関数の作成
    handler_func = create_dynamic_route(funstr, api_info["handler"], メソッド)

    #5. ルートを登録する
    # endpoint= パラメータを使用して、関数名の代わりに一意の名前を指定します
    app.add_url_rule(
        URL_パス、
        エンドポイント=エンドポイント名、
        view_func=handler_func、
        メソッド=メソッド
    )
    
    print(f"登録ルート: {url_path} (エンドポイント: {endpoint_name})")


__name__ == '__main__'の場合:
    # テストエンドポイント、例: http://127.0.0.1:5000/db_agent/user_info
    app.run(debug=True)

2. 要点の分析

• `app.add_url_rule()` の使用: これは、デコレーター構文を置き換えて、プログラムでルートを登録するための推奨される方法です。
• エンドポイント: `app.add_url_rule()` では、`endpoint` パラメータを使用して一意の名前 (例: `db_agent_user_info_api`) を指定する必要があります。この名前は、ルートを管理および参照するために Flask によって内部的に使用されるキーです (例: `url_for()` 内)。
• 結論: 「create_dynamic_route」関数が重要です。これは内部関数 `dynamic_route_handler` を返します。これは、ループ内の変数 `funstr` および `handler_func` の現在の値を「閉じる」(キャプチャして記憶する) ことで、各ルート ハンドラーが対応するロジックを正しく実行できるようにします。
• 関数名 (`get_???`): `endpoint` パラメーターを使用するため、Python は動的に作成された関数ごとに一意の名前を指定する必要はありません。一般的な `handler_func` 名を直接使用できます。

---

---

Gradio

Gradioは、機械学習モデルをよりアクセスしやすく、インタラクティブにするために設計されたオープンソースの Python ライブラリです。単純なコードを使用して、他の人がテストして使用できる機械学習モデルの Web インターフェイスをすばやく構築できます。

Gradioの主な機能

• 使いやすさ: わずか数行のコードでインタラクティブなインターフェイスを作成します。
• インスタント プレビュー: ローカルまたはクラウドで実行した後すぐに結果を表示できるため、モデルのテストと調整が簡単になります。
• さまざまなアプリケーション シナリオに適した、テキスト、画像、オーディオ、画像などのさまざまな入出力タイプをサポートします。
• 機械学習フレームワークとの互換性: Gradio は TensorFlow、PyTorch、Scikit-learn などのフレームワークと互換性があり、これらのフレームワークでトレーニングされたモデルで直接使用できます。
• 簡単な共有: 生成された Web インターフェースはリンクを通じて共有でき、他のユーザーは特別なソフトウェアをインストールせずにアクセスできます。

グラディオの使い方

Gradioの使い方はとても簡単です。以下は、単純なテキスト入出力インターフェイスを作成する方法を示す基本的な例です。

インポートグラディオASGR

#入力データを処理する関数を定義する
デフォルトの挨拶(名前):
    「こんにちは」+名前+「!」を返します。

# Gradioインターフェイスを作成する
iface = gr.Interface(fn=greet、inputs="テキスト"、outputs="テキスト")

# インターフェースの開始
iface.launch()

上記のコードは、ユーザーが名前を入力してパーソナライズされた挨拶を表示できるシンプルな Web インターフェイスを作成します。

Gradioの応用シナリオ

• 機械学習モデルの表示:機械学習モデルを他の人がテストして体験できるインタラクティブな Web アプリケーションにすばやく変換します。
• データの視覚化:データ処理の結果を視覚化し、プレゼンテーションや共有を容易にするために使用できます。
• ユーザーテストツール:開発者は、ユーザーが AI アプリケーションやその他の機能を試せるテスト ツールを迅速に生成できます。

結論は

Gradio は、機械学習モデルを Web アプリケーションに迅速に変換できるシンプルで強力なツールを開発者に提供し、幅広いユーザーが AI の結果を簡単にテストして体験できるようにします。個人的なプロジェクトでもチームワークでも、Gradio はモデルの宣伝と表示に最適です。

---

---

Gradio 出力は HTTP サーバー ページにリダイレクトされます

Gradio インターフェースの出力を Apache HTTP サーバー上のページ (`/results` など) にリダイレクトしたい場合は、Python のrequestsGradioを変換するモジュール 結果はサーバーに送信されます。 Gradio と Apache を統合する方法の基本的な手順は次のとおりです。

ステップ 1: HTTP サーバーを構成する

まず、Apache HTTP サーバーが実行中であり、データを処理できるエンドポイントが設定されていることを確認します (例:/results）。このエンドポイントには、受信データを処理するための PHP、Python、または別のバックエンド言語を使用できます。

ステップ 2: Gradio アプリケーションを作成する

Gradio アプリケーションを作成し、その出力を HTTP サーバーにリダイレクトするサンプル コードを次に示します。

インポートグラディオASGR
インポートリクエスト

# Gradio 入力を処理し、HTTP サーバーにリダイレクトします
def process_and_redirect(input_data):
    # 入力データを処理する
    result = f"処理されました: {input_data}"
    
    #HTTP POST リクエストを Apache HTTP サーバーに送信し、処理されたデータを送信します
    url = 'http://your-apache-server-address/results' # サーバーアドレスに置き換えます
    ペイロード = {'結果': 結果}
    
    試してみてください:
        応答 = リクエスト.ポスト(url, データ=ペイロード)
        response.status_code == 200の場合:
            return f"{url} に正常にリダイレクトされました。"
        それ以外の場合:
            return f「リダイレクトに失敗しました。ステータス コード: {response.status_code}」
    e としての例外を除く:
        return f"エラーが発生しました: {str(e)}"

# Gradioインターフェイスを作成する
iface = gr.Interface(
    fn=プロセスとリダイレクト、
    入力 = "テキスト"、
    出力 = "テキスト"、
    title="HTTP サーバーへの Gradio リダイレクト"
)

iface.launch()

ステップ 3: サーバー側の処理

Apache サーバーは、Gradio データを受信するための単純な PHP スクリプトなど、POST リクエストを処理するエンドポイントを使用して構成する必要があります。

<?php
// Gradio からの POST リクエストを処理します
if ($_SERVER["REQUEST_METHOD"] == "POST") {
    $result = $_POST['結果']; // POST リクエストから 'result' パラメータを取得します
    echo "Gradio から受信したデータ: " . htmlspecialchars($result);
}
?>

注意事項

• 安全: 機密データを送信する場合は、HTTPS を使用して送信を保護し、認証の追加を検討することをお勧めします。
• エラー処理: サーバーの障害やリクエストの失敗を回避するために、適切なエラー処理メカニズムが Gradio アプリケーションとサーバーの両方に追加されていることを確認してください。

要約する

これにより、Gradio アプリケーションを使用して出力を Apache HTTP サーバーにリダイレクトし、データをサーバー側で処理できるようになります。このような統合により、Gradio のインタラクティブ機能を Web 環境でより広く使用できるようになります。

---

---

Web サーバー上の Gradio コンテンツを表示する

方法 1: iframe を使用して Gradio ページを埋め込む

Gradio インターフェイスを Apache ページに埋め込む最も簡単な方法は、次のとおりです。iframeラベル。設定src属性は Gradio サーバーの URL です。

サンプルコード

<!DOCTYPE html>
<html lang="zh">
<頭>
    <メタ文字セット="UTF-8">
    <title>Apache インターフェイスに埋め込まれた Gradio</title>
</head>
<本体>
    <h1>埋め込み Gradio インターフェイス</h1>
    <iframe src="http://your-gradio-server-address:7860" width="100%" height="800px" Frameborder="0"></iframe>
</ボディ>
</html>

方法 2: リバース プロキシを使用して Gradio インターフェイスを Apache URL に統合する

Apache の URL を通じて Gradio インターフェイスに直接アクセスしたい場合は、リバース プロキシを構成できます。これにより、元の Gradio URL を表示する必要がなくなります。

ステップ

1. Apacheを有効にするmod_proxyそしてmod_proxy_httpモッド。次の命令を実行します。

sudo a2enmod proxy
sudo a2enmod proxy_http

またはコメントを解除します。

#LoadModule proxy_module modules/mod_proxy.so
#LoadModule proxy_http_module modules/mod_proxy_http.so

2. Apache の構成ファイルに、次のリバース プロキシ設定を追加して、Gradio インターフェイスを Apache の特定のパスにリバース プロキシします (例:/gradio)。

<Location "/gradio">
    ProxyPass "http://localhost:7860/"
    ProxyPassReverse "http://localhost:7860/"
</Location>
            

3. 設定を保存し、Apache サービスを再起動します。

sudo systemctl restart apache2

完了したら、使用できますhttp://your-apache-server-address/gradioGradio のインターフェイス コンテンツを Apache ページに表示します。

---

---

Apache プロキシ経由の Gradio 静的アセット

ステップ 1: プロキシとプロキシ HTTP モジュールを有効にする

Apache では、有効になっていることを確認してくださいproxyそしてproxy_httpモッド。まだ有効になっていない場合は、次のコマンドを実行できます。

sudo a2enmod proxy
sudo a2enmod proxy_http
    

ステップ 2: Apache 仮想ホスト構成を更新する

Gradio アプリケーションの Apache 設定ファイル (例:/etc/apache2/sites-available/yourdomain.conf)、次の設定を追加して ProxyPass を構成します および ProxyPassReverse:

<仮想ホスト *:80>
    サーバー名 yourdomain.com

    # Gradio ルート ディレクトリが Gradio サーバーを指すようにします
    プロキシパス/http://localhost:7860/
    ProxyPassReverse/http://localhost:7860/

    # 静的リソースが正常にプロキシできることを確認する
    プロキシパス /static/ http://localhost:7860/static/
    ProxyPassReverse /static/ http://localhost:7860/static/
</VirtualHost>
    

ステップ 3: Apache を再起動する

セットアップが完了したら、Apache を再起動して変更を適用します。

sudo systemctl restart apache2

このような構成では、次のような Gradio 静的リソースへのリクエストを明示的に処理できます。theme.css) スタイルが欠落している問題は解決されるはずです。 Gradioの静的ファイルパスが正しくない場合/static/、実際の状況に応じてパスを調整してください。

---

---

Gradio UIコンポーネント一覧

入力コンポーネント

• テキストボックス: 1 行または複数行のテキスト入力を受け入れます。
• 数値: 数値入力を受け入れます。
• スライダー：範囲内の数値入力を受け付け、ドラッグして選択します。
• チェックボックス: ブール値 (True/False) の入力を受け入れます。
• 無線: 複数のオプションの 1 つを受け入れます。
• ドロップダウン: ドロップダウン メニューとして表示する複数のオプションの 1 つを受け入れます。
• CheckboxGroup: 複数のオプションから 0 個以上の選択を受け入れます。
• 画像: 画像入力を受け入れ、アップロードまたは描画をサポートします。
• ビデオ: ビデオ入力を受け入れます。
• オーディオ: オーディオ入力を受け入れ、アップロードまたは録音をサポートします。
• ファイル: ファイルのアップロードを受け入れます。
• ColorPicker: 色の選択を受け入れます。
• スケッチパッド: ユーザーが画像入力としてキャンバスに描画できるようにします。
• データフレーム: データ フレーム (テーブル) 入力を受け入れ、手動編集または CSV/JSON のアップロードをサポートします。

出力コンポーネント

• ラベル: 通常、機械学習モデルの予測結果に使用される分類結果またはテキスト ラベルを表示します。
• テキストボックス: テキスト出力を表示します。
• 画像: 画像出力を表示します。
• ビデオ: ビデオ出力を表示します。
• オーディオ: オーディオ出力を表示します。
• HTML: HTML コンテンツを表示します。
• JSON: データを JSON 形式で表示します。
• Markdown: テキストを Markdown 形式で表示します。
• データフレーム: データフレーム (テーブル) 出力を表示します。
• HighlightedText: 特定のマークまたは強調表示された領域を含むテキストを表示します。
• プロット: さまざまなグラフを表示します (Matplotlib、Plotly など)。
• ギャラリー: 複数の画像を表示するギャラリー。

機能とレイアウトのコンポーネント

• ボタン: イベントまたは機能をトリガーするために使用されるクリック可能なボタン。
• タブ: 複数のインターフェースセクションを整理するために使用されるタブページ。
• 行/列: コンポーネントのレイアウト (水平または垂直の配置) を制御するために使用されます。
• グループ: 複数のコンポーネントをグループ化し、共通の境界線またはスタイルを設定するために使用されます。
• 状態: Gradio アプリケーションのさまざまな関数呼び出し間で状態を保存したり渡したりするために使用されます。
• データセット: サンプル入力データセットを表示および選択するために使用されます。
• チャットボット: チャットボット インターフェイスの構築に特に使用されるコンポーネント。
• ブロック: Gradio の宣言型 API の基礎であり、より細かいレイアウトと制御を可能にします。

---

---

Gradio の DataFrame コンポーネント

グラディオで利用可能gr.DataFramePandas DataFrame やその他の表形式のデータを表示または編集するためのウィジェット。ここではGradioの使い方を説明します。 DataFrame コンポーネントは、対話型データ テーブルを作成するためにアプリケーションで使用されます。

1. Gradioをインストールする

Gradio がまだインストールされていない場合は、次のコマンドを使用してインストールできます。

pip install gradio

2. 使用するgr.DataFrameテーブルデータを表示する

Gradio を使用して DataFrame を表示する方法は次のとおりです。 Gradio アプリで表示する必要がある Pandas DataFrame があるとします。

import gradio as gr
import pandas as pd

#サンプルデータフレームを作成する
data = {'名前': ['アリス', 'ボブ', 'チャーリー'], '年齢': [25, 30, 35], '職業': ['エンジニア', 'デザイナー', '医師']}
df = pd.DataFrame(data)

# DataFrameを返す関数を定義
def show_dataframe():
    return df

#Gradio インターフェイスの作成
インターフェイス = gr.Interface(fn=show_dataframe, 出力=gr.DataFrame(), title="人事データ テーブル")
interface.launch()


説明する

• import gradio as gr: Gradio スイートの紹介。
• data: サンプルデータを作成するために使用する辞書で、名前、年齢、職業の 3 つの列が含まれます。
• show_dataframe: 表示用の Pandas DataFrame を返す関数を定義します。
• gr.DataFrame(): Gradioインターフェースでテーブル表示用のDataFrameコンポーネントを作成します。
• interface.launch()：Gradioアプリを起動します。

3. 使用するgr.DataFrameインタラクティブな編集を行う

ユーザーがテーブルを編集できるようにするには、次のようにします。gr.DataFrame中程度の設定editable=True、ユーザーがテーブル データを変更できるようにします。

Interface = gr.Interface(fn=show_dataframe, Outputs=gr.DataFrame(editable=True), title="編集可能な人事データ テーブル")

結果

起動したアプリケーションには編集可能なテーブルが表示され、ユーザーは Web ページ上でデータを直接変更できます。

---

---

Gradioサーバーを強制終了する

ステップ 1: Gradio プログラムの PID を見つける

使用できますpsutilGradio プログラムの PID を見つけるモジュール。まず、インストールされていることを確認してくださいpsutil：

pip install psutil

次に、次のコードを使用して、Gradio 関連プログラムの PID を見つけることができます。

psutilをインポートする

# 「gradio」を含むプログラムを検索
psutil.process_iter(['pid', 'name', 'cmdline']) のプロセスの場合:
    if 'gradio' in ' '.join(process.info['cmdline']):
        print("見つかった Gradio プログラム PID:", process.info['pid'])

ステップ 2: Gradio プログラムを強制終了する

PID が見つかったら、次を使用できます。terminate()またはkill()プログラムを終了するメソッド。例えば：

psutil.process_iter(['pid', 'name', 'cmdline']) のプロセスの場合:
    if 'gradio' in ' '.join(process.info['cmdline']):
        process.kill() # プログラムを強制終了します
        print(f"終了した Gradio プログラム PID: {process.info['pid']}")

注意事項

使用kill()このメソッドはプログラムをただちに終了するため、プログラムで重要な操作が進行中でないことを確認してください。このサンプル コードは、一致するすべての Gradio プログラムを終了します。

---

---

リスニングポートを使用して Gradio サーバーを強制終了します

ステップ 1: 特定のポートをリッスンしているプログラムを見つける

使用できますpsutil特定のポートでリッスンしているプログラムを検索するモジュール。まず、インストールされていることを確認してくださいpsutil：

pip install psutil

次に、次のコードを使用してモニターを見つけることができます。7860ポートのプログラム PID。

psutilをインポートする

#検索するポート番号を指定
ターゲットポート = 7860
pid_to_kill = なし

# 指定したポートでリッスンしているプログラムを検索します
psutil.net_connections(kind='inet') の conn の場合:
    conn.laddr.port == target_port および conn.status == psutil.CONN_LISTEN の場合:
        pid_to_kill = conn.pid
        休憩

pid_to_kill の場合:
    print("リスニングポート 7860 のプログラム PID が見つかりました:", pid_to_kill)
それ以外の場合:
    print("リスニングポート 7860 に対応するプログラムが見つかりません")

ステップ 2: 見つかったプログラムを強制終了する

PID が見つかったら、次を使用できます。psutil.Processのkill()プログラムを強制終了する方法：

pid_to_kill の場合:
    プロセス = psutil.Process(pid_to_kill)
    process.kill() # プログラムを強制終了します
    print(f"リスニング ポート 7860 のプログラム PID が終了しました: {pid_to_kill}")
それ以外の場合:
    print("PID が見つからないため、プログラムを終了できません")

注意事項

このコードは、指定されたポートでリッスンしているプログラムを強制的に終了します。他のサービスを誤って終了しないように、ポートが実際に Gradio によって使用されていることを確認してください。

---

---

GradioにHTTP APIサーバーを追加する

Gradio は主に、機械学習モデルを表示するための高速で使いやすい Web UI を構築するために設計されています。それ自体はすでに Web サーバー上で実行されていますが、その主な目的は、従来の RESTful API エンドポイントではなく、人間とコンピューターの対話インターフェイスを提供することです。

Gradio アプリケーションに RESTful API 機能を持たせたい場合、最も推奨される方法は、**FastAPI** や **Flask** などのより強力な Web フレームワークに Gradio アプリケーションを埋め込むことです。これにより、サブパスに Gradio UI をマウントしながら、メイン フレームワークを使用して API エンドポイントを定義できるようになります。

1. 推奨される解決策: Gradio アプリケーションを FastAPI に埋め込む (推奨)

FastAPI は高速で、Gradio とともに Starlette フレームワークに依存しているため、埋め込みプロセスが非常にスムーズになります。

ステップ A: 必要なパッケージをインストールする

# FastAPI、Uvicorn (サーバー)、Gradio をインストールする
pip install fastapi uvicorn gradio

ステップ B: コードを実装する

Gradio を使用します.to_app()このメソッドは Gradio インターフェイスを ASGI アプリケーションに変換し、FastAPI を使用します。mountメインアプリケーションにマウントする機能。

fastapi から FastAPI をインポート
fastapi.responses から JSONResponse をインポート
インポートグラディオASGR

# 1. Gradio アプリケーション ロジックを定義する
デフォルトの挨拶(名前):
    return f「こんにちは、{名前}!」

gr_interface = gr.Interface(fn=greet、inputs="テキスト"、outputs="テキスト")

# 2. Gradio インターフェースを ASGI アプリケーションに変換する
gradio_app = gr_interface.to_app()

# 3. FastAPI メイン アプリケーションを作成する
app = FastAPI(
    title="Gradio + FastAPI サーバー",
    description="API エンドポイントと Gradio UI の両方を提供します"
)

# 4. (API SVR) RESTful API エンドポイントを定義する
@app.get("/api/v1/ステータス")
def api_status():
    return JSONResponse(content={"ステータス": "API は動作しています"})

@app.get("/api/v1/model_inference")
def api_inference(データ: str):
    # ここでモデルロジックを呼び出すことができます
    result = f"処理されたデータ: {data.upper()}"
    return JSONResponse(content={"result": result})

# 5. (Gradio SVR) Gradio アプリケーションを /gradio パスにマウントします
# mount() 関数を使用すると、別の ASGI アプリケーションを指定されたパスにマウントできます
app.mount("/gradio", gradient_app)

# 実行サーバー (ファイル名が main.py であると仮定します)
# ターミナルで実行します: uvicorn main:app --host 0.0.0.0 --port 8000 --reload

アクセス方法

• HTTP API サーバー: 「http://127.0.0.1:8000/api/v1/status」経由でアクセスします。
• Gradio UI インターフェイス: `http://127.0.0.1:8000/gradio` を通じてアクセスします。

2. 代替案: Gradio 内に API を提供する

Gradio 自体は、追加の Web フレームワークを必要とせずに、URL パラメーターを通じて Gradio インターフェイスの基礎となる関数を直接呼び出すことができる実験的な機能も提供します。これは標準の RESTful API ではありませんが、プログラムによる簡単なアクセスが可能です。

• Gradio アプリケーションの実行中は、特定の API パスを通じてその内部関数にアクセスできます。
• POST リクエストを使用して「/api/predict」または「/run/」を実行できます。<函式名稱>` エンドポイントは入力データを JSON 形式で送信し、結果を JSON 形式で受信します。
• 特定の API パスと形式は、Gradio UI の「API ファイル」ページ (通常は「/api」パスにあります) で見つけることができます。

ただし、FastAPI/Flask を使用して Gradio を埋め込むことは、より標準化された API 設計、ドキュメント、および認定を提供する、より標準的で柔軟なアプローチです。

---

---

Python クローラー

Requests + BeautifulSoup

これは最も一般的なクローラーの組み合わせであり、初心者に適しており、静的 Web ページの解析に使用されます。

pip install requests beautifulsoup4

使用例：

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")
print(soup.title.string)

Scrapy

大規模なクローラー プロジェクトに適した強力なクローラー フレームワークで、マルチスレッドおよび分散クローラーをサポートします。

pip install scrapy

使用例：

scrapy startproject myproject

プロジェクトにクローラ モジュールを作成し、クローリング コマンドを実行します。

Selenium

JavaScript でレンダリングされたコンテンツの処理など、ユーザー操作をシミュレートする必要がある動的 Web クローリングに適しています。

pip install selenium

使用例：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://example.com")
print(driver.title)
driver.quit()

Playwright

動的 Web ページを処理するためのもう 1 つのツールで、Selenium よりもパフォーマンスが高く、複数のブラウザーをサポートしています。

pip install playwright
playwright install

使用例：

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()

Pyppeteer

Puppeteer の Python バージョンに基づいており、動的 Web ページをクロールするために特別に設計されています。

pip install pyppeteer

使用例：

from pyppeteer import launch

async def main():
    browser = await launch()
    page = await browser.newPage()
    await page.goto("https://example.com")
    print(await page.title())
    await browser.close()

import asyncio
asyncio.get_event_loop().run_until_complete(main())

HTTPX

HTTP リクエストを送信し、非同期操作をサポートする効率的なツール。

pip install httpx

使用例：

import httpx

async def fetch():
    async with httpx.AsyncClient() as client:
        response = await client.get("https://example.com")
        print(response.text)

import asyncio
asyncio.run(fetch())

---

---

Python BeautifulSoup クローラー

To create a simple web scraper in Python, you can use the requests library to get the page content, and BeautifulSoup to parse the HTML.

Here's an example of a basic web scraper:

import requests
from bs4 import BeautifulSoup

# URL to scrape
url = "https://example.com"

# Send a GET request
response = requests.get(url)
response.raise_for_status() # Check for errors

# Parse the HTML content
soup = BeautifulSoup(response.content, "html.parser")

# Extract specific data (e.g., all the headings)
headings = soup.find_all("h1")

# Print the headings
for heading in headings:
    print(heading.text)


Note: You may need to install the libraries with the following commands:

pip install requests
pip install beautifulsoup4


---

---

BeautifulSoup は特定のタグとカテゴリのテキストを検索します

シナリオ例

次の HTML 構造があり、` を抽出したいとします。` タグ内のカテゴリ `xxxclass` のリテラル値:

    抽出するテキスト
    他のテキスト

BeautifulSoup を使用してテキストを検索して抽出する

以下は「BeautifulSoup」を使用した Python コードです。

bs4 インポートから BeautifulSoup

#HTMLファイル
html_content = """

    抽出するテキスト
    他のテキスト

「」

# HTMLを解析する
スープ = BeautifulSoup(html_content, 'html.parser')

# 特定のタグとカテゴリを検索する
span_tag =Soup.find('スパン', class_='xxxclass')

#テキスト値を抽出する
スパンタグの場合:
    print(span_tag.text) #出力: 抽出するテキスト
それ以外の場合:
    print("一致するタグが見つかりません")

メソッドの説明

1. `find(tag, class_=...)`: - `tag`: `span`など、検索するHTMLタグを指定します。 - `class_`: `xxxclass`などのクラス名を指定します。 Python の予約語 `class` との競合を避けるために、`class_` には下線が引かれていることに注意してください。 2. `.text`: タグ内のテキストコンテンツを抽出します。

複数の一致を検索する

複数のタグを抽出する必要がある場合は、`find_all` を使用できます。

# 一致するものをすべて検索ラベル
span_tags =Soup.find_all('スパン', class_='xxxclass')

#各ラベルのテキストを抽出します
scan_tags のタグの場合:
    print(タグ.テキスト)

その他のフィルター

1. **複数の属性でフィルタリング**:

   span_tag = soup.find('span', {'class': 'xxxclass', 'id': 'specific-id'})
   

2. **正規表現を使用してカテゴリを一致させます**:

   import re
   span_tag = soup.find('span', class_=re.compile(r'^xxx'))
   

注意事項

1. **HTML 形式**: HTML が有効であることを確認してください。有効でない場合、解析で問題が発生する可能性があります。 2. **空の結果の処理**: 結果が見つからない場合は `None` が返されます。エラーを避けるために、結果が空かどうかを確認する必要があります。

要約する

特定のタグやカテゴリ内のテキスト コンテンツは、「BeautifulSoup」の「find」または「find_all」メソッドを通じて簡単に抽出できます。フィルター条件と属性一致を柔軟に使用することで、より複雑なシナリオを処理できます。

---

---

Selenium

セレンとは何ですか?

Selenium は、主に Web ブラウザーの操作を自動化するために使用されるオープン ソース ツールです。 Chrome、Firefox、Safari などの複数のブラウザをサポートしており、Web アプリケーションのテストや Web データのスクレイピングに使用できます。

コア機能

• ブラウザの自動化: クリック、テキストの入力、フォームの送信などのユーザー操作をシミュレートします。
• クロスブラウザー テスト: 複数のブラウザーとオペレーティング システムの自動テストをサポートします。
• Python、Java、C#、Ruby などの複数のプログラミング言語をサポートします。
• 強力な拡張性: テスト フレームワーク (pytest、JUnit など) および CI/CD ツール (Jenkins など) と統合できます。

主要コンポーネント

• Selenium WebDriver：ブラウザと対話するためのコアツール。
• Selenium IDE：初心者向けのシンプルな録音および再生ツール。
• Selenium Grid：分散テストに使用され、マルチブラウザおよびマルチ環境の並列テストをサポートします。

アプリケーションシナリオ

• 機能テスト: Web アプリケーションの機能が適切に動作していることを確認します。
• 回帰テスト: 新機能が既存の機能に影響を与えるかどうかを迅速に検出します。
• データスクレイピング: Web ページ上の公開データの自動抽出。
• 継続的インテグレーション: CI/CD プロセス内の自動テスト。

インストールと基本的な使い方

Selenium をインストールする手順と簡単な Python の使用例を次に示します。

# Seleniumをインストールする
pip インストールセレン

#サンプルコード
SeleniumインポートWebドライバーから
selenium.webdriver.common.by からインポート

# WebDriverを起動する
ドライバー = webdriver.Chrome()
driver.get("https://www.example.com")

# 要素を検索して操作を実行する
要素 = driver.find_element(By.TAG_NAME, "h1")
print(要素.テキスト)

# ブラウザを閉じる
driver.quit()

利点と課題

• アドバンテージ：複数のブラウザ、複数の言語をサポートし、幅広いアプリケーションを備えています。
• チャレンジ：動的 Web ページを処理するには、要素が読み込まれるのを待つなどの追加のトリックが必要です。

---

---

Selenium Chrome は特定のユーザーを使用します

必要なパッケージをインストールする

Selenium と ChromeDriver がインストールされていることを確認します。

pip install selenium

適切なバージョンの Chrome をダウンロードしてインストールしますChromeDriver。

ユーザーフォルダーを設定する

Chrome のユーザー フォルダーには、ブックマーク、履歴、Cookie などの個人データが含まれています。ブラウザの起動に使用する特定のフォルダーを指定できます。

サンプルコード

SeleniumインポートWebドライバーから
selenium.webdriver.chrome.service インポート サービスから
selenium.webdriver.chrome.options からインポート オプション

#ChromeDriver のパスを指定する
chromedriver_path = "/パス/to/chromedriver"

#ユーザーフォルダを指定
user_data_dir = "/パス/への/ユーザー/データ"

# Chrome オプションを設定する
chrome_options = オプション()
chrome_options.add_argument(f"--user-data-dir={user_data_dir}")
chrome_options.add_argument("--profile-directory=Default") # または他のサブフォルダー名

# ブラウザを起動する
サービス = サービス(chromedriver_path)
driver = webdriver.Chrome(service=サービス、オプション=chrome_options)

# Webページを開く
driver.get("https://example.com")

# プログラムを終了する
driver.quit()

注意事項

• 必ず指定してくださいuser_data_dirパスは有効で書き込み可能なディレクトリです。
• フォルダーがすでに他の Chrome プロセスによって占有されている場合、起動に失敗する可能性があります。
• ユーザーのフォルダーへのパスは、ブラウザーの設定ページで確認できます。
• Chromeと入力してくださいchrome://version。
• プロファイル パスを表示します。

アプリケーションシナリオ

• 特定の Cookie、ブックマーク、またはその他のパーソナライゼーション データの使用が必要です。
• ログインが必要なサイトをテストする場合は、保存したログイン情報を使用します。
• 特定のユーザー環境の動作をシミュレートします。

---

---

すべての user_data_dir を取得する

1. 必要なライブラリをインストールする

インストールされていることを確認してくださいseleniumそしてpsutil：

pip install selenium psutil

2. すべての Chrome user_data_dir を使用中にする

次のコードは、実行中のすべての Chrome をスキャンして抽出します。user-data-dirパラメータ:

import psutil
import re

def get_all_user_data_dirs():
    user_data_dirs = set()
    for proc in psutil.process_iter(attrs=['pid', 'name', 'cmdline']):
        try:
            if proc.info['name'] and 'chrome' in proc.info['name'].lower():
                cmdline = ' '.join(proc.info['cmdline'])
                match = re.search(r'--user-data-dir=([^\s]+)', cmdline)
                if match:
                    user_data_dirs.add(match.group(1))
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
    return list(user_data_dirs)

print(get_all_user_data_dirs())

3. Selenium で特定の user_data_dir を使用する

ターゲットを見つけるuser_data_dir最後に、Selenium で使用できるようになります。

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

chrome_user_data_dir = "C:\\Users\\YourUser\\AppData\\Local\\Google\\Chrome\\User Data"

options = Options()
options.add_argument(f"--user-data-dir={chrome_user_data_dir}")

service = Service("chromedriver.exe")
driver = webdriver.Chrome(service=service, options=options)
driver.get("https://www.google.com")

4. 結論

を通してpsutil実行中の Chrome プロセスを解析してすべてを取得しますuser-data-dir、特定のを使用しますuser_data_dirブラウザを起動します。

---

---

Chrome データ ディレクトリからユーザー名を取得する

問題文

Chrome ユーザー データ ディレクトリからユーザー名を取得するには、そのディレクトリ内のファイル (通常は次のパスにある) にアクセスする必要があります。

• C:\Users\[Username]\AppData\Local\Google\Chrome\User Data\（Windows）
• /Users/[Username]/Library/Application Support/Google/Chrome/（macOS）
• /home/[Username]/.config/google-chrome/（Linux）

これらのフォルダーには、読み取ることができるファイルが多数含まれていますLocal Stateファイルを使用してユーザーに関する基本情報を取得します。

ステップ: 読むLocal Stateファイル

クロムLocal Stateこのファイルには、ユーザーの情報を取得できるいくつかの基本的なユーザー設定が含まれています。

jsonをインポートする
OSをインポートする

def get_chrome_user_name(user_data_dir):
    local_state_path = os.path.join(user_data_dir, 'ローカル状態')
    
    # ファイルが存在するか確認する
    os.path.exists(local_state_path) でない場合:
        「ローカル状態ファイルが見つかりません」を返します

    ファイルとして open(local_state_path, 'r', encoding='utf-8') を使用します:
        local_state = json.load(ファイル)

    # Local Stateからユーザー情報を取得する
    user_name = local_state.get('プロフィール', {}).get('名前', '不明なユーザー')
    
    ユーザー名を返す

# 例: Chrome ユーザー データ ディレクトリ パス
user_data_dir = r'C:\Users\YourUserName\AppData\Local\Google\Chrome\User Data'

print(get_chrome_user_name(user_data_dir))

ローカル状態を解析する

読むときLocal Stateファイルを JSON に解析すると、そこから次のような多くの情報を取得できます。

• profile: 名前、写真などのユーザーの設定情報が含まれます。
• last_version：Chromeの最新バージョンを表示します。
• is_logged_in：ユーザーがログインしているかどうかを示します。

ほとんどの場合、ユーザー名は次のとおりです。profile, 上記の方法で抽出できます。

注意事項

Local Stateファイルは Chrome を起動するたびに更新されるため、時間の経過とともにファイルの内容が変更される可能性があります。
• この方法は Chrome プロファイル データに依存するため、ユーザーが別の Google アカウントを使用している場合はファイル構造が異なる場合があります。

結論は

解析することでLocal Stateファイル内の JSON データから Chrome ユーザー名を簡単に取得できます。

---

---

ローカル状態ファイルからすべてのユーザーを取得する

問題文

クロムLocal Stateファイルには、ユーザーに関する多くの基本情報が保存されます。そこからすべてのユーザー名を抽出する場合は、ファイルを読み取り、その JSON コンテンツを解析します。これを実現する手順は次のとおりです。

ステップ: 読むLocal Stateアーカイブと解析

読むことができますLocal Stateファイルを解析し、その JSON 形式のコンテンツを解析してすべてのユーザー データを抽出します。

jsonをインポートする
OSをインポートする

def get_all_users(user_data_dir):
    local_state_path = os.path.join(user_data_dir, 'ローカル状態')
    
    # ファイルが存在するか確認する
    os.path.exists(local_state_path) でない場合:
        「ローカル状態ファイルが見つかりません」を返します

    ファイルとして open(local_state_path, 'r', encoding='utf-8') を使用します:
        local_state = json.load(ファイル)

    # Local State からすべてのユーザーデータを取得します
    profiles = local_state.get('profile', {}).get('info_cache', {})
    
    # すべてのユーザー名を取得する
    user_names = [profile.get('name', 'Unknown User') for profile in profiles.values()]
    
    ユーザー名を返す

# 例: Chrome ユーザー データ ディレクトリ パス
user_data_dir = r'C:\Users\YourUserName\AppData\Local\Google\Chrome\User Data'

print(get_all_users(user_data_dir))

ローカル状態のユーザー データを解析する

ChromeでLocal Stateファイルでは、ユーザー データは通常、次の場所に保存されます。profile下info_cacheこれは、各ユーザーのプロファイルがその構成名によってキー付けされている辞書です。

デモンストレーション：Local Stateファイル構造

以下はLocal Stateアーカイブ内の構造の例:

{
    "profile": {
        "info_cache": {
            "profile1": {
                "name": "User1",
                "avatar": "path/to/avatar1.jpg"
            },
            "profile2": {
                "name": "User2",
                "avatar": "path/to/avatar2.jpg"
            }
        }
    }
}

注意事項

• この方法は、Chrome ユーザー データ ディレクトリへの読み取りアクセス権をすでに持っていることを前提としています。
• 一部のユーザー データは、Chrome のバージョンや設定に応じて、異なるファイル構造で存在する場合があります。
• 一致するプロファイルがない場合は、デフォルト名として「不明なユーザー」が返されます。

結論は

解析することでLocal Stateファイルを使用すると、Chrome のすべてのユーザーの名前を取得できます。これにより、すべてのアカウントを簡単に一覧表示できます。

---

---

ローカル状態ファイル内のユーザー データ

問題文

ChromeでLocal Stateファイルには、各ユーザーのデータが含まれていますinfo_cache真ん中。そこから、ユーザー名と対応する構成サブディレクトリを抽出できます。

ステップ: 読むLocal Stateアーカイブと解析

Chromeから行う方法は次のとおりですLocal Stateファイル内のすべてのユーザーの名前と対応するサブディレクトリを取得するメソッド。

jsonをインポートする
OSをインポートする

def get_users_and_profiles(user_data_dir):
    local_state_path = os.path.join(user_data_dir, 'ローカル状態')
    
    # ファイルが存在するか確認する
    os.path.exists(local_state_path) でない場合:
        「ローカル状態ファイルが見つかりません」を返します

    ファイルとして open(local_state_path, 'r', encoding='utf-8') を使用します:
        local_state = json.load(ファイル)

    # Local State からすべてのユーザーデータを取得します
    プロファイル = local_state.get('プロファイル', {}).get('info_cache', {})
    
    # すべてのユーザー名とそれに対応するサブディレクトリを取得します
    ユーザー情報 = {}
    profiles.items() の profile_key、profile_data の場合:
        user_name = profile_data.get('name', '不明なユーザー')
        profile_sub_dir = os.path.join(user_data_dir, 'プロファイル' + profile_key)
        user_info[user_name] = profile_sub_dir
    
    ユーザー情報を返す

# 例: Chrome ユーザー データ ディレクトリ パス
user_data_dir = r'C:\Users\YourUserName\AppData\Local\Google\Chrome\User Data'

users_and_profiles = get_users_and_profiles(user_data_dir)
users_and_profiles.items() の user_name、profile_dir の場合:
    print(f"ユーザー名: {user_name}、サブディレクトリ: {profile_dir}")

ローカル状態のデータ構造を解析する

存在するLocal Stateファイルの場合、すべてのユーザー データは次の場所にあります。profile下info_cache。各ユーザーは対応する設定キーを持っています (例:profile1, profile2待って）。設定された各プロファイルにはユーザーの名前 (name）およびその他の関連情報。

デモンストレーション：Local Stateファイル構造

以下はLocal Stateアーカイブ内の構造の例:

{
    "profile": {
        "info_cache": {
            "Profile 1": {
                "name": "User1",
                "avatar": "path/to/avatar1.jpg"
            },
            "Profile 2": {
                "name": "User2",
                "avatar": "path/to/avatar2.jpg"
            }
        }
    }
}

注意事項

• 各ユーザーの設定サブディレクトリは通常、次で終わります。Profile先頭に数字が続きます (例:Profile 1, Profile 2待って）。
• このメソッドは、各ユーザーの名前と、それに対応する構成サブディレクトリのパスを返します。
• 一部のユーザーのデータが欠落している場合は、「不明なユーザー」がデフォルト名として返されます。

結論は

解析することでLocal Stateファイルを開くと、すべてのユーザーの名前と、それらに対応する構成サブディレクトリを取得できます。これにより、各ユーザーの構成データの場所を簡単に見つけることができます。

---

---

Chrome ユーザー向けの Gmail

問題文

Chrome ユーザー データ ディレクトリから Gmail アカウントを取得するには、Chrome 構成データから関連情報を抽出する必要があります。これは通常、Chrome のユーザー データ ファイル、特に Google 関連のアカウント データを解析することによって実現されます。

手順: プロファイル ファイルを読み取り、解析します。

各 Chrome ユーザーのデータは、通常は独自のフォルダーに保存されます。User Dataディレクトリの下にあるProfileディレクトリ内。ユーザーが Google アカウントにサインインしている場合は、関連する Gmail アカウント情報が構成データで見つかります。

OSをインポートする
jsonをインポートする

def get_gmail_from_profile(user_data_dir, profile_name):
    profile_dir = os.path.join(user_data_dir, profile_name)
    accounts_file = os.path.join(profile_dir, 'Web データ')

    # ファイルが存在するか確認する
    os.path.exists(accounts_file) でない場合:
        「Web データ ファイルが見つかりません」を返します

    # Web データファイルを読み込んでみる
    試してみてください:
        ファイルとして open(accounts_file, 'r', encoding='utf-8') を使用します:
            web_data = json.load(ファイル)

        # データから Gmail アカウントを抽出する
        web_data.get('accounts', []) の行:
            row.get('email', '') に 'gmail' がある場合:
                return row.get('電子メール')
        
        「Gmail アカウントが見つかりません」を返す
    e としての例外を除く:
        return f"Web データ ファイルの読み取りエラー: {e}"

# 例: Chrome ユーザー データ ディレクトリ パス
user_data_dir = r'C:\Users\YourUserName\AppData\Local\Google\Chrome\User Data'

# プロファイル 1 を使用していると仮定します。
プロファイル名 = 'プロファイル 1'
print(get_gmail_from_profile(user_data_dir, profile_name))

Web データアーカイブを解析する

ウェブ データ ファイルには、アカウント名、パスワード、その他の関連情報など、Chrome のさまざまなログイン データが含まれています。この例では、emailフィールドに Gmail メールボックスが含まれているかどうかを確認します。

デモ: Web データ ファイル構造

以下は、Web データ ファイルの部分構造の例です。

{
    "accounts": [
        {
            "email": "[email protected]",
            "password": "encrypted_password_1"
        },
        {
            "email": "[email protected]",
            "password": "encrypted_password_2"
        }
    ]
}

注意事項

• ウェブ データ ファイルは暗号化されて保存されるため、データを直接解析してもユーザーのパスワードを簡単に取得できない可能性がありますが、Gmail アカウント (email）通常は抽出できます。
• Chrome のバージョンに応じて、Web データ アーカイブの構造とコンテンツが異なる場合があります。
• ユーザーが Google アカウントにサインインしていない場合、Gmail アカウントはウェブ データに見つかりません。

結論は

Chrome ユーザー プロファイルを解析することによってWeb Dataファイルを使用すると、ユーザーの Gmail アカウントを簡単に取得できます。ユーザーが Gmail アカウントにサインインしている場合、対応する電子メールがデータに表示されます。

---

---

Webサイト内のページを閲覧するユーザーの操作をシミュレートします

ステップ 1: Web 自動化ツールを使用する

一般的な Web 自動化ツールには、Selenium や Playwright などがあります。これらのツールは、クリック、テキスト入力、その他のユーザー アクションをシミュレートできます。

ステップ 2: すべてのリンクを取得する

BeautifulSoup や Playwright などのツールを使用して、Web サイト上のすべてのハイパーリンクを取得します (<a href>) を使用して、閲覧するページのリストを作成します。

ステップ 3: ブラウザエミュレーションをセットアップする

Selenium または Playwright でブラウザを開き、ボタンのクリック、スクロール、さらには動的コンテンツのトリガーなどのユーザー アクションをシミュレートします。

ステップ 4: JavaScript 動的コンテンツを処理する

最近の Web サイトには動的に生成されたコンテンツが多数含まれていることが多く、Playwright または Selenium を使用して JavaScript を実行し、ページが正しく読み込まれるようにすることができます。

ステップ 5: すべてのページに再帰的にアクセスする

クロールされたリンクに基づいて、Web サイト内のすべてのページを再帰的に訪問し、重複を避けるために訪問したページを記録します。

ステップ 6: ユーザー操作を記録する

各ページを参照するときに、フォームへの記入、情報の送信、操作の結果の記録など、一般的なユーザーの行動をシミュレートします。

ステップ 7: 応用例

SeleniumインポートWebドライバーから
selenium.webdriver.common.by からインポート

#ブラウザを初期化する
ドライバー = webdriver.Chrome()

# ウェブサイトの閲覧を開始する
driver.get("https://example.com")

# すべてのリンクを取得する
links = driver.find_elements(By.TAG_NAME, "a")
リンク内のリンクの場合:
    href = link.get_attribute("href")
    print(f"リンクが見つかりました: {href}")

# クリックをシミュレートする
リンクの場合:
    リンク[0].click()

# ブラウザを閉じる
driver.quit()

注意事項

ウェブサイトの閲覧やシミュレーションを行う際は、過度なサーバー負荷や法律違反を避けるため、該当するウェブサイトの利用規約に従ってください。

---

---

WebDriver を使用してテストをステップ実行する

概要

Selenium WebDriver などの WebDriver を使用してテストする場合、問題のトラブルシューティングやユーザー アクションのシミュレーションを行うための段階的な実行を設計できます。ここでは、一般的な設計アプローチをいくつか紹介します。

方法 1: 明示的な待機を使用する

明示的に待機することで、次のステップに進む前に各ステップが完了していることを確認できます。

SeleniumインポートWebドライバーから
selenium.webdriver.common.by からインポート
selenium.webdriver.support.ui から WebDriverWait をインポート
selenium.webdriver.support から、expected_conditions を EC としてインポートします

#WebDriverの初期化
ドライバー = webdriver.Chrome()

#対象のWebサイトを開く
driver.get("https://example.com")

# ボタンが表示されるまで待ってクリックします
wait = WebDriverWait(ドライバー, 10)
button = wait.until(EC.element_to_be_clickable((By.ID, "button_id")))
button.click()

# 他の要素がロードされるまで待ちます
text_field = wait.until(EC.visibility_of_element_located((By.NAME, "text_field_name")))
text_field.send_keys("テストデータ")

# ブラウザを閉じる
driver.quit()

方法 2: 一時停止を手動で挿入する

`time.sleep()` を通じてテスト プロセスを一時停止し、各ステップの実行効果を観察します。

インポート時間
SeleniumインポートWebドライバーから

#WebDriverの初期化
ドライバー = webdriver.Chrome()

#対象のWebサイトを開く
driver.get("https://example.com")
time.sleep(3) # 3秒間一時停止します

# ボタンのクリックをシミュレートします
button = driver.find_element(By.ID, "button_id")
button.click()
タイムスリープ(3)

# ブラウザを閉じる
driver.quit()

**注意**: `time.sleep` は正式なテストには推奨されず、デバッグ目的のみに使用されます。

方法 3: ステップバイステップの実行とブレークポイントの設計

条件付きブレークポイントまたは入力ヒントをコードに追加すると、段階的にデバッグできます。

SeleniumインポートWebドライバーから

#WebDriverの初期化
ドライバー = webdriver.Chrome()

#対象のWebサイトを開く
driver.get("https://example.com")

# 手動確認後に続行
input("次のステップに進むには Enter キーを押してください...")
button = driver.find_element(By.ID, "button_id")
button.click()

# 引き続き他のテストを実行します
input("次のステップに進むには Enter キーを押してください...")
driver.quit()

方法 4: テスト フレームワークを使用して制御された実行を設計する

pytest や Unittest などのテスト フレームワークを利用すると、テストの実行をより柔軟に制御できます。

単体テストのインポート
SeleniumインポートWebドライバーから

クラス TestExample(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()

    def test_step_by_step(self):
        ドライバー = self.driver
        driver.get("https://example.com")
        input("ページを確認してください。続行するには Enter キーを押してください...") # 手動ブレークポイント

        button = driver.find_element(By.ID, "button_id")
        button.click()
        input("操作結果を確認してください。続行するには Enter キーを押してください...") # 手動ブレークポイント

    def ティアダウン(自分):
        self.driver.quit()

__name__ == "__main__"の場合:
    ユニットテスト.メイン()

注意事項

1. **待機時間の設定**: 効率と安定性を向上させるために、固定の一時停止の代わりに明示的な待機を使用します。 2. **デバッグにはステップバイステップ テストが使用されます**: ステップバイステップの実行設計はデバッグ プロセスに適していますが、長期にわたる自動テストには適していません。 3. **テスト フレームワークの柔軟性**: フレームワークを使用すると、テスト ケースとテスト ステップをより適切に整理できます。

要約する

明示的な待機、手動ブレークポイント、一時停止時間、またはテスト フレームワークとの組み合わせを通じて、段階的なテスト プロセスを効果的に設計して、デバッグと最適化操作を容易にすることができます。

---

---

Selenium は特定の行で始まるテキストを検索し、データを抽出します

コード例

SeleniumインポートWebドライバーから
selenium.webdriver.common.by からインポート

# Seleniumを初期化する
ドライバー = webdriver.Chrome()
driver.get("ターゲット Web ページ URL")

# 特定の行で始まるテキストを検索します
target_text = "ターゲットの開始テキスト"
rows = driver.find_elements(By.CSS_SELECTOR, "テーブル tr")

# 結果を保存する
結果データ = []

行内の行の場合:
    セル = row.find_elements(By.TAG_NAME, "td")
    セルとセル[0].text.startswith(target_text)の場合:
        # ピアの背後にある情報を取得する
        result_data.append([セル内のセルのcell.text])

driver.quit()

# 結果をHTMLに変換する
html_output = "<h2>検索結果</h2>\n"
i の場合、enumerate(result_data, start=1) の row_data:
    html_output += f"
行 {i}
\n
\n"
    row_data のデータの場合:
        html_output += f" <li>{data}</li>\n"
    html_output += "</ul>\n"

# 結果を表示
print(html_output)

実行結果例

検索結果
1行目

  
ターゲット開始テキスト 1
  
その他の情報1
  
その他の情報 2

2行目

  
ターゲット冒頭テキスト 2
  
その他の情報1
  
その他の情報 2

注意事項

• 特定の行の先頭のテキスト: を使用します。startswithテキストが条件を満たしているかどうかを判断する方法。
• HTML タイトル構造: 必要に応じて使用<h2>そして<h3>、順序なしリストとして<ul>情報を整理します。
• 必要なし<head>そして<body>: 他のページに簡単に埋め込めるように、必要な HTML タグのみを生成します。

---

---

find_elements By.XPATH

概要

セレンでは、find_elements(By.XPATH, xpath)XPath セレクターに基づいて基準に一致するすべての要素を検索し、リストを返すために使用されます。それはに関連していますfind_element(By.XPATH, xpath)異なりますが、後者は最初に一致した要素のみを返します。

基本的な文法

SeleniumインポートWebドライバーから
selenium.webdriver.common.by からインポート

# ブラウザを起動する
ドライバー = webdriver.Chrome()

# Webページを開く
driver.get("https://example.com")

# XPath を使用して条件に一致するすべての要素を検索します
elements = driver.find_elements(By.XPATH, "//div[@class='example-class']")

# 見つかった要素を走査し、コンテンツを出力します
要素内の要素の場合:
    print(要素.テキスト)

# ブラウザを閉じる
driver.quit()

一般的な XPath 式

XPath式	説明する
//tagname	指定されたタグを持つすべての要素を選択します。//divすべてを代表するdiv要素
//tagname[@attribute='value']	属性値に基づいて要素を選択します。//input[@type='text']
//tagname[contains(@attribute, 'value')]	特定のテキストを含む属性。//div[contains(@class, 'header')]
//tagname[text()='text']	テキストと完全に一致する要素を選択します。//ボタン[text()='送信']
//tagname[contains(text(), 'text')]	特定のテキストを含む要素を選択します。//p[contains(text(), 'ようこそ')]
//*[@id='some-id']	特定の ID を持つ要素を選択します
(//tagname)[index]	を選択します。index一致する要素、たとえば(//div)[1]最初の div を選択します

例: 複数の要素を検索する

次の HTML 構造を想定します。

<div class="product">製品 A</div>
<div class="product">製品 B</div>
<div class="product">製品 C</div>

次の Selenium コードを使用して、すべてを取得できます。productカテゴリdiv要素：

elements = driver.find_elements(By.XPATH, "//div[@class='product']")
for element in elements:
    print(element.text)

注意事項

• find_elements()要素が 1 つしか見つからない場合でも、返されるのはリストです。
• 要素が見つからない場合は、エラーをスローせずに空のリストが返されます。
• 必要な要素が 1 つだけであることが確実な場合は、次を使用する必要があります。find_element()、さもないとfind_elements()。

結論は

find_elements(By.XPATH, xpath)これは Selenium の強力かつ柔軟な検索方法であり、Web ページ上の複数の要素を見つけるために使用でき、クローラーや自動テストに適しています。

---

---

By.LINK_TEXT

概要

セレンでは、By.LINK_TEXTそしてBy.PARTIAL_LINK_TEXTハイパーリンクのテキスト内容に基づいて要素を検索するために使用されます。

• By.LINK_TEXT: 完全なリンク テキストに基づく完全一致。
• By.PARTIAL_LINK_TEXT: リンクテキストの一部に基づいてあいまい一致を実行します。

基本的な文法

SeleniumインポートWebドライバーから
selenium.webdriver.common.by からインポート

# ブラウザを起動する
ドライバー = webdriver.Chrome()

# Webページを開く
driver.get("https://example.com")

# LINK_TEXT を使用してハイパーリンクを検索します
element = driver.find_element(By.LINK_TEXT, "完全なリンク テキスト")
print(element.get_attribute("href"))

# PARTIAL_LINK_TEXT を使用してハイパーリンクを検索します
element_partial = driver.find_element(By.PARTIAL_LINK_TEXT, "部分テキスト")
print(element_partial.get_attribute("href"))

# ブラウザを閉じる
driver.quit()

HTML の例

<a href="https://example.com/page1">リンク全文</a>
<a href="https://example.com/page2">詳細についてはここをクリックしてください</a>

LINK_TEXTを使用してください

クリックしたいとします<a>完全なリンクテキスト</a>、次を使用できます。

driver.find_element(By.LINK_TEXT, "完全なリンク テキスト").click()

PARTIAL_LINK_TEXTを使用してください

ハイパーリンクが「詳細についてはここをクリックしてください」であるが、「ここをクリックしてください」しかわからない場合は、次を使用できます。

driver.find_element(By.PARTIAL_LINK_TEXT, "ここをクリック").click()

一般的なアプリケーションシナリオ

• ハイパーリンクのテキストが長く、動的に変化する場合に使用できます。By.PARTIAL_LINK_TEXT。
• リンク テキストが一意であることを確認する場合は、次を使用します。By.LINK_TEXT完全一致の場合。

注意事項

• これらのメソッドは次の場合にのみ機能します。<a>ラベルのリンク。
• Web ページが JavaScript を使用してリンクを生成している場合、Selenium はリンクをすぐに見つけることができず、ロードされるまで待機する必要がある場合があります。
• ページ内に同様のリンクが複数ある場合、find_elements()リストを返しますが、find_element()最初に一致した要素のみが返されます。

結論は

By.LINK_TEXT完全なリンクを正確に見つけるのに役立ちますが、By.PARTIAL_LINK_TEXTより柔軟で、リンク テキストの一部を一致させるために使用できます。

---

---

Selenium は欠落している要素を処理します

明示的な待機 WebDriverWait を使用する

SeleniumインポートWebドライバーから
selenium.webdriver.common.by からインポート
selenium.webdriver.support.ui から WebDriverWait をインポート
selenium.webdriver.support から、expected_conditions を EC としてインポートします

ドライバー = webdriver.Chrome()

試してみてください:
    elems = WebDriverWait(ドライバー, 10).until(
        EC.presence_of_all_elements_located((By.CSS_SELECTOR, ".item"))
    )
    print("見つかった要素:", len(elems))
以下を除く：
    print("10秒以内に要素が見つかりませんでした")

find_elements を使用すること自体は例外をスローせず、長さを直接決定できます。

要素 = driver.find_elements(By.CSS_SELECTOR, ".item")

要素でない場合:
    print("要素が見つかりません")
それ以外の場合:
    print("見つかった要素の数:", len(elems))

処理要素がまだ出現していない (一般的な理由)

• DOM がまだロードされていない → WebDriverWait を使用する
• 要素が iframe 内にある → 最初に iframe を切り替える必要があります
• 要素は Shadow DOM にあります → find_elements を直接見つけることができません
• 配置が間違っている → CSS セレクター / XPath を再確認する必要がある
• ページの読み込み中に動的 JS が存在する → 動的レンダリングが完了するまで待つ必要がある

iframeを切り替えた後の要素を検索する

# iframe に切り替えて再検索
iframe = driver.find_element(By.TAG_NAME, "iframe")
driver.switch_to.frame(iframe)

要素 = driver.find_elements(By.CSS_SELECTOR, ".item")
print("見つかった:", len(elems))

Shadow DOM では JS がshadowRoot に入る必要があります

shadow_host = driver.find_element(By.CSS_SELECTOR, "#shadowHost")
shadow_root = driver.execute_script("return arguments[0].shadowRoot", shadow_host)
elem = shadow_root.find_element(By.CSS_SELECTOR, ".target")

最も完全で安全な検索機能（再利用可能）

defsafe_find_elements(ドライバー、バイ、セレクター、タイムアウト=10):
    試してみてください:
        return WebDriverWait(ドライバー, タイムアウト).until(
            EC.presence_of_all_elements_located((by, セレクター))
        )
    以下を除く：
        return [] # 返された空のリストが見つかりません

要素 =safe_find_elements(ドライバー, By.CSS_SELECTOR, ".item")

要素の場合:
    print("見つかった:", len(elems))
それ以外の場合:
    print("要素が見つかりません")

---

---

Selenium はアラート ボックスを処理します

タイプ

• シンプルなアラートボックス・「OK」ボタンのみ。
• アラートボックスを確認する- 「OK」ボタンと「キャンセル」ボタンがあります。
• プロンプト警告ボックス- 「OK」ボタンと「キャンセル」ボタンのある入力ボックスがあります。

単純なアラートボックスの処理

SeleniumインポートWebドライバーから
selenium.webdriver.common.alert からのインポート アラート

ドライバー = webdriver.Chrome()
driver.get("URL")

アラート = アラート(ドライバー)
print(alert.text) # 警告メッセージを取得します
alert.accept() # 「OK」をクリックします

driver.quit()

処理確認アラートボックス

アラート = アラート(ドライバー)
print(alert.text)

alert.accept() # 「OK」をクリックします
#alert.dismiss() #クリックしてキャンセル

処理プロンプトと警告ボックス

アラート = アラート(ドライバー)
print(alert.text)

alert.send_keys("テスト入力") #入力内容
alert.accept() # 「OK」をクリックします

ベストプラクティス

• 使用driver.switch_to.alertアラートボックスに切り替えます。
• 使用try-except例外を処理してテストの失敗を回避します。
• 明示的な待機を使用して、アラート ボックスが表示されることを確認します。

  
  from selenium.webdriver.support.ui import WebDriverWait
  from selenium.webdriver.support import expected_conditions as EC
  
  WebDriverWait(driver, 10).until(EC.alert_is_present())
          

---

---

Selenium チェック アラート ボックス

警告ボックスがあるかどうかを確認する

Selenium では、次のことができます。WebDriverWait警告ボックスが表示されないことによるエラーを回避するために、警告ボックスが存在するかどうかを確認します。

SeleniumインポートWebドライバーから
selenium.webdriver.common.alert からのインポート アラート
selenium.webdriver.support.ui から WebDriverWait をインポート
selenium.webdriver.support から、expected_conditions を EC としてインポートします

ドライバー = webdriver.Chrome()
driver.get("URL")

試してみてください:
    # 5 秒待ってアラート ボックスがあるかどうかを確認します
    WebDriverWait(ドライバー, 5).until(EC.alert_is_present())
    アラート = アラート(ドライバー)
    print("アラートボックスの内容:",alert.text)
    alert.accept() # 「OK」をクリックします
以下を除く：
    print("警告ボックスが見つかりません")

driver.quit()

ベストプラクティス

• 使用WebDriverWait回避するために、切り替える前に警告ボックスが表示されることを確認してください。NoAlertPresentException。
• 使用try-except警告ボックスがないためにテストが失敗するのを防ぐため。

---

---

ハンドルシステムアラートボックス

質問

使用WebDriverWait(driver, 5).until(EC.alert_is_present())JavaScript によって生成されたアラート ボックスのみを検出できますが、「パスワードの保存」や「ウェブサイト通知」などの Chrome システム レベルのアラート ボックスは検出できません。

解決

• 使用ChromeOptionsシステムレベルのアラートボックスを無効にします。
• システム警告ボックスが表示された場合は、以下を使用する必要がある場合があります。pyautoguiまたはWin32 APIキーボードまたはマウスの操作をシミュレートします。

方法 1: Chrome システム アラートを無効にする

Chrome を起動するには、ChromeOptions通知やその他のシステム全体のポップアップを閉じます。

SeleniumインポートWebドライバーから

オプション = webdriver.ChromeOptions()
options.add_argument("--disable-notifications") # 通知を無効にする
options.add_argument("--disable-save-password-bubble") # パスワード プロンプトの保存を無効にする

driver = webdriver.Chrome(options=オプション)
driver.get("URL")

方法 2: pyautogui を使用してシステム アラート ボックスを処理する

警告ボックスが表示された場合は、次のコマンドを使用できます。pyautoguiを押すなどのキー操作をシミュレートします。EnterまたはEsc閉める。

importpyautogui
インポート時間

time.sleep(3) # アラートボックスが表示されるまで待ちます
pyautogui.press("enter") # Enter キーを押すことをシミュレートします

方法 3: Win32 API を使用する (Windows の場合)

Windows環境の場合は、次のように使用できます。pygetwindowそしてpywinautoシステムレベルのポップアップを検出して閉じます。

pygetwindowをGWとしてインポートします
importpywinauto

windows = gw.getWindowsWithTitle("Google Chrome") # Chrome ウィンドウを取得する
Windowsで勝つ場合：
    if "システム アラート" in win.title. lower(): # タイトルに "システム アラート" が含まれているかどうかを確認します。
        win.close() # ウィンドウを閉じる

ベストプラクティス

• ブラウザを起動するときに使用しますChromeOptions警告ボックスを防ぐため。
• システム警告ボックスが表示された場合は、次の使用を検討してください。pyautoguiまたはWin32 APIキーボードまたはウィンドウの操作をシミュレートします。

---

---

Shadow DOM

シャドウ DOM とは何ですか?

Shadow DOM は Web コンポーネントの一部であり、コンポーネントの内部実装の詳細が外部の世界に干渉しないように、HTML、CSS、および JavaScript をカプセル化するために使用されます。

簡単に言うと「スコープを分離する」DOM構造です。

---

Shadow DOM 構造図

<カスタム要素>
  #shadow-root (オープン)
    <button>クリックしてください</button>
</カスタム要素>

button実際にはシャドウ DOM に存在し、従来の DOM では使用できません。document.querySelector("button")現れる。

---

開閉モード

• open：JavaScriptでアクセス可能element.shadowRoot
• closed：element.shadowRootnull を返すため、アクセスできません
---

Shadow DOM の作成 (オープン モード)

const shadowHost = document.querySelector('#host');
const shadowRoot = shadowHost.attachShadow({ mode: 'open' });
shadowRoot.innerHTML = '<p>Hello from Shadow DOM</p>';

---

スロットスロットを使用する

// シャドウ DOM 内
<div><slot name="title">デフォルトのタイトル</slot></div>

// 外部使用
<カスタム要素>
  <span slot="title">カスタム タイトル</span>
</カスタム要素>

---

Selenium での Shadow DOM の操作

js = """
const host = document.querySelector('custom-element');
const shadow = host.shadowRoot;
return shadow.querySelector('button');
"""
button = driver.execute_script(js)
button.click()

---

アドバンテージ

• カプセル化: CSS/JS が外部に漏洩したり影響を受けたりすることはありません
• コンポーネント化: 再利用可能な UI 要素
• セキュリティ: 開発者が指定された API を介して内部操作のみを操作できるように制限します。
---

限界

• シャドウ内の要素は、XPath や一般的な CSS セレクターを使用して直接選択することはできません。
• JavaScript を取得する必要がありますshadowRoot後でもう一度検索してください

---

---

Tor ブラウザを使用した Selenium

基本的な概念

Tor ブラウザは、基本的に Firefox ESR に Tor ネットワーク設定と強化されたプライバシー設定を加えたものです。 Selenium は「Tor ブラウザ GUI を直接制御」することはできませんが、Firefox + Tor SOCKS ProxyTor ブラウザと同じ匿名性効果を実現する方法。

必要な条件

• Tor ブラウザ (または少なくとも Tor Expert バンドル) がインストールされている
• Python パッケージ: セレン
• Firefox および対応するバージョンの geckodriver

Torの起動方法

まず、Tor がローカル マシンで実行されていることを確認します。デフォルトの SOCKS プロキシは次のとおりです。

127.0.0.1:9050

Tor ブラウザを使用している場合、起動後は通常次のようになります。

127.0.0.1:9150

Selenium を使用して Tor プロキシをセットアップする

from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.firefox.service import Service

options = Options()
options.set_preference("network.proxy.type", 1)
options.set_preference("network.proxy.socks", "127.0.0.1")
options.set_preference("network.proxy.socks_port", 9150)
options.set_preference("network.proxy.socks_remote_dns", True)

service = Service("geckodriver.exe")
driver = webdriver.Firefox(service=service, options=options)

driver.get("https://check.torproject.org")

Tor が正常に使用されているかどうかを確認する

次の URL を入力すると、Tor の使用が成功を意味することがページに表示されます。

https://check.torproject.org

特定の Tor ブラウザ用の Firefox バイナリ

Tor ブラウザに組み込まれた Firefox を使用する場合:

options.binary_location = r"C:\Tor Browser\Browser\firefox.exe"

完全な例 (Windows)

from selenium import webdriver
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.firefox.service import Service

options = Options()
options.binary_location = r"C:\Tor Browser\Browser\firefox.exe"

options.set_preference("network.proxy.type", 1)
options.set_preference("network.proxy.socks", "127.0.0.1")
options.set_preference("network.proxy.socks_port", 9150)
options.set_preference("network.proxy.socks_remote_dns", True)

service = Service("geckodriver.exe")
driver = webdriver.Firefox(service=service, options=options)

driver.get("https://check.torproject.org")

注意事項

• Tor + Selenium は、Web サイトによって自動化された動作として簡単に認識されます
• Tor ブラウザのセキュリティは Selenium の設定によって弱まる可能性があります
• 関連性の漏洩を避けるため、実際の ID アカウントにはログインしないでください。
• Tor ネットワークの速度が遅いため、Selenium のタイムアウト設定を増やす必要があります

よくある間違い

• 接続できません: Tor が起動していないか、SOCKS ポート エラーです
• Firefox を起動できません: geckodriver は Firefox のバージョンと互換性がありません
• IPは変更されません：socks_remote_dnsが設定されていません

要約する

• Selenium は Tor ブラウザ UI を直接制御できません
• 正しい方法は Firefox + Tor SOCKS プロキシです
• sock_remote_dns の設定が匿名性の鍵です

---

---

Python が Thunderbird の重要なメールを抽出する

ステップ 1: 環境を準備する

Thunderbird から電子メールを抽出するには、Python の IMAP プロトコル ライブラリを使用できます。imaplibまたはサードパーティのライブラリimapclient。まず、確認してください Thunderbird では IMAP プロトコルが有効になっており、外部アプリケーションの接続が可能です。

ステップ 2: 必要な Python ライブラリをインストールする

pip を使用して関連ライブラリをインストールします。

pip install imapclient pyzmail36
    

ステップ 3: メールサーバーに接続する

次のコードを使用して電子メール サーバーに接続し、重要な電子メールを抽出します。

imapclient をインポートする
pyzmail から PyzMessage をインポート

# メールサーバーとログイン情報を設定する
IMAP_SERVER = 'imap.example.com' # IMAP サーバーのアドレスに置き換えます
EMAIL = '[email protected]'
PASSWORD = 'あなたのパスワード'

# IMAPサーバーに接続する
imapclient.IMAPClient(IMAP_SERVER) をクライアントとして使用:
    client.login(メールアドレス、パスワード)
    client.select_folder('INBOX')

    # 重要としてマークされたメッセージを検索する
    メッセージ = client.search(['フラグ付き'])
    メッセージ内の uid の場合:
        raw_message = client.fetch([uid], ['BODY[]'])[uid][b'BODY[]']
        メッセージ = PyzMessage.factory(raw_message)
        
        # メール情報を表示する
        print(f"件名: {message.get_subject()}")
        print(f"From: {message.get_address('from')}")
        print(f"日付: {message.get_decoded_header('date')}")

ステップ 4: 注意事項

• IMAP サーバーのアドレスが正しいこと、およびアカウントで IMAP プロトコルが有効になっていることを確認してください。
• サーバー設定によっては、アプリケーション固有のパスワードを生成するか、安全な接続 (SSL) を有効にする必要がある場合があります。
• パスワードをコードに直接保存しないでください。環境変数またはパスワード管理ツールを使用することをお勧めします。

ステップ 5: テストとデバッグ

上記のコードを実行して、重要としてマークされた電子メールを正常に抽出できるかどうかを確認します。接続に問題がある場合は、サーバー設定を確認するか、IMAP プロトコル層でより詳細なデバッグを実行できます。

このようにして、Python を使用して Thunderbird から重要なメールを正常に抽出できます。

---

---

PyAutoGUI

PyAutoGUI をインストールする

次の手順に従って PyAutoGUI をインストールします。

pip install pyautogui

基本機能

PyAutoGUI は、マウスやキーボードの操作をシミュレーションできる自動化ツールで、GUI の自動テストや反復作業に適しています。

マウス操作

マウスの位置とアクションを制御します。

importpyautogui

# 画面解像度を取得する
画面幅、画面高さ = pyautogui.size()
print(f"画面解像度: {screen_width}x{screen_height}")

# 指定した座標にマウスを移動します
pyautogui.moveTo(100, 100, period=1)

# 現在の位置からマウスを移動します
pyautogui.move(50, 50, period=1)

# マウスクリックをシミュレートする
pyautogui.click(200, 200)

# マウスの右クリックをシミュレートします
pyautogui.rightClick()

# ドラッグ操作をシミュレートする
pyautogui.dragTo(400, 400, 持続時間=1)

キーボード操作

キーボードのキー入力をシミュレートします。

importpyautogui

# テキストを入力
pyautogui.write("こんにちは、PyAutoGUI!", 間隔=0.1)

# 特定のキーを押すことをシミュレートする
pyautogui.press("入力")

# Press multiple keys at the same time
pyautogui.hotkey("ctrl", "c") # テキストをコピー

スクリーンショットと画像認識

スクリーンショットを撮るか、特定の画像を見つけます。

importpyautogui

# 画面全体をキャプチャする
スクリーンショット = pyautogui.screenshot()
スクリーンショット.save("スクリーンショット.png")

# 画面上の画像を検索する
location = pyautogui.locateOnScreen("image.png")
場所の場合:
    print(f"画像の場所: {location}")
それ以外の場合:
    print("画像が見つかりません")

警告と安全性

プログラムが無期限に実行されないようにするには、次のようにします。pyautogui.FAILSAFE：

pyautogui.FAILSAFE = True # デフォルトは True
# マウスを画面の左上隅 (0, 0) に移動すると、プログラムがすぐに停止します

一般的なアプリケーション

• フォームへの記入やクリックなどの反復的なアクションを自動化します。
• 特定の UI 要素が存在するかどうかを検出するためのスクリーンショット。
• 簡単なテストのためにキーボードとマウスの操作をシミュレートします。

---

---

Surfshark VPN の制御

準備

Surfshark VPN が次のようなコマンド ライン ツールを提供していない場合surfshark-cli)、GUI 自動化ツール (次のような) を使用する必要があります。pyautogui) 手動操作をシミュレートします。

• Surfshark VPN デスクトップ アプリがインストールされています。
• Pythonがインストールされているpyautoguiモジュール（経由で入手可能）pip install pyautoguiインストール）。
• Python スクリプトに十分な権限があることを確認してください。

プログラムロジック

を通してpyautoguiSurfshark のグラフィカル インターフェイスのボタンのクリックを自動化して、VPN に接続または切断します。

サンプルコード

次の例では、Surfshark VPN のボタン位置が固定されており、pyautogui行うべきこと:

importpyautogui
インポート時間

def connect_vpn():
    # Surfshark がオンになっていることを確認してください
    print("VPN に接続してみます...")
    # 「接続」ボタンのクリックをシミュレートし、実際の位置に応じて座標を調整します
    pyautogui.click(x=500, y=300) # 「接続」ボタンの位置に置き換えます
    time.sleep(5) # 接続が完了するまで待ちます
    print("VPN接続中")

デフォルトの切断_vpn():
    # Surfshark がオンになっていることを確認してください
    print("VPN から切断してみます...")
    # 「切断」ボタンのクリックをシミュレートし、実際の位置に応じて座標を調整します
    pyautogui.click(x=500, y=350) # 「切断」ボタンの位置に置き換えます
    time.sleep(5) # 切断が完了するまで待ちます
    print("VPN が切断されました")

# テスト
connect_vpn()
切断_vpn()
    

実際の運用上の注意点

• ボタンの座標: 画面解像度と Surfshark VPN インターフェイスに応じて調整する必要がありますxそしてyコーディネート。
• アプリを起動します: Surfshark VPN が起動していることを確認してください。起動していなければ機能します。subprocessアプリケーションを開きます。subprocess.run("start surfshark.exe", shell=True)。
• オートメーションのアクセス許可: Windows 設定で偽装入力を許可する必要がある場合があります。

代替方法

座標方法が不安定な場合は、画像認識（pyautogui.locateOnScreen()) ボタンの位置を見つけて柔軟性を高めます。

---

---

Kivy - Python GUI

Kivy は、マルチタッチ アプリケーションを迅速に開発するためのオープンソース Python フレームワークです。クロスプラットフォームのサポートを念頭に置いて設計されており、開発者は Windows、macOS、Linux、iOS、Android で作業できます。 同じコードが複数のプラットフォームで実行されるまで待ちます。 Kivy は、携帯電話、タブレット、デスクトップ デバイス用の GUI アプリケーションの構築に特に適しており、優れたマルチタッチ サポートを備えています。

Kivyの主な機能

• クロスプラットフォームのサポート: Kivy は、Windows、macOS、Linux などの主流のオペレーティング システムと、Android や iOS などのモバイル プラットフォームをサポートしています。
• マルチタッチ: マルチタッチ イベントのサポートが組み込まれており、携帯電話やタブレットのアプリケーションの開発に適しています。
• 効率的なインターフェース設計: Kivy は豊富な UI コントロールを提供し、Kivy Language (KV) を使用してインターフェイスを迅速に設計およびレイアウトできます。
• ハードウェアアクセラレーション: Kivy は OpenGL ES 2 を使用してグラフィックスをレンダリングし、アプリケーションのスムーズさとパフォーマンスを保証します。

キビィの使い方

Kivy アプリケーションは複数のウィジェットで構成されており、コードまたは Kivy 独自の言語 KV ファイルを通じてレイアウトできます。以下は、クリックすると色が変わるボタンを表示する簡単なアプリケーションの例です。

基本的な例

kivy.app からアプリをインポート
kivy.uix.button インポートボタンから

クラスMyApp(アプリ):
    デフォルトビルド(自分自身):
        return Button(text='こんにちは、Kivy!',
                      background_color=(0, 1, 0, 1)) # 緑色のボタン

__name__ == '__main__'の場合:
    MyApp().run()

Kivy をインストールする

Kivy は pip 経由でインストールできます。

pip install kivy

Kivy アプリケーションのシナリオ

Kivy は、以下を含むさまざまなアプリケーション シナリオに適していますが、これらに限定されません。

• 携帯電話やタブレット用のマルチタッチ アプリケーション
• クロスプラットフォームのデスクトップ アプリケーション
• ゲーム開発
• 革新的なインターフェースとインタラクションデザイン

---

---

Python Kivy でリモート表示する方法

Kivy はクロスプラットフォーム アプリケーションを構築するための Python フレームワークですが、通常はローカル デバイス上で実行されます。 Kivy アプリケーションをリモートで表示するには、次のオプションを検討できます。

1. VNC またはリモート デスクトップ ツールを使用する

VNC (仮想ネットワーク コンピューティング) または他のリモート デスクトップ ツール (RDP、TeamViewer など) を使用して、Kivy アプリケーションをリモートで制御および表示できます。

• VNC サーバーまたはその他のリモート デスクトップ ソフトウェアをサーバーにインストールします。
• 対応するクライアント ツールをローカル デバイスにインストールします。
• サーバーに接続し、Kivy アプリケーションをリモートで表示します。

2. X11 転送を使用する (Linux の場合)

Linux を使用している場合は、X11 転送を使用してグラフィカル インターフェイスをリモートで表示できます。

• リモート サーバーに X11 がインストールされていることを確認してください。
• X11 転送にはローカル側で SSH コマンドを使用します。

  ssh -X username@remote_host

• Kivy アプリケーションを実行すると、ローカル デバイスに表示されます。

3. Kivy + FlaskをWebアプリケーションの表示として使用する

Flask または他の Web フレームワークを使用して、Kivy アプリケーションの一部をリモート ユーザーに公開し、Web ブラウザーを使用して表示できます。

• Kivy 関連のデータまたは操作を処理するために Flask バックエンドを構築します。
• 対応する出力を Web フロントエンドに表示します (Kivy は Web に直接表示できないため、このメソッドは主にデータ処理またはバックエンドの対話に使用されます)。

4. Docker + Kivy + VNC

コンテナ化された環境で Kivy アプリを実行したい場合は、Docker と VNC を使用してセットアップできます。

• Kivy アプリケーションを Docker コンテナにパッケージ化します。
• VNCサーバーをコンテナにインストールします。
• VNC 経由でリモート コンテナに接続し、Kivy アプリケーション インターフェイスを表示します。

---

---

No module named 'kivy.garden.tickmarker'

ModuleNotFoundError: No module named 'kivy.garden.tickmarker'

This error indicates that the tickmarker module from Kivy's Garden is not installed. To fix this issue, follow the steps below:

Steps to Resolve the Issue

1. Install Kivy Garden
   If you don’t already have Garden installed, open your terminal or command prompt and run the following command:

   pip install kivy-garden

2. Install the Tickmarker Widget
   After installing Kivy Garden, install the tickmarker widget by running:

   garden install tickmarker

Once you've done these steps, try running your Kivy application again.

---

---

Rio UI

導入

Rio UI は、Python を中核とするユーザー インターフェイス フレームワークで、開発者がシンプルかつ直感的な方法で対話型アプリケーションを作成できるように設計されています。これは Python プログラミング ロジックに基づいており、最新のフロントエンド テクノロジを通じて UI を表示します。

特徴

• 純粋な Python 構文を使用して UI を作成できるため、フロントエンドとバックエンドを分離する学習のしきい値が低くなります。
• リアルタイム更新とリアクティブインターフェイスをサポートします。
• Web テクノロジーと組み合わせて、クロスプラットフォーム ソリューションを提供できます。
• 導入プロセスが簡素化され、ラピッド プロトタイピングに適しています。

設置方法

pip install rio-ui

基本的な例

import rio

app = rio.App()

@app.page("/")
def index():
    return rio.Text("Hello, Rio UI with Python!")

if __name__ == "__main__":
    app.run()

アプリケーションシナリオ

• 小さなツールや社内システムを迅速に開発
• インタラクティブなデータ視覚化アプリケーションを構築する
• 教育または研究の性質を持つプロトタイプ システム

---

---

---

email: [email protected]

T:0000
資訊與搜尋 | 回dev首頁 | 回python首頁
email: Yan Sa [email protected] Line: 阿央
電話: 02-27566655 ,03-5924828
阿央
泱泱科技
捷昱科技泱泱企業