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 進数で指定する文字                               |
+----------------------------------------------------+----------------------------------------------------+
| "\x*hh*"                                           | 16 進数で指定する文字                              |
+----------------------------------------------------+----------------------------------------------------+
| "\N{*name*}"                                       | 名前で指定する Unicode 文字                        |
+----------------------------------------------------+----------------------------------------------------+
| "\u*xxxx*"                                         | 16 進数で指定する Unicode 文字                     |
+----------------------------------------------------+----------------------------------------------------+
| "\U*xxxxxxxx*"                                     | 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 進数で指定する文字
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

シーケンス "\x*hh*" は、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 文字
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

シーケンス "\u*xxxx*" と "\U*xxxxxxxx*" は、指定された 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 の何乗を掛けるか」を
表します。

   1.0e3  # (次を表す: 1.0×10³、すなわち 1000.0)
   1.166e-5  # (次を表す: 1.166×10⁻⁵、すなわち 0.00001166)
   6.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.2*i* を、実数 3 と虚数 4.2*i* の和として書
きます。 Python でも同様の構文を使いますが、虚数単位には *i* ではなく
"j" を使います。

   3+4.2j

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

   3 + 4.2j

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

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

   4.2j
   3.14j
   10.j
   .001j
   1e100j
   3.14e-10j
   3.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" リテラルとして特別
な意味を持ちます。
