2. 字句解析¶

Python プログラムは パーザ によって読み取られます。パーザへの入力は、字句解析器 (または トークナイザ) が生成したトークンの列です。この章では、字句解析器がこれらのトークンを生成する方法を説明します。

字句解析器はプログラムのテキストのエンコーディング (デフォルトは UTF-8) を判定し、テキストをソース文字にデコードします。デコードできない場合は SyntaxError を送出します。

次に、字句解析器はソース文字からトークン列を生成します。生成するトークンの種類は、一般に次に処理するソース文字によって決まります。同様に、字句解析器のその他の特別な動作も、まだ処理していない最初のソース文字によって決まります。次の表はこうしたソース文字の概要と、詳細を説明する節へのリンクを示します。

文字	次のトークン (またはその他の関連する説明)
空白タブフォームフィード	空白
CR、LF	改行インデント
バックスラッシュ (`\`)	明示的な行継続 (文字列のエスケープシーケンスでも意味を持ちます)
ハッシュ (`#`)	コメント
引用符 (`'`、`"`)	文字列リテラル
ASCII の英字 (`a`-`z`、`A`-`Z`) 非 ASCII 文字	名前接頭辞付きの文字列リテラルまたはバイト列リテラル
アンダースコア (`_`)	名前 (数値リテラルの一部にもなります)
数字 (`0`-`9`)	数値リテラル
ドット (`.`)	数値リテラル演算子
疑問符 (`?`) ドル記号 (`$`) バッククォート (`) 制御文字	エラー (文字列リテラルとコメントの外側の場合)
その他の表示可能文字	演算子またはデリミタ
ファイルの終端	終端マーカー

2.1. 行構造¶

Python プログラムは多数の 論理行 (logical lines) に分割されます。

2.1.1. 論理行 (logical line)¶

論理行の終端は NEWLINE トークンで表されます。構文上 NEWLINE が許される場合 (例えば複合文の中の文と文の間) を除き、文は論理行の境界を越えられません。論理行は、明示的または非明示的な 行継続 の規則に従って、1 行以上の 物理行 から構成されます。

2.1.2. 物理行 (physical line)¶

物理行は、次のいずれかの行末シーケンスで終わる文字列です。

ASCII の LF (ラインフィード) を使う Unix 形式。
ASCII の CR LF (キャリッジリターンに続くラインフィード) を使う Windows 形式。
ASCII の CR (キャリッジリターン) を使う Classic Mac OS 形式。

プラットフォームにかかわらず、これらのシーケンスはいずれも 1 個の ASCII LF (ラインフィード) 文字に置き換えられます。 (文字列リテラルの中でも置き換えます。) 各行でどのシーケンスを使ってもよく、ファイル内で統一する必要はありません。

入力の終端も、最後の物理行の暗黙の終端となります。

形式的には次のように定義します。

newline: <ASCII LF> | <ASCII CR> <ASCII LF> | <ASCII CR>

2.1.3. コメント (Comments)¶

コメントは文字列リテラル内に入っていないハッシュ文字 (#) から始まり、同じ物理行の末端で終わります。非明示的な行継続規則が適用されていない限り、コメントは論理行を終端させます。コメントは構文上無視されます。

2.1.4. エンコード宣言 (encoding declaration)¶

Python スクリプト中の一行目か二行目にあるコメントが正規表現 coding[=:]\s*([-\w.]+) にマッチする場合、コメントはエンコード宣言として処理されます; この表現の最初のグループがソースコードファイルのエンコードを指定します。エンコード宣言は自身の行になければなりません。二行目にある場合、一行目もコメントのみの行でなければなりません。エンコード宣言式として推奨する形式は

# -*- coding: <encoding-name> -*-

これは GNU Emacs で認識できます。または

# vim:fileencoding=<encoding-name>

これは、Bram Moolenar による VIM が認識できる形式です。

エンコード宣言が見つからなければ、デフォルトのエンコーディングは UTF-8 です。ファイルのエンコーディングが暗黙的または明示的に UTF-8 となっている場合、先頭の UTF-8 バイトオーダーマーク (b'\xef\xbb\xbf') は構文エラーにならず、無視されます。

エンコーディングが宣言される場合、そのエンコーディング名は Python によって認識できなければなりません (標準エンコーディングを参照してください)。宣言されたエンコーディングは、例えば文字列リテラル、コメント、識別子などの、全ての字句解析に使われます。

文字列リテラル、コメント、識別子を含め、すべての字句解析はソースのエンコーディングでデコードした Unicode テキストに対して行われます。 Python のソースには、NUL 制御文字を除く任意の Unicode コードポイントを含められます。

source_character:  <any Unicode code point, except NUL>

2.1.5. 明示的な行継続¶

二つまたはそれ以上の物理行を論理行としてつなげるためには、バックスラッシュ文字 (\) を使って以下のようにします: 物理行が文字列リテラルやコメント中の文字でないバックスラッシュで終わっている場合、後続する行とつなげて一つの論理行を構成し、バックスラッシュおよびバックスラッシュの後ろにある行末文字を削除します。例えば:

if 1900 < year < 2100 and 1 <= month <= 12 \
   and 1 <= day <= 31 and 0 <= hour < 24 \
   and 0 <= minute < 60 and 0 <= second < 60:   # 有効な日時のように見える
        return 1

バックスラッシュで終わる行にはコメントを入れることはできません。また、バックスラッシュを使ってコメントを継続することはできません。バックスラッシュが文字列リテラル中にある場合を除き、バックスラッシュの後ろにトークンを継続することはできません (すなわち、物理行内の文字列リテラル以外のトークンをバックスラッシュを使って分断することはできません)。上記以外の場所では、文字列リテラル外にあるバックスラッシュはどこにあっても不正となります。

2.1.6. 非明示的な行継続¶

丸括弧、角括弧、波括弧の中の式は、バックスラッシュを使わずに複数の物理行に分割できます。例えば次のように書きます。

month_names = ['Januari', 'Februari', 'Maart',      # これらは
               'April',   'Mei',      'Juni',       # オランダ語の
               'Juli',    'Augustus', 'September',  # 各月の
               'Oktober', 'November', 'December']   # 名前

非明示的に継続された行にはコメントを含めることができます。継続行のインデントは重要ではありません。空の継続行を書くことができます。非明示的な継続行中には、NEWLINE トークンは存在しません。非明示的な行の継続は、三重クオートされた文字列 (下記参照) でも発生します; この場合には、コメントを含めることができません。

2.1.7. 空行¶

スペース、タブ、フォームフィードと、省略可能なコメントだけを含む論理行は無視されます (つまり NEWLINE トークンは生成されません)。対話的に文を入力する場合、空行の扱いは読み込み・評価・表示ループの実装によって異なる場合があります。標準の対話型インタープリタでは、完全に空の論理行 (空白もコメントも含まない行) が複数行の文を終端させます。

2.1.8. インデント¶

論理行の行頭にある、先頭の空白 (スペースおよびタブ) の連なりは、その行のインデントレベルを計算するために使われます。インデントレベルは、実行文のグループ化方法を決定するために用いられます。

タブは左から右へ、置き換えた部分までの文字数が 8 の倍数になるように、1 個から 8 個のスペースに置き換えられます (Unix と同じ規則を意図しています)。最初の非空白文字より前にあるスペースの総数で、その行のインデントが決まります。インデントをバックスラッシュで複数の物理行に分割することはできません。最初のバックスラッシュまでの空白がインデントを決めます。

ソースファイルがタブとスペースを混在させ、その意味づけがタブのスペース換算数に依存するようなら、インデントは不合理なものとして却下されます。その場合は TabError が送出されます。

プラットフォーム間の互換性に関する注意: 非 UNIX プラットフォームのテキストエディタの性質上、1 つのソースファイルのインデントにスペースとタブを混在させるのは避けるべきです。また、プラットフォームによっては最大インデントレベルを明示的に制限している場合があります。

フォームフィード文字が行の先頭にあっても構いません; フォームフィード文字は上のインデントレベル計算時には無視されます。フォームフィード文字が先頭の空白中の他の場所にある場合、その影響は未定義です (例えば、スペースの数を 0 にリセットするかもしれません)。

連続する行のインデントレベルから、スタックを使って INDENT トークンと DEDENT トークンを次のように生成します。

ファイルの最初の行を読む前に、スタックに 0 を 1 個積みます。この 0 を取り除くことはありません。スタックに積まれた数値は、常に下から上へ厳密に増加します。各論理行の先頭で、その行のインデントレベルをスタックの最上部と比較します。等しければ何もしません。大きければその値をスタックに積み、INDENT トークンを 1 個生成します。小さければ、その値はスタック内のいずれかの数値と一致しなければ なりません。その値より大きい数値をすべてスタックから取り除き、取り除いた数値ごとに DEDENT トークンを 1 個生成します。ファイルの終端では、スタックに残っている 0 より大きい数値ごとに DEDENT トークンを 1 個生成します。

以下の例に正しく (しかし当惑させるように) インデントされた Python コードの一部を示します:

def perm(l):
        # l のすべての順列のリストを計算する
    if len(l) <= 1:
                  return [l]
    r = []
    for i in range(len(l)):
             s = l[:i] + l[i+1:]
             p = perm(s)
             for x in p:
              r.append(l[i:i+1] + x)
    return r

以下の例は、様々なインデントエラーになります:

 def perm(l):                       # エラー: 最初の行がインデントされている
for i in range(len(l)):             # エラー: インデントされていない
    s = l[:i] + l[i+1:]
        p = perm(l[:i] + l[i+1:])   # エラー: 予期しないインデント
        for x in p:
                r.append(l[i:i+1] + x)
            return r                # エラー: インデントの戻し方が不整合

(実際は、最初の 3 つのエラーはパーザによって検出されます; 最後のエラーのみが字句解析器で見つかります --- return r のインデントは、スタックから逐次除去されていくどのインデントレベル値とも一致しません)

2.1.9. トークン間の空白¶

論理行の先頭と文字列リテラルの中を除き、空白文字のスペース、タブ、フォームフィードは、どれも同じようにトークンの区切りに使えます。

whitespace:  ' ' | tab | formfeed

2 つのトークンの間に空白が必要なのは、連結すると別のトークンとして解釈される可能性がある場合だけです。例えば ab は 1 個のトークンですが、a b は 2 個のトークンです。一方、+a は有効なトークンではないため、+a と + a はどちらも + と a という 2 個のトークンになります。

2.1.10. 終端マーカー¶

非対話的な入力の終端で、字句解析器は ENDMARKER トークンを生成します。

2.2. その他のトークン¶

NEWLINE、INDENT、DEDENT のほかに、識別子 と キーワード (NAME)、リテラル (NUMBER や STRING など)、その他の記号 (演算子 と デリミタ、OP) という種類のトークンがあります。空白文字は、前述の論理行の終端を除いてトークンではなく、トークンを区切る役割を持ちます。曖昧さがある場合は、左から右に読んだときに有効なトークンとなる最長の文字列を 1 個のトークンとします。

2.3. 名前 (識別子とキーワード)¶

NAME トークンは 識別子、キーワード、ソフトキーワード を表します。

名前は次の文字から構成されます。

大文字と小文字の英字 (A-Z と a-z)。
アンダースコア (_)。
数字 (0 から 9)。ただし先頭の文字には使えません。
非 ASCII 文字。有効な名前に含められるのは「文字に類する」文字と「数字に類する」文字だけです。詳細は名前に含まれる非 ASCII 文字を参照してください。

名前には少なくとも 1 文字が必要ですが、長さに上限はありません。大文字と小文字は区別されます。

形式的には、名前は次の字句定義で表されます。

NAME:          name_start name_continue*
name_start:    "a"..."z" | "A"..."Z" | "_" | <non-ASCII character>
name_continue: name_start | "0"..."9"
identifier:    <NAME, except keywords>

この文法に一致する名前がすべて有効なわけではありません。詳細は名前に含まれる非 ASCII 文字を参照してください。

2.3.1. キーワード (keyword)¶

次の名前は言語の予約語、すなわち キーワード として使われ、通常の識別子としては使えません。ここに示すとおりに綴る必要があります。

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

2.3.2. ソフトキーワード¶

Added in version 3.10.

特定の文脈でだけ予約される名前もあります。これらを ソフトキーワード と呼びます。

match 文の中で使われる match、case、_。
type 文の中で使われる type。
import 文の前で使われる lazy。

これらは特定の文脈では構文上キーワードとして働きますが、この区別はトークン化の段階ではなく、パーザで行います。

ソフトキーワードにすることで、これらの名前を識別子として使う既存のコードとの互換性を保ちながら、文法の一部として使えます。

バージョン 3.12 で変更: type がソフトキーワードになりました。

バージョン 3.15 で変更: lazy がソフトキーワードになりました。

2.3.3. 予約済みの識別子種 (reserved classes of identifiers)¶

ある種の (キーワードを除く) 識別子には、特殊な意味があります。これらの識別子種は、先頭や末尾にあるアンダースコア文字のパターンで区別されます:

_*

Not imported by from module import *.

_

match 文の case パターンの中で、_ はワイルドカードを表すソフトキーワードです。

これとは別に、対話型インタープリタでは最後の評価結果を変数 _ で参照できます。 (print などの組み込み関数と同じく、builtins モジュールに格納されます。)

それ以外の場所では、_ は通常の識別子です。「特別な」ものの名前によく使われますが、Python 自体が特別に扱うわけではありません。

注釈

名前 _ は、しばしば国際化 (internationalization) と共に用いられます; この慣習についての詳しい情報は、 gettext を参照してください。

使わない変数の名前にもよく使われます。

__*__

システムで定義された名前で、非公式には "dunder" 名と呼ばれます (double underscores の略)。これらはインタープリタとその実装 (標準ライブラリを含む) が定義します。現在のシステム定義の名前については特殊メソッド名などで説明しています。 Python の将来のバージョンでは、さらに多くの名前が定義される可能性があります。明示的に文書化された用法に従わない __*__ 名の あらゆる 使用は、どの文脈であっても、予告なく動作しなくなる可能性があります。

__*

クラスプライベート (class-private) な名前です。このカテゴリに属する名前は、クラス定義のコンテキスト上で用いられた場合、基底クラスと派生クラスの "プライベートな" 属性間で名前衝突が起こるのを防ぐために書き直されます。識別子 (identifier、または名前 (name)) を参照してください。

2.3.4. 名前に含まれる非 ASCII 文字¶

非 ASCII 文字を含む名前には、前述の規則や文法に加えて正規化と妥当性の検証が必要です。例えば ř_1、蛇、साँप は有効な名前ですが、r〰2、€、🐍 は無効です。

この節では厳密な規則を説明します。

解析時にすべての名前を normalization form NFKC に変換します。このため、例えば文字の一部の字形の違いは「基本的な」形に置き換えられます。 ﬁⁿₐˡᵢᶻₐᵗᵢᵒₙ は finalization に正規化されるため、Python はこれらを同じ名前として扱います。

>>> ﬁⁿₐˡᵢᶻₐᵗᵢᵒₙ = 3
>>> finalization
3

注釈

正規化を行うのは字句のレベルだけです。名前を 文字列 として受け取る実行時の関数は、一般に引数を正規化しません。例えば、上で定義した変数には、実行時に globals() の辞書を使って globals()["finalization"] でアクセスできますが、globals()["ﬁⁿₐˡᵢᶻₐᵗᵢᵒₙ"] ではアクセスできません。

ASCII だけの名前が英字、数字、アンダースコアだけを含み、数字では始められないのと同様に、有効な名前の先頭は「文字に類する」文字の集合 xid_start に属し、残りの文字は「文字や数字に類する」文字の集合 xid_continue に属する必要があります。

これらの集合は、Unicode 標準の付属書 UAX-31 が定義する XID_Start と XID_Continue に基づきます。 Python の xid_start はこれにアンダースコア (_) を加えたものです。 Python が必ずしも UAX-31 に準拠しているわけではないことに注意してください。

Unicode が定義する XID_Start と XID_Continue の文字の一覧は、Unicode 文字データベースの DerivedCoreProperties.txt ファイルで参照できますが、この一覧は規範的な定義ではありません。参考として、xid_* の集合を構成する規則を以下に示します。

集合 id_start は、次の集合の和集合として定義されます。

Unicode カテゴリ <Lu> — 大文字 (A から Z を含む)
Unicode カテゴリ <Ll> — 小文字 (a から z を含む)
Unicode カテゴリ <Lt> — タイトルケース文字
Unicode カテゴリ <Lm> — 修飾文字
Unicode カテゴリ <Lo> — その他の文字
Unicode カテゴリ <Nl> — 数値を表す文字
{"_"} — アンダースコア
<Other_ID_Start> — 後方互換性のために PropList.txt で明示的に指定された文字の集合

次に、正規化した結果が id_start id_continue* の形にならない文字をすべて除き、NFKC 正規化に関して閉じた集合 xid_start を作ります。

集合 id_continue は、次の集合の和集合として定義されます。

id_start (前述)
Unicode カテゴリ <Nd> — 10 進数字 (0 から 9 を含む)
Unicode カテゴリ <Pc> — 連結用の句読点
Unicode カテゴリ <Mn> — 幅を持たない結合文字
Unicode カテゴリ <Mc> — 幅を持つ結合文字
<Other_ID_Continue> — 後方互換性のために PropList.txt で明示的に指定された別の文字の集合

同様に、この集合を NFKC 正規化に関して閉じたものが xid_continue です。

Unicode カテゴリには、unicodedata モジュールが含むバージョンの Unicode 文字データベースを使います。

参考

PEP 3131 — 非 ASCII 識別子のサポート
PEP 672 — Python の Unicode に関するセキュリティ上の考慮事項

2.4. リテラル¶

リテラル (literal) とは、いくつかの組み込み型の定数を表記したものです。

字句解析の観点では、Python のリテラルには文字列、バイト列、数値があります。

その他の「リテラル」は、字句上はキーワード (None、True、False) や特別な省略記号トークン (...) で表されます。

2.5. 文字列およびバイト列リテラル¶

文字列リテラルは、シングルクォート (') またはダブルクォート (") で囲んだテキストです。例えば次のように書きます。

"spam"
'eggs'

リテラルを開始した引用符が終端にもなるため、文字列リテラルの中にはもう一方の引用符だけを含められます (後述のエスケープシーケンスを使う場合を除きます)。例えば次のように書きます。

'Say "Hello", please.'
"Don't do that!"

この制限を除けば、引用符 (' または ") の選択によってリテラルの解析方法が変わることはありません。

文字列リテラルの中のバックスラッシュ (\) は エスケープシーケンス の始まりを示し、後に続く文字に応じた特別な意味を持ちます。例えば \" はダブルクォート文字を表し、文字列を終端させることは ありません。

>>> print("Say \"Hello\" to everyone!")
Say "Hello" to everyone!

エスケープシーケンスの全一覧と詳細は、後述のエスケープシーケンスを参照してください。

2.5.1. 三重クォート文字列¶

文字列は、シングルクォートまたはダブルクォートを 3 個ずつ並べた組で囲むこともできます。一般に 三重クォート文字列 と呼びます。

"""This is a triple-quoted string."""

三重クォートのリテラルには、エスケープされていない引用符を含められ、そのまま保持されます。ただし、開始時と同じ種類の引用符 (' または ") がエスケープされずに 3 個連続すると、リテラルは終端します。

"""This string has "quotes" inside."""

エスケープされていない改行も含められ、そのまま保持されます。

'''This triple-quoted string
continues on the next line.'''

2.5.2. 文字列の接頭辞¶

文字列リテラルには、内容の解析方法を変える 接頭辞 を付けられます。例えば次のように書きます。

b"data"
f'{result=}'

使える接頭辞は次のとおりです。

b: バイト列リテラル
r: raw 文字列
f: フォーマット済み文字列リテラル ("f-string")
t: テンプレート文字列リテラル ("t-string")
u: 効果なし (後方互換性のために使用可能)

それぞれの種類の詳細は、リンク先の節を参照してください。

接頭辞は大文字と小文字を区別しません (例えば「B」は「b」と同じように動作します)。接頭辞「r」は「f」、「t」、「b」と組み合わせられるため、「fr」、「rf」、「tr」、「rt」、「br」、「rb」も有効な接頭辞です。

Added in version 3.3: raw バイト列リテラルの 'rb' プレフィックスが 'br' の同義語として追加されました。

Python 2.x と 3.x 両対応のコードベースのメンテナンスを単純化するために、レガシー unicode リテラル (u'value') のサポートが再び導入されました。詳細は PEP 414 を参照してください。

2.5.3. 形式文法¶

"f-string" と "t-string" を除く文字列リテラルは、次の字句定義で表されます。

これらの定義では、否定先読み (!) を使って、終わりの引用符がリテラルを終端させることを示しています。

STRING:          [stringprefix] (stringcontent)
stringprefix:    <("r" | "u" | "b" | "br" | "rb"), case-insensitive>
stringcontent:
   | "'''" ( !"'''" longstringitem)* "'''"
   | '"""' ( !'"""' longstringitem)* '"""'
   | "'" ( !"'" stringitem)* "'"
   | '"' ( !'"' stringitem)* '"'
stringitem:      stringchar | stringescapeseq
stringchar:      <any source_character, except backslash and newline>
longstringitem:  stringitem | newline
stringescapeseq: "\" <any source_character>

すべての字句定義と同様に、空白にも意味があることに注意してください。特に、接頭辞を付ける場合はその直後に開始の引用符を置く必要があります。

2.5.4. エスケープシーケンス¶

接頭辞「r」または「R」がない場合、文字列リテラルとバイト列リテラルのエスケープシーケンスは、標準 C と同様の規則に従って解釈されます。認識されるエスケープシーケンスは次のとおりです。

エスケープシーケンス	意味
`\`<newline>	行末の無視
`\\`	バックスラッシュ
`\'`	シングルクォート
`\"`	ダブルクォート
`\a`	ASCII 端末ベル (BEL)
`\b`	ASCII バックスペース (BS)
`\f`	ASCII フォームフィード (FF)
`\n`	ASCII 行送り (LF)
`\r`	ASCII 復帰 (CR)
`\t`	ASCII 水平タブ (TAB)
`\v`	ASCII 垂直タブ (VT)
`\ooo`	8 進数で指定する文字
`\xhh`	16 進数で指定する文字
`\N{name}`	名前で指定する Unicode 文字
`\uxxxx`	16 進数で指定する Unicode 文字
`\Uxxxxxxxx`	16 進数で指定する Unicode 文字

2.5.4.1. 行末の無視¶

行末にバックスラッシュを付けると、改行を無視できます。

>>> 'This string will not include \
... backslashes or newline characters.'
'This string will not include backslashes or newline characters.'

三重クォート文字列や、丸括弧と文字列リテラルの連結を使っても同じ結果を得られます。

2.5.4.2. 文字のエスケープ¶

raw ではない Python の文字列リテラルにバックスラッシュを含めるには、2 個重ねる必要があります。エスケープシーケンス \\ は 1 個のバックスラッシュを表します。

>>> print('C:\\Program Files')
C:\Program Files

同様に、\' と \" はそれぞれシングルクォートとダブルクォートを表します。

>>> print('\' and \"')
' and "

2.5.4.3. 8 進数で指定する文字¶

シーケンス \ooo は、8 進数の値 ooo を持つ文字を表します。

>>> '\120'
'P'

8 進数字 (0 から 7) を最大 3 桁まで指定できます。

バイト列リテラルでは、文字は指定された値を持つ バイト を意味します。文字列リテラルでは、指定された値を持つ Unicode 文字を意味します。

バージョン 3.11 で変更: 値が 0o377 (255) を超える 8 進エスケープは DeprecationWarning を出します。

バージョン 3.12 で変更: 値が 0o377 (255) を超える 8 進エスケープは SyntaxWarning を出します。将来の Python バージョンでは SyntaxError を送出するようになります。

2.5.4.4. 16 進数で指定する文字¶

シーケンス \xhh は、16 進数の値 hh を持つ文字を表します。

>>> '\x50'
'P'

標準 C とは違い、ちょうど 2 桁の 16 進数しか受理されません。

バイト列リテラルでは、文字は指定された値を持つ バイト を意味します。文字列リテラルでは、指定された値を持つ Unicode 文字を意味します。

2.5.4.5. 名前で指定する Unicode 文字¶

シーケンス \N{name} は、指定された name を持つ Unicode 文字を表します。

>>> '\N{LATIN CAPITAL LETTER P}'
'P'
>>> '\N{SNAKE}'
'🐍'

このシーケンスはバイト列リテラルには使えません。

バージョン 3.3 で変更: 名前の別名をサポートしました。

2.5.4.6. 16 進数で指定する Unicode 文字¶

シーケンス \uxxxx と \Uxxxxxxxx は、指定された 16 進数の値を持つ Unicode 文字を表します。 \u にはちょうど 4 桁、\U にはちょうど 8 桁が必要です。後者は任意の Unicode 文字を表せます。

>>> '\u1234'
'ሴ'
>>> '\U0001f40d'
'🐍'

これらのシーケンスはバイト列リテラルには使えません。

2.5.4.7. 認識されないエスケープシーケンス¶

標準 C と異なり、認識されないエスケープシーケンスは文字列内にそのまま残ります。つまり、結果にバックスラッシュが残ります。

>>> print('\q')
\q
>>> list('\q')
['\\', 'q']

バイト列リテラルでは、文字列リテラルでだけ認識されるエスケープシーケンス (\N...、\u...、\U...) も、認識されないエスケープに分類されます。

バージョン 3.6 で変更: 認識されないエスケープシーケンスは DeprecationWarning を出します。

バージョン 3.12 で変更: 認識されないエスケープシーケンスは SyntaxWarning を出します。将来の Python バージョンでは SyntaxError を送出するようになります。

2.5.5. バイト列リテラル¶

バイト列リテラル は常に接頭辞「b」または「B」を持ち、str 型ではなく bytes 型のインスタンスを生成します。リテラルに直接含められるのは ASCII 文字だけです。数値が 128 以上のバイトは、エスケープシーケンス (通常は 16 進数で指定する文字または 8 進数で指定する文字) で表す必要があります。

>>> b'\x89PNG\r\n\x1a\n'
b'\x89PNG\r\n\x1a\n'
>>> list(b'\x89PNG\r\n\x1a\n')
[137, 80, 78, 71, 13, 10, 26, 10]

同様に、値が 0 のバイトもエスケープシーケンス (通常は \0 または \x00) で表す必要があります。

2.5.6. raw 文字列リテラル¶

文字列リテラルにもバイト列リテラルにも、接頭辞「r」または「R」を付けられます。それぞれ raw 文字列リテラル、raw バイト列リテラル と呼び、バックスラッシュをそのままの文字として扱います。そのため、raw 文字列リテラルではエスケープシーケンスを特別に扱いません。

>>> r'\d{4}-\d{2}-\d{2}'
'\\d{4}-\\d{2}-\\d{2}'

raw リテラルでも、引用符はバックスラッシュでエスケープできますが、バックスラッシュ自体も文字列に残ります; 例えば、r"\"" は有効な文字列リテラルで、バックスラッシュと二重引用符からなる文字列を表します; r"\" は無効な文字列リテラルです (raw リテラルを奇数個連なったバックスラッシュで終わらせることはできません)。具体的には、(バックスラッシュが直後のクオート文字をエスケープしてしまうので) raw文字列を単一のバックスラッシュで終わらせることはできません さらに、バックスラッシュの直後に改行がきても、行継続を意味する のではなく、リテラルの一部であるそれら二つの文字として解釈されます。

2.5.7. f-strings¶

Added in version 3.6.

バージョン 3.7 で変更: f-string 内の式で await と async for を使えるようになりました。

バージョン 3.8 で変更: デバッグ指定子 (=) を追加しました

バージョン 3.12 で変更: f-string 内の式に対する多くの制限が取り除かれました。特に、文字列の入れ子、コメント、バックスラッシュが使えるようになりました。

フォーマット済み文字列リテラル、または f-string は、接頭辞「f」または「F」を持つ文字列リテラルです。他の文字列リテラルと異なり、f-string の値は定数ではありません。波括弧 {} で囲んだ 置換フィールド を含められます。置換フィールドに含まれる式は実行時に評価されます。例えば次のように書きます。

>>> who = 'nobody'
>>> nationality = 'Spanish'
>>> f'{who.title()} expects the {nationality} Inquisition!'
'Nobody expects the Spanish Inquisition!'

置換フィールドの外側で二重にした波括弧 ({{ または }}) は、対応する単一の波括弧に置き換えられます。

>>> print(f'{{...}}')
{...}

置換フィールドの外側にあるその他の文字は、通常の文字列リテラルと同じように扱います。つまり、raw 文字列としても指定されている場合を除いてエスケープシーケンスはデコードされ、三重クォートの f-string には改行を含められます。

>>> name = 'Galahad'
>>> favorite_color = 'blue'
>>> print(f'{name}:\t{favorite_color}')
Galahad:       blue
>>> print(rf"C:\Users\{name}")
C:\Users\Galahad
>>> print(f'''Three shall be the number of the counting
... and the number of the counting shall be three.''')
Three shall be the number of the counting
and the number of the counting shall be three.

フォーマット済み文字列リテラルの中の式は、通常の Python の式と同じように扱われます。各式は、フォーマット済み文字列リテラルが現れる文脈で、左から右の順に評価されます。空の式は使えません。また、lambda と代入式 := は明示的に丸括弧で囲む必要があります。

>>> f'{(half := 1/2)}, {half * 42}'
'0.5, 21.0'

置換フィールドの中で、外側の f-string と同じ種類の引用符を使えます。

>>> a = dict(x=2)
>>> f"abc {a["x"]} def"
'abc 2 def'

置換フィールドの中ではバックスラッシュも使え、他の文脈と同じように評価されます。

>>> a = ["a", "b", "c"]
>>> print(f"List a contains:\n{"\n".join(a)}")
List a contains:
a
b
c

f-string は入れ子にできます。

>>> name = 'world'
>>> f'Repeated:{f' hello {name}' * 3}'
'Repeated: hello world hello world hello world'

移植性が必要な Python プログラムでは、入れ子を 5 段階より深くしないでください。

CPython は f-string の入れ子の深さを制限しません。

1 個の引用符で囲んだ f-string でも、三重クォートの f-string でも、置換する式には改行やコメントを含められます。置換フィールドの中の # より後は、閉じ波括弧や引用符も含めてすべてコメントです。そのため、コメントを含む置換フィールドは別の行で閉じる必要があります。

>>> a = 2
>>> f"abc{a  # このコメントは  }"  を含めて行末まで続く
...       + 3}"
'abc5'

置換フィールドの式の後には、必要に応じて次のものを指定できます。

デバッグ指定子 — 等号 (=)。片側または両側に空白を置くこともできます。
変換指定子 である !s、!r、!a のいずれか。これと次の書式指定子は、どちらか一方または両方を指定できます。
コロン (:) を先頭に付けた 書式指定子。

これらのフィールドの評価方法の詳細は、標準ライブラリの f-string の節を参照してください。

その節で説明するとおり、書式指定子 は format() 関数の第 2 引数として渡され、置換フィールドの値の書式化に使われます。例えば書式指定ミニ言語を使って、フィールドの幅や埋め草の文字を指定できます。

>>> number = 14.3
>>> f'{number:20.7f}'
'          14.3000000'

最上位の書式指定子には、入れ子の置換フィールドを含められます。

>>> field_size = 20
>>> precision = 7
>>> f'{number:{field_size}.{precision}f}'
'          14.3000000'

これらの入れ子のフィールドには、それぞれ変換フィールドや書式指定子を含められます。

>>> number = 3
>>> f'{number:{field_size}}'
'                   3'
>>> f'{number:{field_size:05}}'
'00000000000000000003'

ただし、これらの入れ子のフィールドに、さらに深く入れ子になった置換フィールドを含めることはできません。

フォーマット済み文字列リテラルは、式を含まない場合でも docstring には使えません。

>>> def foo():
...     f"Not a docstring"
...
>>> print(foo.__doc__)
None

参考

PEP 498 — リテラル文字列の補間
PEP 701 — f-string の構文の形式化
関連する書式文字列の仕組みを使う str.format()。

2.5.8. t-strings¶

Added in version 3.14.

テンプレート文字列リテラル、または t-string は、接頭辞「t」または「T」を持つ文字列リテラルです。フォーマット済み文字列リテラルと同じ構文規則に従います。評価規則の違いは標準ライブラリの t-string の節を参照してください。

2.5.9. f-string の形式文法¶

f-string の処理は、字句解析器とパーザが分担します。字句解析器は FSTRING_START、FSTRING_MIDDLE、FSTRING_END トークンを生成し、パーザは置換フィールド内の式を処理します。処理をどのように分担するかという詳細は、CPython の実装の詳細です。

そのため、f-string の文法は字句定義と構文定義が混在しています。

次の場合、空白にも意味があります。

FSTRING_START の中 (接頭辞と引用符の間) に空白は置けません。
FSTRING_MIDDLE の空白は、リテラルの文字列の内容の一部になります。
fstring_replacement_field に f_debug_specifier がある場合、開き波括弧の後から f_debug_specifier までのすべての空白と、f_debug_specifier の直後の空白は、式の一部として保持されます。

式はトークン化の段階では処理せず、{ トークンと = の次のトークンの位置を使ってソースコードから取得します。

FSTRING_MIDDLE の定義では、否定先読み (!) を使って特別な文字 (バックスラッシュ、改行、{、}) や文字列 (f_quote) を示しています。

fstring:    FSTRING_START fstring_middle* FSTRING_END

FSTRING_START:      fstringprefix ("'" | '"' | "'''" | '"""')
FSTRING_END:        f_quote
fstringprefix:      <("f" | "fr" | "rf"), case-insensitive>
f_debug_specifier:  '='
f_quote:            <the quote character(s) used in FSTRING_START>

fstring_middle:
   | fstring_replacement_field
   | FSTRING_MIDDLE
FSTRING_MIDDLE:
   | (!"\" !newline !'{' !'}' !f_quote) source_character
   | stringescapeseq
   | "{{"
   | "}}"
   | <newline, in triple-quoted f-strings only>
fstring_replacement_field:
   | '{' f_expression [f_debug_specifier] [fstring_conversion]
         [fstring_full_format_spec] '}'
fstring_conversion:
   | "!" ("s" | "r" | "a")
fstring_full_format_spec:
   | ':' fstring_format_spec*
fstring_format_spec:
   | FSTRING_MIDDLE
   | fstring_replacement_field
f_expression:
   | ','.(conditional_expression | "*" or_expr)+ [","]
   | yield_expression

注釈

上の文法の抜粋では、f_quote と FSTRING_MIDDLE の規則は文脈依存です。最も内側にある、それらを囲む fstring の FSTRING_START の内容に依存します。

このテンプレートから、より伝統的な形式文法を構成する方法は、読者の演習とします。

t-string の文法は、規則名、トークン名、接頭辞の先頭が f ではなく t であることを除いて、f-string と同じです。

tstring:    TSTRING_START tstring_middle* TSTRING_END

<rest of the t-string grammar is omitted; see above>

2.6. 数値リテラル¶

NUMBER トークンは数値リテラルを表します。整数、浮動小数点数、虚数の 3 種類があります。

NUMBER: integer | floatnumber | imagnumber

The numeric value of a numeric literal is the same as if it were passed as a string to the int, float or complex class constructor, respectively. Note that not all valid inputs for those constructors are also valid literals.

数値リテラルは符号を含みません。 -1 のような表記は、実際には単項演算子「-」とリテラル 1 からなる式です。

2.6.1. 整数リテラル¶

整数リテラルは整数を表します。例えば次のように書きます。

7
3
2147483647

There is no limit for the length of integer literals apart from what can be stored in available memory:

7922816251426433759354395033679228162514264337593543950336

アンダースコアで数字を区切ると読みやすくなります。リテラルの数値を決める際には無視されます。例えば次のリテラルは同じ値を表します。

100_000_000_000
100000000000
1_00_00_00_00_000

アンダースコアを置けるのは数字と数字の間だけです。例えば _123、321_、123__321 は有効なリテラルでは ありません。

接頭辞 0b、0o、0x を使うと、それぞれ 2 進数、8 進数、16 進数で整数を指定できます。 16 進数の 10 から 15 は英字 A-F で表し、大文字と小文字は区別しません。例えば次のように書きます。

0b100110111
0b_1110_0101
0o177
0o377
0xdeadbeef
0xDead_Beef

基数の指定の直後にもアンダースコアを置けます。例えば 0x_1f は有効なリテラルですが、0_x1f と 0x__1f は無効です。

0 以外の 10 進数に先頭の 0 は付けられません。例えば 0123 は有効なリテラルではありません。これは、Python がバージョン 3.0 より前に使っていた C 形式の 8 進数リテラルとの曖昧さを避けるためです。

形式的には、整数リテラルは次の字句定義で表されます。

integer:      decinteger | bininteger | octinteger | hexinteger | zerointeger
decinteger:   nonzerodigit (["_"] digit)*
bininteger:   "0" ("b" | "B") (["_"] bindigit)+
octinteger:   "0" ("o" | "O") (["_"] octdigit)+
hexinteger:   "0" ("x" | "X") (["_"] hexdigit)+
zerointeger:  "0"+ (["_"] "0")*
nonzerodigit: "1"..."9"
digit:        "0"..."9"
bindigit:     "0" | "1"
octdigit:     "0"..."7"
hexdigit:     digit | "a"..."f" | "A"..."F"

バージョン 3.6 で変更: グループ化を目的としたリテラル中のアンダースコアが許されるようになりました。

2.6.2. 浮動小数点数リテラル¶

3.14 や 1.5 などの浮動小数点数 (float) リテラルは、実数の近似値を表します。

整数部 と 小数部 からなり、どちらも 10 進数字で構成されます。整数部と小数部は小数点 . で区切ります。

2.71828
4.0

整数リテラルと異なり、先頭に 0 を付けられます。例えば 077.010 は有効で、77.01 と同じ数を表します。

整数リテラルと同様、読みやすくするために数字と数字の間にアンダースコアを 1 個ずつ置けます。

96_485.332_123
3.14_15_93

整数部と小数部の片方は空にできますが、両方を空にはできません。例えば次のように書きます。

10.  # (次と同じ: 10.0)
.001  # (次と同じ: 0.001)

整数部と小数部の後には、必要に応じて 指数部 を付けられます。指数部は文字 e または E、省略可能な符号 + または -、整数部や小数部と同じ形式の数からなります。 e または E は「10 の何乗を掛けるか」を表します。

0e3  # (次を表す: 1.0×10³、すなわち 1000.0)
166e-5  # (次を表す: 1.166×10⁻⁵、すなわち 0.00001166)
02214076e+23  # (次を表す: 6.02214076×10²³、すなわち 602214076000000000000000.)

整数部と指数部だけの浮動小数点数では、小数点を省略できます。

1e3  # (次と同じ: 1.e3 と 1.0e3)
0e0  # (次と同じ: 0.)

形式的には、浮動小数点数リテラルは次の字句定義で表されます。

floatnumber:
   | digitpart "." [digitpart] [exponent]
   | "." digitpart [exponent]
   | digitpart exponent
digitpart: digit (["_"] digit)*
exponent:  ("e" | "E") ["+" | "-"] digitpart

バージョン 3.6 で変更: グループ化を目的としたリテラル中のアンダースコアが許されるようになりました。

2.6.3. 虚数 (imaginary) リテラル¶

Python には複素数オブジェクトがありますが、複素数リテラルはありません。代わりに、虚数リテラル が実部の 0 の複素数を表します。

例えば数学では、複素数 3+4.2i を、実数 3 と虚数 4.2i の和として書きます。 Python でも同様の構文を使いますが、虚数単位には i ではなく j を使います。

3+4.2j

これは整数リテラル 3、演算子 +、虚数リテラル 4.2j からなる式です。これらは別々の 3 個のトークンなので、その間に空白を置けます。

3 + 4.2j

各トークンの中に空白は置けません。特に、接尾辞 j を直前の数から離すことはできません。

j の前の数は、浮動小数点数リテラルと同じ構文です。従って、次は有効な虚数リテラルです。

2j
14j
j
.001j
1e100j
14e-10j
14_15_93j

浮動小数点数リテラルと異なり、虚数が整数部だけを持つ場合は小数点を省略できます。この場合も、数は整数ではなく浮動小数点数として評価されます。

10j
0j
1000000000000000000000000j   # 次と同じ: 1e+24j

接尾辞 j は大文字と小文字を区別しません。つまり、代わりに J も使えます。

3.14J   # 次と同じ: 3.14j

形式的には、虚数リテラルは次の字句定義で表されます。

imagnumber: (floatnumber | digitpart) ("j" | "J")

2.7. 演算子とデリミタ¶

次の文法は 演算子 と デリミタ のトークン、すなわち汎用の OP トークン型を定義します。 token モジュールのドキュメントにもこれらのトークンと名前の一覧があります。

OP:
   | assignment_operator
   | bitwise_operator
   | comparison_operator
   | enclosing_delimiter
   | other_delimiter
   | arithmetic_operator
   | "..."
   | other_op

assignment_operator:   "+=" | "-=" | "*=" | "**=" | "/="  | "//=" | "%=" |
                       "&=" | "|=" | "^=" | "<<=" | ">>=" | "@="  | ":="
bitwise_operator:      "&"  | "|"  | "^"  | "~"   | "<<"  | ">>"
comparison_operator:   "<=" | ">=" | "<"  | ">"   | "=="  | "!="
enclosing_delimiter:   "("  | ")"  | "["  | "]"   | "{"   | "}"
other_delimiter:       ","  | ":"  | "!"  | ";"   | "="   | "->"
arithmetic_operator:   "+"  | "-"  | "**" | "*"   | "//"  | "/"   | "%"
other_op:              "."  | "@"

注釈

一般に、演算子 は式を組み合わせるために使われ、デリミタ はその他の目的に使われます。ただし、この 2 つに明確で形式的な区別があるわけではありません。

使い方によって、演算子にもデリミタにもなるトークンがあります。例えば * は乗算演算子にもシーケンスのアンパックに使うデリミタにもなり、@ は行列乗算にもデコレータの始まりを示すデリミタにもなります。

区別が曖昧なトークンもあります。例えば .、(、) をデリミタと考える人もいれば、getattr() 演算子や関数呼び出し演算子と考える人もいます。

and、or、not in など、Python の一部の演算子は「記号」(演算子トークン) ではなくキーワードトークンを使います。

ピリオドが 3 個連続したもの (...) は、Ellipsis リテラルとして特別な意味を持ちます。