Python言語用語集

エグゼクティブサマリ

本用語集は、Pythonプログラミング言語に関する基本用語と特徴機能を解説する技術文書である。動的型付け、自動メモリ管理、豊富な組み込みデータ構造などPythonの主要な特徴の解説から、個々の用語の詳細な説明、記号とキーワードの解説まで、体系的に整理されている。各用語には詳細な説明とコード例が付属し、用語間のリンクにより関連概念を参照できる構成となっている。プログラミング初学者から中級者を対象とし、大学の情報工学課程における教材として、またPython学習者の参考資料として使用できる内容である。

【本文書の使い方】

推奨される学習順序：

  1. 基本的なデータ型と変数の概念を理解する（型、変数、初期化）
  2. 制御フローの仕組みを学ぶ（if、for、while）
  3. 関数の定義と呼び出しを習得する（関数、仮引数、引数）
  4. ファイル操作とエラー処理を習得する（ファイル、open()、try、except）
  5. クラスとオブジェクト指向の概念を学ぶ（クラス、メンバ）

辞書的利用：用語集から必要な用語を直接参照することも可能である。

【目次】

  1. 主要概念の解説
  2. 用語
  3. Pythonの記号・キーワード等
  4. 索引

主要概念の解説

本セクションでは、Pythonプログラミング言語の主要概念を解説する。これらの概念は相互に関連し、Pythonの生産性と可読性を支える基盤となっている。

データ型と変数（Types and Variables）

Pythonは動的型付け言語であり、変数の型は実行時に決定される。変数はオブジェクトへの参照（名前の束縛）として機能し、代入が宣言と初期化を兼ねる。すべての値はオブジェクトであり、型情報はオブジェクト側が保持する。

x = 10            # 整数オブジェクトに名前xを束縛
name = "Alice"    # 文字列オブジェクトに名前nameを束縛
numbers = [1, 2, 3]  # リストオブジェクトに名前numbersを束縛

# 型ヒント（実行時には強制されない。静的解析ツール向け）
age: int = 25
height: float = 175.5

Pythonの主な組み込み型には、数値型（int、float、complex）、シーケンス型（list、tuple、range）、テキスト型（str）、マッピング型（dict）、集合型（set）、ブール型（bool）、None型がある。

関連項目：型、変数、初期化、宣言

制御フロー（Control Flow）

Pythonの制御フローは、条件分岐（if/elif/else）、繰り返し（for、while）、ジャンプ（break、continue、return）で構成される。ブロックの範囲はインデント（4つの半角空白が推奨）で示され、波括弧によるブロック区切りは使用しない。

for i in range(10):
    if i % 2 == 0:
        continue        # 偶数はスキップ
    if i > 7:
        break           # 7を超えたらループ終了
    print(i)            # 1, 3, 5, 7

Python 3.10以降ではmatch文による構造的パターンマッチングも使用できる。

関連項目：制御文、ブロック、字下げ

関数（Functions）

関数は、特定の処理をまとめた再利用可能なコードブロックである。defキーワードで定義し、引数を受け取り、return文で値を返す。return文がない場合、または引数なしのreturnの場合はNoneが返される。

Pythonでは引数の渡し方としてオブジェクト参照の値渡しが採用されている。ミュータブルオブジェクト（リスト、辞書など）を渡した場合、関数内でのオブジェクトの変更は呼び出し元に反映される。イミュータブルオブジェクト（整数、文字列など）の場合、関数内で再代入しても呼び出し元には影響しない。

def divide(a, b):
    """商と余りを返す"""
    return a // b, a % b    # 複数の値をタプルで返す

quotient, remainder = divide(10, 3)

# 無名関数（ラムダ式）
square = lambda x: x ** 2

関連項目：関数、仮引数、引数、参照による呼び出し・値による呼び出し

ファイル操作とエラー処理（File I/O and Error Handling）

ファイル操作は、open()関数でファイルを開き、読み書きを行い、閉じるという手順で実行する。with文を使用するとクローズが自動化される。エラー処理はtry/except文で例外を捕捉する仕組みである。

try:
    with open("data.txt", "r", encoding="utf-8") as f:
        for line in f:
            print(line.strip())
except FileNotFoundError:
    print("ファイルが見つかりません")
except Exception as e:
    print(f"エラー: {e}")

関連項目：ファイル、オープンモード、エラー

クラスとオブジェクト指向（Classes and Object-Oriented Programming）

クラスは、データ（属性）と処理（メソッド）をまとめたオブジェクトの設計図である。classキーワードで定義する。__init__メソッドは初期化メソッドであり、インスタンス生成時に自動的に呼び出される。第1引数selfはインスタンス自身への参照である。

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

    def greet(self):
        print(f"Hello, my name is {self.name}")

person = Person("Alice", 30)
person.greet()  # "Hello, my name is Alice"

関連項目：クラス、メンバ、構造体

用語

本セクションでは、プログラミングに関する用語をテーマ別に解説する。各用語についてPythonでの扱いを中心に説明する。

基本概念

プログラム

コンピュータに実行させる命令の集まりをプログラムという。オペレーティングシステムなどのシステムプログラムと、特定の用途に使用するアプリケーションプログラムに分類される。

プログラミング

プログラムを設計・作成する作業をプログラミングという。

プログラミング言語

プログラムを記述するための人工言語をプログラミング言語という。Python、JavaScript、C、C++、Java、Ruby、Go、Rustなどがある。

コーディング

ソースプログラムを作成する作業をコーディングという。プログラミングが設計から実装・テストまでの全工程を指すのに対し、コーディングは設計に基づいてコードを記述する工程を指すことが多い。

ソースプログラム

人間が読み書きできる形式で記述されたプログラムをソースプログラム（ソースコード）という。プログラミング言語処理系によって解釈または変換される。

ソースファイル

プログラムのソースコードを保存したテキストファイルをソースファイルという。Pythonのソースファイルの拡張子は.pyであり、デフォルトの文字エンコーディングはUTF-8である。

コメント

プログラム中に記述する注釈をコメントという。実行時には無視される。コードの説明や意図の記述に使用する。Pythonでは#記号から行末までが1行コメントとなる。

# これは1行コメント
x = 10  # 行末コメント

Pythonには複数行コメントの構文はない。トリプルクォート（"""または'''）で囲んだ文字列リテラルが代用されることがあるが、厳密にはコメントではなく文字列リテラルである。関数やクラスの本体の先頭に記述した場合はdocstring（ドキュメンテーション文字列）として扱われ、help()関数やIDEで参照できる。

def example():
    """この関数の説明（docstring）。
    help(example)で参照できる。"""
    pass

ドキュメンテーション文字列（docstring）

関数やクラス、モジュールの説明を記述する文字列をドキュメンテーション文字列（docstring）という。定義本体の先頭にトリプルクォートで記述し、__doc__属性やhelp()関数で参照できる。

def add(a, b):
    """aとbの和を返す。"""
    return a + b

関連項目：コメント

識別子

変数、関数、クラスなどに付ける名前を識別子という。Pythonの識別子は以下の規則に従う。

慣例（PEP 8）：変数名・関数名はsnake_case、クラス名はPascalCase、定数はUPPER_SNAKE_CASEを使用する。

関連項目：予約語

予約語

プログラミング言語において特別な意味を持ち、識別子として使用できない語を予約語（キーワード）という。Python 3の予約語は以下のとおりである。

False    await    else     import   pass
None     break    except   in       raise
True     class    finally  is       return
and      continue for      lambda   try
as       def      from     nonlocal while
assert   del      global   not      with
async    elif     if       or       yield

関連項目：識別子

プログラミングスタイル

コードの書き方に関する規約やガイドラインをプログラミングスタイルという。PythonではPEP 8が標準的なスタイルガイドとして広く採用されている。主な規則には、インデントに4つの半角空白を使用する、1行は79文字以内にする（docstringやコメントは72文字）、関数やクラスの定義の前後に空行を入れる（トップレベルは2行、メソッド間は1行）、インポートは別々の行に記述しファイル先頭にまとめる、などがある。

エディタ

テキストやプログラムを編集する機能を持つソフトウェアをエディタという。プログラミング用のエディタにはVisual Studio Code、PyCharm、Sublime Textなどがある。

コマンドラインシェル

テキストベースのコマンドを入力してコンピュータを操作するプログラムをコマンドラインシェルという。bash（Linux、macOS）、PowerShell・コマンドプロンプト（Windows）などがある。Pythonスクリプトの実行やパッケージのインストール（pipコマンド）に使用される。

プログラミング言語のシェル（REPL）

対話的にプログラムを入力・実行できる環境をREPL（Read-Eval-Print Loop）という。Pythonではpythonコマンドを引数なしで実行するか、IPythonを使用する。入力した式の評価結果が即座に表示される。

実行環境とメモリ

プログラミング言語処理系

ソースコードを解釈・実行するソフトウェアをプログラミング言語処理系という。インタプリタ（逐次解釈実行）とコンパイラ（一括変換）に大別される。Pythonはインタプリタ型言語に分類されるが、実装上はソースコードをバイトコードにコンパイルした後、Python仮想マシン（PVM）で実行する。代表的な実装にCPython（標準）、PyPy、Jythonなどがある。

コンパイル

ソースコードをコンピュータが実行可能な形式に変換する処理をコンパイルという。Pythonでは、ソースコード（.py）はバイトコード（.pycファイル）に変換され、Python仮想マシン（PVM）で解釈実行される。この変換は通常、モジュールのインポート時に自動的に行われる。

関連項目：Python仮想マシンコード

Python仮想マシンコード

Pythonソースコードがコンパイルされて生成される中間コードをバイトコードという。バイトコードはPython仮想マシン（PVM）で解釈実行される。コンパイル済みバイトコードは__pycache__ディレクトリ内の.pycファイルに保存され、再実行時にソースが変更されていなければ再利用される。

関連項目：逆アセンブル

逆アセンブル

機械語やバイトコードを人間が読める形式に変換することを逆アセンブルという。Pythonではdisモジュールを使用してバイトコードを逆アセンブルできる。

import dis

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

dis.dis(add)

実行形式ファイル

機械語で記述され、コンピュータが直接実行できるファイルを実行形式ファイルという。Windowsでは.exe、Unix系ではELF形式が使用される。Pythonは通常、実行形式ファイルを生成せず、インタプリタがソースコードを解釈実行する。PyInstallerやcx_Freezeなどのツールを使用すれば実行形式ファイルに変換することも可能である。

プロセッサ

機械語のプログラムを解釈・実行するハードウェアをプロセッサ（CPU）という。

メモリ

データやプログラムを一時的に記憶する装置をメモリ（主記憶装置、RAM）という。各記憶位置にはアドレスが割り当てられている。

関連項目：アドレス、動的メモリ管理

アドレス

メモリ内での位置を示す値をアドレスという。Pythonではid()関数を使用してオブジェクトの識別値を取得できる。CPython実装ではこの値はメモリアドレスに対応するが、他の実装（PyPy等）では異なる場合がある。id()が返すのはオブジェクトの一意な識別値であり、必ずしもメモリアドレスを意味しない。

data = 100
print(f"データ={data}, id={id(data)}")

関連項目：ポインタ

アクセス

データの読み出しや書き込みを行うことをアクセスという。「メモリにアクセスする」「ディスクにアクセスする」などのように使用する。

動的メモリ管理

プログラムの実行中にメモリを確保・解放することを動的メモリ管理という。Pythonではガベージコレクション（参照カウント方式＋循環参照検出）によりメモリが自動管理されるため、明示的なメモリ管理は不要である。

ガベージコレクション

不要になったオブジェクトのメモリを自動的に回収する仕組みをガベージコレクションという。Pythonでは参照カウントを主な方式とし、循環参照を検出する世代別ガベージコレクタを補助的に使用する。gcモジュールでガベージコレクタの制御が可能である。

関連項目：動的メモリ管理

ポインタ

メモリ上のアドレスを格納する変数をポインタという。Pythonではポインタを直接操作しない。すべての変数がオブジェクトへの参照として機能し、ポインタに相当する処理は言語が内部的に行う。

関連項目：間接参照

間接参照

ポインタを通じてデータにアクセスすることを間接参照（デリファレンス）という。Pythonではすべての変数がオブジェクトへの参照として機能するため、間接参照に相当する処理は言語が内部的に行う。

NULLポインタ

どのオブジェクトも指していないことを示すポインタをNULLポインタという。PythonではNoneが「値がないこと」を表す同様の役割を果たす。ただし、NoneはNoneType型の唯一のインスタンスであり、ポインタではない。

オーバーフロー

演算結果の絶対値がデータ型で表現可能な範囲を超えた状態をオーバーフローという。Pythonの整数型（int）は任意精度であるため、整数のオーバーフローは発生しない。浮動小数点数（float）はIEEE 754倍精度で表現されるため、オーバーフローが発生する可能性がある。

バイト

データの基本単位をバイトという。1バイトは8ビットで構成され、0から255までの256通りの値を表現できる。

メイン処理（if __name__ == "__main__":）

スクリプトの直接実行時にのみ特定の処理を実行するためのPython固有のイディオムである。モジュールとしてインポートされた場合は実行されない。スクリプト直接実行時には__name__変数に"__main__"が設定され、インポート時にはモジュール名が設定される。

def main():
    print("メイン処理")

if __name__ == "__main__":
    main()

モジュール

関数やクラス、変数をまとめたPythonファイル（.py）をモジュールという。import文で読み込んで使用する。複数のモジュールをディレクトリにまとめたものをパッケージという。

import math
print(math.sqrt(2))  # 1.4142135623730951

関連項目：import、from

データ型と変数

型

データの種類と、そのデータに対して実行可能な操作を定義するものを型という。Pythonは動的型付け言語であり、変数の型は実行時に決定される。

Pythonの主な組み込み型を以下に示す。

関連項目：変数、初期化

変数

データを参照するための名前を変数という。Pythonでは変数はオブジェクトへの参照（名前の束縛）として機能する。変数自体は値を格納せず、オブジェクトに名前を束縛する。動的型付け言語であるため、同じ変数に異なる型の値を再代入することも可能である。

x = 10           # 整数オブジェクト10にxという名前を束縛
name = "Alice"   # 文字列オブジェクトに名前を束縛
numbers = [1, 2, 3]

# 型ヒント付き変数
age: int = 25
height: float = 175.5

関連項目：型、初期化

初期化

変数やオブジェクトに最初の値を設定することを初期化という。Pythonでは変数への最初の代入が宣言と初期化を兼ねる。代入前の変数を参照するとNameErrorが発生する。

x = 10                              # 整数
rate = 124.10                       # 浮動小数点数
name = "Alice"                      # 文字列
numbers = [1, 2, 3]                 # リスト
person = {"name": "Bob", "age": 25} # 辞書
flag = True                         # ブール値
result = None                       # None（値なし）

宣言

変数や関数の名前と型を指定することを宣言という。Pythonでは変数の明示的な宣言は不要であり、最初の代入時に変数が自動的に作成される。型ヒントを使用して型情報を注釈として記述できるが、実行時には強制されず、静的解析ツール（mypy等）による検査に使用される。

x = 10  # 宣言不要。代入が変数の作成を兼ねる

# 型ヒント付き
y: int = 20
name: str = "Alice"

定数

プログラム中で変更されない値を定数という。Pythonには定数を定義する専用のキーワードがない。慣例として大文字のスネークケースで命名する。typingモジュールのFinalを使用すると、型チェッカーに対して再代入を禁止する意図を示すことができる。

MAX_SIZE = 100

from typing import Final
PI: Final = 3.14159

真

偽として評価される値以外のすべての値が真（True）と評価される。0以外の数値、空でない文字列、空でないコンテナなどが真となる。

関連項目：偽

偽

Pythonでは以下の値がブール文脈で偽（False）と評価される。この判定はオブジェクトの__bool__()メソッドまたは__len__()メソッドに基づく。

関連項目：真

数字

0から9までの10個の記号を数字（digit）という。Pythonの整数リテラルは10進数のほか、2進数（0b接頭辞）、8進数（0o接頭辞）、16進数（0x接頭辞）で記述できる。桁区切りにアンダースコア_を使用できる（Python 3.6以降）。

decimal = 255
binary = 0b11111111
octal = 0o377
hexadecimal = 0xFF
large = 1_000_000

ヌル文字

文字列の終端を示す特殊文字（'\0'、値は0）をヌル文字という。Pythonのstr型ではヌル文字による終端は使用せず、文字列の長さは別途管理される。

演算子と式

演算子

1個または複数のオペランドに対して演算を行うための記号を演算子（オペレータ）という。Pythonの代表的な演算子は記号・キーワード等セクションで個別に解説する。

オペランド

演算子による演算の対象となる値や変数をオペランドという。たとえば式a + bでは、aとbがオペランド、+が演算子である。

式

演算子とオペランドの組み合わせで構成され、評価すると値を生成するコードの断片を式（expression）という。

30                          # リテラル式
x                           # 名前式
x + y                       # 二項演算式
len(my_list)                # 関数呼び出し式
x if c else y               # 条件式（三項演算子）
[i for i in range(10)]      # リスト内包表記

式のみで構成される文を式文という。式の評価結果は通常破棄されるが、関数呼び出しなどの副作用を目的とする場合に使用される。

評価

式からその値を計算することを評価（evaluate）という。Pythonではeval()関数で文字列の式を動的に評価することもできるが、セキュリティ上の理由から信頼できない入力に対する使用は避けるべきである。

算術

数値に対する加減乗除などの基本的な計算を算術という。

インクリメント

値を1増やす操作をインクリメントという。Pythonには++演算子は存在しないため、+= 1を使用する。

x = 10
x += 1  # xは11になる

関連項目：デクリメント

デクリメント

値を1減らす操作をデクリメントという。Pythonには--演算子は存在しないため、-= 1を使用する。

x = 10
x -= 1  # xは9になる

関連項目：インクリメント

文と制御フロー

文

プログラムを構成する実行単位を文（statement）という。Pythonの主な文には、代入文（x = 10）、条件文（if/elif/else）、繰り返し文（for/while）、ジャンプ文（break/continue/return）、pass文、import文、def文、class文、raise文、try文、with文がある。

ブロック

複数の文をまとめた単位をブロック（複文）という。Pythonではインデントによりブロックの範囲を示す。

def greet(name):
    # ここからブロック開始（インデントレベル1）
    message = f"Hello, {name}"
    print(message)
    # ブロック終了（インデントが戻ると終了）

if True:
    print("条件は真")

字下げ（インデント）

プログラムの行頭に空白を挿入することを字下げ（インデント）という。Pythonではインデントが構文上必須であり、ブロックの範囲を示す。同一ブロック内の文は同じインデントレベルでなければならない。PEP 8では4つの半角空白が推奨されている。タブと空白の混在はPython 3ではエラーとなる。

制御文

プログラムの実行順序を変更する文を制御文という。以下の3種類に分類される。

繰り返し

同じ処理を条件に基づいて複数回実行することを繰り返し（ループ、反復）という。Pythonではfor文とwhile文が使用される。

イテラブル

for文で要素を順に取り出せるオブジェクトをイテラブルという。__iter__()メソッドを持つオブジェクトが該当する。リスト、タプル、文字列、辞書、集合、range、ジェネレータなどがイテラブルである。

for ch in "abc":
    print(ch)  # a, b, c

関連項目：繰り返し、ジェネレータ

選択文

条件に基づいて実行する処理を選択する文を選択文という。Pythonの選択文にはif文とmatch文（Python 3.10以降）がある。

ジャンプ文

プログラムの実行位置を変更する文をジャンプ文という。break（最も内側のループを中断して脱出）、continue（次の反復へ移行）、return（関数から呼び出し元へ復帰）の3つがある。

入れ子

ある構造の内部に同じ種類の構造が含まれている状態を入れ子（ネスト）という。ループ、条件分岐、関数呼び出しなどで入れ子構造が使用される。

for i in range(10):
    for j in range(20):
        print(f"i={i}, j={j}")

# リスト内包表記による2次元リスト
x = [[0 for j in range(20)] for i in range(10)]

改行・改行文字

テキストの表示位置を次の行の先頭に移動させる動作を改行という。改行を表す特殊文字を改行文字といい、Pythonでは\nで表現する。OSによって内部表現は異なる（Windowsでは\r\n、Unix系では\n）が、Pythonのテキストモードでは読み書き時に自動変換される。

print("1行目\n2行目\n3行目")

関数

関数

特定の処理をまとめた再利用可能なコードブロックを関数という。引数を受け取り、処理を実行し、結果を返すことができる。Pythonではdefキーワードで関数を定義する。

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

result = add(3, 5)  # 8

return文がない場合、または引数なしのreturnの場合はNoneが返される。複数の値をタプルとして返すこともできる。

def divide(a, b):
    return a // b, a % b

quotient, remainder = divide(10, 3)

プログラムは通常、上から下へ順番に実行される。関数呼び出しがあると制御は関数の本体に移り、処理が完了すると呼び出し元に戻る。

関連項目：仮引数、引数、return

仮引数

関数定義において宣言される変数を仮引数（パラメータ）という。関数が呼び出されると、実引数の値が仮引数に渡される。

def greet(name):  # nameが仮引数
    print(f"Hello, {name}")

greet("Alice")  # "Alice"が実引数

Pythonの仮引数には以下の種類がある。

関連項目：引数

引数（実引数）

関数呼び出し時に渡す値を引数（実引数、argument）という。位置実引数とキーワード実引数がある。関数定義側で受け取る変数は仮引数（パラメータ）と呼ばれる。

def add(a, b):   # a, bは仮引数
    return a + b

add(3, 5)         # 位置実引数
add(a=3, b=5)     # キーワード実引数

参照による呼び出し・値による呼び出し

関数への引数の渡し方に関する概念である。値による呼び出しはデータのコピーを渡す方式、参照による呼び出しはデータへの参照を渡す方式である。

Pythonではオブジェクト参照の値渡し（pass by object reference）が採用されている。関数にはオブジェクトへの参照のコピーが渡される。動作はオブジェクトのミュータブル/イミュータブルの性質に依存する。

# ミュータブル（リスト）：オブジェクトの変更が呼び出し元に反映される
def modify_list(lst):
    lst.append(4)

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # [1, 2, 3, 4]

# イミュータブル（整数）：再代入しても呼び出し元に影響しない
def modify_number(n):
    n = n + 100

x = 10
modify_number(x)
print(x)  # 10

ミュータブルオブジェクトであっても、仮引数に別のオブジェクトを再代入した場合は呼び出し元に影響しない。影響するのはオブジェクト自体を変更（ミューテーション）した場合に限られる。

スコープ

変数が参照可能なプログラム上の範囲をスコープという。PythonではLEGB規則（Local → Enclosing → Global → Built-in）の順で名前が検索される。

x = "global"              # グローバルスコープ
def f():
    y = "local"            # ローカルスコープ

関連項目：global、nonlocal

ジェネレータ

値を逐次生成するイテラブルの一種をジェネレータという。yieldを含む関数（ジェネレータ関数）またはジェネレータ式で作成する。全要素を一度にメモリに保持しないため、大量のデータを扱う際に効率的である。

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

関連項目：yield、イテラブル

デコレータ

関数やクラスの動作を修飾する仕組みをデコレータという。@記号を使用して適用する。デコレータは関数を引数に取り、関数を返す高階関数である。

def log(func):
    def wrapper(*args): print(f"呼び出し: {func.__name__}"); return func(*args)
    return wrapper

関連項目：@

再帰的呼び出し

関数が自分自身を呼び出すことを再帰的呼び出し（再帰）という。問題を同じ構造のより小さな問題に分割して解く場合に有効である。再帰関数には必ず基底条件（再帰を停止する条件）が必要である。

def hanoi(n, source, auxiliary, target):
    if n == 1:  # 基底条件
        print(f"円盤1を{source}から{target}へ移動")
        return
    hanoi(n - 1, source, target, auxiliary)
    print(f"円盤{n}を{source}から{target}へ移動")
    hanoi(n - 1, auxiliary, source, target)

hanoi(3, "A", "B", "C")

Pythonのデフォルトの再帰上限は1000回である（sys.getrecursionlimit()で確認、sys.setrecursionlimit()で変更可能）。深い再帰が必要な場合はループへの変換を検討する。

関連項目：ハノイの塔

ハノイの塔

3本の柱とサイズの異なる複数の円盤を用いるパズルである。「大きな円盤の上に小さな円盤のみ置ける」という制約のもと、円盤を1枚ずつ移動させてすべてを別の柱に移す問題であり、再帰的呼び出しの典型的な例題として知られる。

データ構造

データ構造

データを効率的に格納・操作するための形式をデータ構造という。Pythonが標準で提供する主なデータ構造を以下に示す。

配列

同じ型のデータがメモリ上に連続して配置されたデータ構造を配列という。Pythonではリスト（list）が配列に相当する汎用的なデータ構造として使用される。リストは異なる型の要素を混在させることができ、サイズも動的に変更できる。

numbers = [1, 2, 3, 4, 5]
mixed = [1, "two", 3.0, True]

print(numbers[0])   # 1（インデックスは0始まり）
print(numbers[-1])  # 5（負のインデックスは末尾から）
print(numbers[1:3]) # [2, 3]（スライス）

# リストの作成
zeros = [0] * 100  # 100個の0を含むリスト
matrix = [[0 for j in range(20)] for i in range(10)]  # 2次元リスト

同じ型のみを格納するメモリ効率の高い配列が必要な場合は、arrayモジュールやNumPyライブラリを使用する。

タプル

イミュータブルな順序付きのシーケンスをタプル（tuple）という。要素の変更・追加・削除ができないため、変更されるべきでないデータの格納や辞書のキーに使用できる。

t = (1, "two", 3.0)
print(t[0], len(t))  # 1 3

関連項目：配列

辞書

キーと値のペアを格納するマッピング型を辞書（dict）という。キーにはハッシュ可能な（イミュータブルな）オブジェクトを使用する。キーによる検索・挿入・削除は平均O(1)で実行される。

d = {"name": "Alice", "age": 30}
print(d["name"])  # Alice

関連項目：集合

集合

重複のない要素の集まりを集合（set）という。和集合、積集合、差集合などの集合演算を使用できる。要素はハッシュ可能でなければならない。

s = {1, 2, 3, 2}
print(s)  # {1, 2, 3}

関連項目：辞書

自己参照構造体

自身と同じ型への参照を含む構造体を自己参照構造体という。連結リストや木構造の実装に使用される。Pythonではクラスを使用して実装する。

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None  # 次のNodeへの参照（またはNone）

文字列とテキスト処理

文字列データ

文字の並びを表すデータを文字列という。Pythonではstr型で表現され、シングルクォート（'）またはダブルクォート（"）で囲む。文字列はイミュータブル（変更不可能）である。

s1 = "Hello"
s2 = 'World'
s3 = """複数行の
文字列"""

length = len(s1)            # 長さの取得: 5
upper = s1.upper()          # 大文字変換: "HELLO"
combined = s1 + " " + s2    # 連結: "Hello World"
joined = " ".join([s1, s2]) # join()による連結: "Hello World"

比較には比較演算子を直接使用でき、Unicodeのコードポイント順で比較される。

文字型

Pythonには独立した文字型は存在しない。単一の文字は長さ1の文字列（str型）として扱われる。

書式文字列

データの文字列への変換形式を指定する文字列を書式文字列という。Pythonでは3つの方法がある。

name = "Alice"
age = 30

# f-string（フォーマット済み文字列リテラル、Python 3.6以降、推奨）
print(f"{name}は{age}歳です")

# format()メソッド
print("{}は{}歳です".format(name, age))

# %演算子（古い形式）
print("%sは%d歳です" % (name, age))

# 書式指定の例
pi = 3.141592653589793
print(f"円周率={pi:.4f}")  # 小数点以下4桁: "円周率=3.1416"

型変換関数 / split()

文字列からデータを読み込むには、int()、float()などの型変換関数とsplit()メソッドを組み合わせる。

s = "10 20 30"
values = [int(x) for x in s.split()]  # [10, 20, 30]

s2 = "Alice,30,175.5"
parts = s2.split(",")
name, age, height = parts[0], int(parts[1]), float(parts[2])

ファイル操作

ファイル

ディスクなどの記憶装置に保存されるデータの単位をファイルという。操作にはオープン→読み書き→クローズの手順が必要である。with文を使用するとクローズが自動化されるため、推奨される方法である。

# ファイルの読み込み
with open("input.txt", "r", encoding="utf-8") as f:
    content = f.read()

# ファイルへの書き込み
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello, World!")

# 1行ずつの読み込み（メモリ効率が良い）
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

ファイルの終端はread()やreadline()が空文字列を返すことで検出される。

関連項目：オープンモード、open()、with

オープンモード

ファイルを開く方法を指定するパラメータをオープンモードという。

テキストファイル

人間が読める文字で構成されたファイルをテキストファイルという。バイナリファイルと対比される概念である。Pythonではopen()のモード指定で区別し、テキストモードではエンコーディングに基づく文字列の読み書きと改行文字の自動変換が行われる。

標準出力・標準入力

標準出力はプログラムの既定の出力先であり、通常はコンソール（端末）に接続される。print()関数が出力を行い、sys.stdoutでアクセスできる。標準入力はプログラムの既定の入力元であり、通常はキーボードに接続される。input()関数が1行を文字列として読み込み、sys.stdinでアクセスできる。リダイレクトにより入出力先をファイルに変更することも可能である。

コンテキストマネージャ

with文で使用する、リソースの確保と解放を自動化する仕組みをコンテキストマネージャという。__enter__()と__exit__()メソッドを実装するか、contextlibモジュールを使用して作成する。

with open("file.txt") as f:
    data = f.read()  # ブロック終了時に自動でclose

関連項目：with

クラスとオブジェクト

クラス

データ（属性）と処理（メソッド）をまとめたオブジェクトの設計図をクラスという。classキーワードで定義する。

class Person:
    def __init__(self, name, age):
        self.name = name  # インスタンス変数（属性）
        self.age = age

    def greet(self):  # メソッド
        print(f"Hello, my name is {self.name}")

person = Person("Alice", 30)
person.greet()  # "Hello, my name is Alice"

__init__は初期化メソッドであり、インスタンス生成時に自動的に呼び出される。第1引数selfはインスタンス自身への参照であり、メソッド呼び出し時にPythonが自動的に渡す。

関連項目：メンバ、構造体

メンバ

クラスを構成する要素をメンバという。Pythonのクラスでは属性（インスタンス変数、クラス変数）とメソッドがメンバに相当する。

class Person:
    species = "Homo sapiens"  # クラス変数（全インスタンスで共有）

    def __init__(self, name, age):
        self.name = name  # インスタンス変数
        self.age = age

    def greet(self):      # メソッド
        print(f"Hello, {self.name}")

構造体

複数のデータを1つにまとめたデータ型を構造体という。Pythonではdataclass、namedtuple、または通常のクラスで実現する。dataclassデコレータを使用すると__init__、__repr__、__eq__などのメソッドが自動生成される。

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    height: float

p = Person("Alice", 30, 165.0)
print(p.name)  # "Alice"

エラーとデバッグ

エラー

プログラムの実行中または実行前に発生する問題をエラーという。

例外

実行時に発生するエラーを表すオブジェクトを例外という。try/except文で捕捉し、raise文で発生させる。すべての組み込み例外はBaseExceptionクラスを継承する。

try:
    x = int("abc")
except ValueError as e:
    print(f"例外: {e}")

関連項目：try、except、raise

テスト

プログラムが仕様どおりに動作するかを検証し、バグを発見する作業をテストという。単体テスト、結合テスト、システムテストなどの種類がある。Pythonでは標準ライブラリのunittestモジュール、またはサードパーティのpytestライブラリが使用される。

デバッグ

プログラムのバグを発見し、修正する作業をデバッグという。

関連項目：デバッガ、テスト

デバッガ

プログラムのバグを発見・修正するための支援ツールをデバッガという。ブレークポイントの設定、ステップ実行、変数の監視などの機能を提供する。Pythonでは標準ライブラリのpdbモジュール、またはIDE内蔵のデバッガが使用される。Python 3.7以降ではbreakpoint()組み込み関数でデバッガを起動できる。

数学関数と乱数

三角関数

角度に関する数学関数を三角関数という。mathモジュールで提供される。引数・戻り値の角度の単位はラジアンである。math.sin()（正弦）、math.cos()（余弦）、math.tan()（正接）、math.asin()（逆正弦）、math.acos()（逆余弦）、math.atan()（逆正接）、math.atan2(y, x)（2引数逆正接、象限を考慮）がある。度とラジアンの変換にはmath.radians()とmath.degrees()を使用する。

擬似乱数

数学的アルゴリズムによって生成される、統計的に乱数と同等の性質を持つ数列を擬似乱数という。Pythonではrandomモジュールで生成する。内部ではメルセンヌ・ツイスタ（MT19937）アルゴリズムが使用されている。

import random

x = random.random()        # 0.0以上1.0未満
y = random.randint(1, 100) # 1以上100以下の整数
z = random.choice([1, 2, 3])  # リストからランダムに1要素選択
random.seed(42)             # シードの設定（再現性の確保）

randomモジュールの擬似乱数は暗号論的に安全ではない。暗号目的にはsecretsモジュールを使用する。

関連項目：random()、seed()

Pythonの記号・キーワード等

本セクションでは、Pythonで使用される記号、キーワード、および主要な組み込み関数・標準ライブラリ関数を解説する。

記号

!

Python単独では使用しない。!=（不等価演算子）の一部として使用される。

!=

不等価比較演算子。2つのオペランドが等しくない場合にTrueを返す。

if x != 0:
    print("xは0ではない")

"（ダブルクォート）

文字列リテラルを囲む引用符。シングルクォート（'）と同等に使用できる。3つ連続（"""）で複数行文字列やdocstringを記述する。

#

コメントの開始を示す記号。#から行末までがコメントとして扱われ、実行時に無視される。

%

剰余演算子。除算の余りを返す。古い形式の書式文字列にも使用される。

remainder = 10 % 3  # 1

&

ビット単位のAND演算子。集合（set）の積集合演算子としても使用される。

result = 5 & 3             # ビットAND: 1
a = {1, 2, 3} & {2, 3, 4}  # 積集合: {2, 3}

'（シングルクォート）

文字列リテラルを囲む引用符。ダブルクォート（"）と同等に使用できる。3つ連続（'''）で複数行文字列を記述する。

()

関数呼び出し、タプルの作成、式のグループ化に使用する括弧。

result = func(x, y)  # 関数呼び出し
t = (1, 2, 3)        # タプル
value = (a + b) * c  # グループ化

*

乗算演算子。シーケンスの繰り返し、関数の可変長位置引数（*args）、イテラブルのアンパック演算子としても使用される。

product = 3 * 4             # 乗算: 12
repeated = "ab" * 3         # 繰り返し: "ababab"
def func(*args): pass       # 可変長位置引数
merged = [*list1, *list2]   # アンパック

**

べき乗演算子。関数のキーワード可変長引数（**kwargs）、辞書のアンパックにも使用される。

power = 2 ** 10              # べき乗: 1024
def func(**kwargs): pass     # キーワード可変長引数
merged = {**dict1, **dict2}  # 辞書のアンパック

+

加算演算子。文字列やリストの連結にも使用される。

-

減算演算子および単項マイナス演算子。集合（set）の差集合にも使用される。

->

関数の戻り値の型ヒントを示す記号。

def add(a: int, b: int) -> int:
    return a + b

.

属性アクセス演算子。オブジェクトの属性やメソッドにアクセスする。

my_list.append(4)   # メソッド呼び出し
name = person.name  # 属性アクセス

/

除算演算子。結果は常にfloat型となる。

result = 7 / 2  # 3.5

//

整数除算（切り捨て除算）演算子。結果を負の無限大方向に切り捨てる。

result = 7 // 2    # 3
result = -7 // 2   # -4（負の無限大方向へ切り捨て）

:

ブロックの開始、スライス、辞書のキーと値の区切り、型ヒントに使用される。

if x > 0:             # ブロック開始
    print("positive")
sub = lst[1:3]        # スライス
d = {"key": "value"}  # 辞書
x: int = 10           # 型ヒント

;

複数の文を1行に記述する際の区切り文字。PEP 8では使用は推奨されない。

< <= > >= ==

比較演算子。Pythonでは比較の連鎖が可能である（0 < x < 100は0 < x and x < 100と同等）。

=

代入演算子。変数に値を代入する。Python 3.8以降では:=（セイウチ演算子、walrus operator）で式中での代入も可能。

x = 10
if (n := len(data)) > 10:  # 代入式（Python 3.8以降）
    print(f"長さ: {n}")

@

デコレータの適用に使用される。NumPyなどでは行列乗算演算子としても使用される。

@decorator
def func():
    pass

[]

リストの作成、インデックスアクセス、スライスに使用する括弧。

lst = [1, 2, 3]    # リスト作成
item = lst[0]      # インデックスアクセス: 1
sub = lst[1:3]     # スライス: [2, 3]

\

行継続文字。長い行を複数行に分割する際に使用する。括弧（()、[]、{}）内では不要。文字列内ではエスケープシーケンス（\nなど）の開始を示す。

total = value1 + value2 + \
        value3 + value4

# 括弧内では行継続文字不要
total = (value1 + value2 +
         value3 + value4)

^

ビット単位のXOR演算子。集合（set）の対称差にも使用される。

result = 5 ^ 3             # ビットXOR: 6
a = {1, 2, 3} ^ {2, 3, 4}  # 対称差: {1, 4}

_

使用しない変数の慣用名、対話モードでの直前の結果、数値リテラルの桁区切り、名前マングリング（_name、__name）に使用される。

for _ in range(10):   # 使用しないループ変数
    do_something()
large = 1_000_000     # 桁区切り

{}

辞書および集合の作成に使用する括弧。空の{}は辞書となる。空の集合はset()で作成する。

d = {"name": "Alice", "age": 30}  # 辞書
s = {1, 2, 3}                     # 集合
empty_set = set()                  # 空の集合

|

ビット単位のOR演算子。集合（set）の和集合にも使用される。Python 3.9以降では辞書のマージ演算子としても使用される。

result = 5 | 3            # ビットOR: 7
a = {1, 2} | {3, 4}       # 和集合: {1, 2, 3, 4}

~

ビット単位のNOT演算子。整数のビットを反転する。~xは-(x+1)と等価である。

+= -= *= /= //= %= **=

複合代入演算子。演算と代入を同時に行う。

x += 1    # x = x + 1 と同等
x *= 2    # x = x * 2 と同等

キーワード（アルファベット順）

and

論理積演算子。短絡評価が行われる（第1オペランドが偽なら第2オペランドは評価されない）。厳密には、第1オペランドが偽ならその値を返し、真なら第2オペランドの値を返す。

if x > 0 and y > 0:
    print("両方とも正")

as

import時の別名指定、with文での変数束縛、例外処理での例外オブジェクトの束縛に使用する。

import numpy as np
with open("file.txt") as f:
    content = f.read()

assert

条件が偽の場合にAssertionErrorを発生させるアサーション文。デバッグ目的で使用する。-O（最適化）オプションで実行すると除去されるため、通常のエラー処理には使用すべきでない。

assert x > 0, "xは正の数でなければならない"

async / await

非同期処理のためのキーワード。async defでコルーチン関数を定義し、awaitで非同期処理の完了を待つ。asyncioライブラリと組み合わせて使用する。

import asyncio

async def fetch_data():
    result = await some_async_operation()
    return result

asyncio.run(fetch_data())

break

最も内側のループ（for/while）を中断して脱出するジャンプ文のキーワード。

for i in range(100):
    if i == 10:
        break  # ループを終了

case

match文で個々のパターンを指定するキーワード（Python 3.10以降）。

class

クラスを定義するキーワード。

class Person:
    def __init__(self, name):
        self.name = name

continue

ループの現在の反復をスキップし、次の反復に移るジャンプ文のキーワード。

for i in range(10):
    if i % 2 == 0:
        continue  # 偶数はスキップ
    print(i)      # 奇数のみ出力

def

関数を定義するキーワード。

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

del

オブジェクトへの参照を削除するキーワード。変数、リストの要素、辞書のキーなどを削除できる。オブジェクト自体はガベージコレクタが必要に応じて回収する。

del x          # 変数の削除
del lst[0]     # リストの要素の削除
del d["key"]   # 辞書のキーの削除

elif

if文で複数の条件を順に判定するキーワード。「else if」の短縮形である。

else

if文で条件が偽の場合、for/while文がbreakなしで正常終了した場合、try文で例外が発生しなかった場合のブロックを示すキーワード。

# forのelse：breakされなかった場合のみ実行
for i in range(10):
    if i == target:
        break
else:
    print("見つからなかった")

except

try文で例外を捕捉するキーワード。

try:
    result = x / y
except ZeroDivisionError:
    print("ゼロ除算エラー")
except (TypeError, ValueError) as e:
    print(f"エラー: {e}")

False

ブール型の偽を表すリテラル。intのサブクラスであり、整数値0と等価である。

finally

try文で例外の有無にかかわらず必ず実行されるブロックを示すキーワード。リソースの解放処理などに使用する。

try:
    f = open("file.txt")
    # 処理
finally:
    f.close()  # 例外が発生しても必ず実行

for

イテラブル（リスト、タプル、文字列、range等）の要素を順に処理する繰り返し文のキーワード。

for item in collection:
    print(item)

for i in range(10):
    print(i)

# リスト内包表記
squares = [x ** 2 for x in range(10)]

from

モジュールから特定の要素をインポートする際に使用するキーワード。

from math import sqrt, pi
from collections import defaultdict

global

関数内でグローバルスコープの変数を参照・変更することを宣言するキーワード。global宣言なしでは、関数内での代入はローカル変数の作成となる。グローバル変数の多用は保守性を低下させるため最小限に留めることが推奨される。

count = 0

def increment():
    global count
    count += 1

if

条件分岐のキーワード。条件が真の場合にブロックを実行する。elifで複数条件を、elseで該当なしの場合を処理する。条件式（三項演算子）としても使用できる。

if x > 0:
    print("正の数")
elif x == 0:
    print("ゼロ")
else:
    print("負の数")

result = "正" if x > 0 else "非正"  # 条件式

import

モジュールを読み込むキーワード。

import math
import os.path

関連項目：from、as

in

所属判定演算子。要素がシーケンスや集合に含まれているかを判定する。for文のイテレーション対象の指定にも使用される。

if "a" in "abc":
    print("含まれている")

for x in range(10):
    print(x)

is

同一性判定演算子。2つの変数が同一のオブジェクト（同じメモリ上のオブジェクト）を指しているかを判定する。値の等価性の判定には==を使用する。

if x is None:        # Noneの判定にはisを使用（推奨）
    print("xはNone")

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)   # True（値が等しい）
print(a is b)   # False（別のオブジェクト）

lambda

無名関数（ラムダ式）を作成するキーワード。本体は単一の式のみ。

square = lambda x: x ** 2
sorted_list = sorted(items, key=lambda x: x.name)

match

構造的パターンマッチングのキーワード（Python 3.10以降）。caseで各パターンを指定する。フォールスルー（次のcaseへの暗黙の遷移）は発生しない。

match command:
    case "quit":
        sys.exit()
    case "hello":
        print("Hello!")
    case _:             # ワイルドカードパターン
        print("不明なコマンド")

None

値がないことを表す特殊なシングルトンリテラル。NoneType型の唯一のインスタンスである。関数がreturn文なしで終了した場合の戻り値でもある。判定にはis Noneを使用する（== Noneではなく）。

result = None
if x is None:
    print("値がない")

nonlocal

入れ子の関数内で、外側（ただしグローバルではない）の関数のローカル変数を参照・変更することを宣言するキーワード。

def outer():
    x = 10
    def inner():
        nonlocal x
        x += 1
    inner()
    return x  # 11

関連項目：global、スコープ

not

論理否定演算子。オペランドが真ならFalse、偽ならTrueを返す。

if not found:
    print("見つからない")

or

論理和演算子。短絡評価が行われる（第1オペランドが真なら第2オペランドは評価されない）。厳密には、第1オペランドが真ならその値を返し、偽なら第2オペランドの値を返す。

if x == 0 or y == 0:
    print("どちらかがゼロ")

pass

何もしない文。構文上ブロックが必要だが処理が不要な場合に使用する。

def not_implemented_yet():
    pass

class EmptyClass:
    pass

raise

例外を発生させるキーワード。引数なしのraiseは捕捉した例外の再送出を行う。

if x < 0:
    raise ValueError("xは負の数であってはならない")

# 例外の再送出
try:
    risky_operation()
except Exception:
    print("エラー発生")
    raise

return

関数から値を返すジャンプ文のキーワード。引数なしの場合はNoneを返す。複数の値をタプルとして返すことができる。

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

def divide(a, b):
    return a // b, a % b  # タプルで返す

True

ブール型の真を表すリテラル。intのサブクラスであり、整数値1と等価である。

try

例外処理のブロックを開始するキーワード。except、else、finallyと組み合わせて使用する。

try:
    result = risky_operation()
except ValueError as e:
    print(f"値エラー: {e}")    # ValueError発生時
except Exception as e:
    print(f"エラー: {e}")      # その他の例外
else:
    print("成功")              # 例外なしの場合
finally:
    print("後処理")            # 常に実行

while

条件が真の間、処理を繰り返すキーワード。無限ループはwhile True:で記述し、breakで脱出する。

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

with

コンテキストマネージャを使用するキーワード。リソースの確保と解放を自動化する。__enter__と__exit__メソッドを持つオブジェクトに対して使用できる。ファイル操作で推奨される方法である。

with open("file.txt", "r") as f:
    content = f.read()
# ブロック終了時にf.close()が自動的に呼ばれる

yield

ジェネレータ関数で値を生成するキーワード。関数の実行状態を保持したまま値を返し、次回の呼び出しで続きから実行を再開する。yieldを含む関数はジェネレータ関数となり、呼び出すとジェネレータイテレータを返す。returnと異なり、関数の状態が保持される。

def count_up(n):
    for i in range(n):
        yield i

for num in count_up(5):
    print(num)  # 0, 1, 2, 3, 4

組み込み関数・標準ライブラリ関数（アルファベット順）

abs()

数値の絶対値を返す組み込み関数。整数、浮動小数点数、複素数に対応する。

abs(-10)    # 10
abs(-3.14)  # 3.14
abs(3+4j)   # 5.0（複素数の絶対値＝原点からの距離）

acos()

逆コサイン（アークコサイン）をラジアンで返す関数。mathモジュールで提供される。引数は-1.0から1.0の範囲。

import math
math.acos(0.5)  # 1.0471975511965979（≒ π/3）

asin()

逆サイン（アークサイン）をラジアンで返す関数。mathモジュールで提供される。引数は-1.0から1.0の範囲。

import math
math.asin(0.5)  # 0.5235987755982989（≒ π/6）

atan()

逆タンジェント（アークタンジェント）をラジアンで返す関数。mathモジュールで提供される。2引数版のmath.atan2(y, x)は象限を正しく判定する。

import math
math.atan(1)  # 0.7853981633974483（≒ π/4）

chr()

Unicodeコードポイント（整数）に対応する文字を返す組み込み関数。逆変換はord()。

chr(65)     # 'A'
chr(12354)  # 'あ'
ord('A')    # 65

close()

ファイルオブジェクトを閉じるメソッド。with文を使用すると自動的にクローズされるため、明示的な呼び出しは通常不要である。

cos()

コサイン（余弦）を計算する関数。mathモジュールで提供される。引数はラジアン。

import math
math.cos(0)        # 1.0
math.cos(math.pi)  # -1.0

exit() / sys.exit()

プログラムを終了する関数。sys.exit()はSystemExit例外を送出することでプログラムを終了する。引数0は正常終了、0以外はエラー終了を示す。対話モードのexit()はsiteモジュールが提供する便利関数であり、スクリプト内ではsys.exit()を使用する。

import sys
sys.exit(0)  # 正常終了
sys.exit(1)  # エラー終了

exp()

指数関数（e^x）を計算する関数。mathモジュールで提供される。

import math
math.exp(1)   # 2.718281828459045（≒ e）
math.exp(2)   # 7.38905609893065（≒ e²）

float

浮動小数点数型。内部的にはIEEE 754倍精度で実装されている。コンストラクタとして文字列や整数からfloat値を生成する。

x = 3.14
y = float("3.14")   # 文字列からの変換
z = float(10)        # 整数からの変換: 10.0
inf = float("inf")   # 正の無限大
nan = float("nan")   # 非数（Not a Number）

fmod()

浮動小数点数の剰余を計算する関数。mathモジュールで提供される。%演算子と異なり、結果の符号は被除数（第1引数）と同じになる。

import math
math.fmod(7.5, 2.0)   # 1.5
math.fmod(-7.5, 2.0)  # -1.5

input() / sys.stdin

標準入力から読み込む方法。input()は1行を文字列として読み込む（末尾の改行は除去される）。sys.stdinはファイルオブジェクトとしてアクセスできる。

name = input("名前を入力: ")

import sys
for line in sys.stdin:  # 標準入力を1行ずつ読み込み
    print(line.rstrip())

int

整数型。Pythonのint型は任意精度であり、桁数の制限がない。コンストラクタとして文字列や浮動小数点数からint値を生成する。

x = 10
y = int("42")       # 文字列からの変換
z = int(3.14)        # 小数部切り捨て: 3
b = int("ff", 16)    # 16進数文字列からの変換: 255
large = 10 ** 100    # 任意の大きさの整数

len()

オブジェクトの長さ（要素数）を返す組み込み関数。__len__メソッドを持つオブジェクトに使用できる。

len("Hello")       # 5
len([1, 2, 3])     # 3
len({"a": 1})      # 1

log()

対数を計算する関数。mathモジュールで提供される。引数が1つの場合は自然対数、2つの場合は第2引数を底とする対数を計算する。math.log10()（常用対数）、math.log2()（2を底とする対数）は専用関数。

import math
math.log(math.e)     # 1.0（ln(e)）
math.log(100, 10)    # 2.0（log₁₀(100)）
math.log10(100)      # 2.0
math.log2(8)         # 3.0

open()

ファイルを開く組み込み関数。ファイルオブジェクトを返す。主な引数はfile（ファイルパス）、mode（オープンモード）、encoding（文字エンコーディング）。テキストモードではencodingの明示的な指定が推奨される。

# 推奨される方法（with文との組み合わせ）
with open("file.txt", "r", encoding="utf-8") as f:
    content = f.read()

print()

標準出力に出力する組み込み関数。主な引数はsep（区切り文字、デフォルトは空白）、end（末尾文字、デフォルトは改行）、file（出力先、デフォルトはsys.stdout）。

print("Hello, World!")
print(f"{name}は{age}歳です")  # f-stringと組み合わせ
print(value, end="")           # 改行なし
print(a, b, c, sep=", ")      # 区切り文字指定

random()

0.0以上1.0未満の擬似乱数（浮動小数点数）を生成する関数。randomモジュールで提供される。

import random
x = random.random()           # 0.0以上1.0未満
y = random.randint(1, 10)     # 1以上10以下の整数
z = random.choice([1, 2, 3])  # ランダムに選択
w = random.uniform(0, 100)    # 0以上100以下の浮動小数点数

read() / readline()

ファイルから読み込むメソッド。read()は全体または指定文字数（バイト数）を、readline()は1行を読み込む。readlines()は全行をリストとして返す。

with open("file.txt") as f:
    content = f.read()       # ファイル全体
    f.seek(0)                # 先頭に戻す
    line = f.readline()      # 1行
    lines = f.readlines()    # 残り全行をリストで

seed()

擬似乱数のシードを設定する関数。randomモジュールで提供される。同じシードを設定すると同じ乱数列が生成されるため、結果の再現性を確保する際に使用する。

import random
random.seed(42)
print(random.random())  # 常に同じ値が得られる

seek() / tell()

ファイルの読み書き位置を操作するメソッド。seek(offset, whence)は位置を変更し、tell()は現在位置を返す。whenceの値は、0（先頭基準、デフォルト）、1（現在位置基準）、2（終端基準）である。whenceが1または2の場合はバイナリモードが必要である。

with open("file.txt", "rb") as f:
    f.seek(10)         # 先頭から10バイト目へ
    f.seek(5, 1)       # 現在位置から5バイト後へ
    f.seek(-10, 2)     # 終端から10バイト前へ
    pos = f.tell()     # 現在位置を取得

sin()

サイン（正弦）を計算する関数。mathモジュールで提供される。引数はラジアン。

import math
math.sin(0)             # 0.0
math.sin(math.pi / 2)   # 1.0

sqrt()

平方根を計算する関数。mathモジュールで提供される。

import math
math.sqrt(4)    # 2.0
math.sqrt(2)    # 1.4142135623730951

tan()

タンジェント（正接）を計算する関数。mathモジュールで提供される。引数はラジアン。

import math
math.tan(0)             # 0.0
math.tan(math.pi / 4)   # 0.9999999999999999（≒ 1.0）

write()

ファイルに文字列を書き込むメソッド。書き込んだ文字数を返す。print()と異なり、自動的な改行の付加は行われない。

with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello, World!\n")
    name = "Alice"
    age = 30
    f.write(f"{name}は{age}歳です\n")

索引

あ行

アクセス、 アドレス、 入れ子、 イテラブル、 インクリメント、 エディタ、 エラー、 演算子、 オーバーフロー、 オープンモード、 オペランド

か行

改行・改行文字、 型、 型変換関数 / split()、 仮引数、 関数、 間接参照、 ガベージコレクション、 偽、 擬似乱数、 逆アセンブル、 クラス、 繰り返し、 コーディング、 構造体、 コンテキストマネージャ、 コマンドラインシェル、 コメント、 コンパイル

さ行

再帰的呼び出し、 三角関数、 参照による呼び出し・値による呼び出し、 式、 識別子、 自己参照構造体、 字下げ、 辞書、 実行形式ファイル、 ジャンプ文、 集合、 初期化、 書式文字列、 ジェネレータ、 真、 数字、 スコープ、 算術、 制御文、 宣言、 選択文、 ソースファイル、 ソースプログラム

た行

タプル、 データ構造、 テキストファイル、 テスト、 デバッガ、 デバッグ、 デクリメント、 デコレータ、 定数、 動的メモリ管理、 ドキュメンテーション文字列（docstring）

な行

NULLポインタ、 ヌル文字

は行

バイト、 配列、 ハノイの塔、 引数（実引数）、 評価、 標準出力・標準入力、 ファイル、 プログラム、 プログラミング、 プログラミング言語、 プログラミング言語のシェル（REPL）、 プログラミング言語処理系、 プログラミングスタイル、 プロセッサ、 ブロック、 文、 変数、 ポインタ

ま行

メイン処理、 メモリ、 メンバ、 文字型、 文字列データ、 モジュール

や行

予約語

ら行

例外、 ループ→繰り返しを参照

その他

Python仮想マシンコード

記号

!、 !=、 "、 #、 %、 &、 '、 ()、 *、 **、 +、 -、 ->、 .、 /、 //、 :、 ;、 < <= == > >=、 =、 @、 []、 \、 ^、 _、 {}、 |、 ~、 += -= *= /= //= %= **=

キーワード

and、 as、 assert、 async/await、 break、 case、 class、 continue、 def、 del、 elif、 else、 except、 False、 finally、 for、 from、 global、 if、 import、 in、 is、 lambda、 match、 None、 nonlocal、 not、 or、 pass、 raise、 return、 True、 try、 while、 with、 yield

組み込み関数・標準ライブラリ関数

abs()、 acos()、 asin()、 atan()、 chr()、 close()、 cos()、 exit()/sys.exit()、 exp()、 float、 fmod()、 input()/sys.stdin、 int、 len()、 log()、 open()、 print()、 random()、 read()/readline()、 seed()、 seek()/tell()、 sin()、 sqrt()、 tan()、 write()