# 3. 形式ばらない Python の紹介

以下のサンプルでは、入力と出力はプロンプト (>>> や ...) の有無で区別します: 例を実際に試す場合は、プロンプトが表示されているときに、サンプル中のプロンプトから後ろの内容全てを入力します。

コード例の枠の右上にある `>>>` をクリックすると、プロンプトと出力の表示をトグルできます。コード例のプロンプトと出力を非表示にすると、簡単にインタープリタの入力にコピー&ペーストができます。

このマニュアルにあるサンプルの多くは、対話プロンプトで入力されるものでもコメントを含んでいます。 Python におけるコメント文は、ハッシュ文字 `#` で始まり、物理行の終わりまで続きます。コメントは行の先頭にも、空白やコードの後にも書くことができますが、文字列リテラルの内部に置くことはできません。文字列リテラル中のハッシュ文字はただのハッシュ文字です。コメントはコードを明快にするためのものであり、Pythonはコメントを解釈しません。なので、サンプルコードを実際に入力して試して見るときは、コメントを省いても大丈夫です。

いくつかの例です:

    # this is the first comment
    spam = 1  # and this is the second comment
              # ... and now a third!
    text = "# This is not a comment because it's inside quotes."

## 3.1. Python を電卓として使う

それでは、簡単な Python コマンドをいくつか試してみましょう。インタプリタを起動して、一次プロンプト、 `>>>` が現れるのを待ちます。 (そう長くはかからないはずです)

### 3.1.1. 数

インタプリタは、簡単な電卓のように動作します: 式を入力すると、その結果が表示されます。 式の文法は素直なものです: 演算子 `+` 、 `-` 、 `*` 、 `/` によって算術演算を行うことができ、丸括弧 (`()`) をグループ化に使うことができます。 例えば:

    >>> 2 + 2
    4
    >>> 50 - 5*6
    20
    >>> (50 - 5*6) / 4
    5.0
    >>> 8 / 5  # division always returns a floating point number
    1.6

整数 (例えば、 `2` 、 `4` 、 `20`) は `int` 型であり、小数部を持つ数 (例えば、 `5.0` 、 `1.6`) は `float` 型です。数値型については後のチュートリアルでさらに見ていきます。

除算 (`/`) は常に浮動小数点数を返します。 `//` 演算子は 整数除算 を行い、整数値を返します; 剰余は、`%` で求めます。:

    >>> 17 / 3  # classic division returns a float
    5.666666666666667
    >>>
    >>> 17 // 3  # floor division discards the fractional part
    5
    >>> 17 % 3  # the % operator returns the remainder of the division
    2
    >>> 5 * 3 + 2  # floored quotient * divisor + remainder
    17

Python では、冪乗を計算するのに `**` 演算子が使えます [1]:

    >>> 5 ** 2  # 5 squared
    25
    >>> 2 ** 7  # 2 to the power of 7
    128

等号 (`=`) は変数に値を代入するときに使います。代入を行っても、結果は出力されず、次の入力プロンプトが表示されます。:

    >>> width = 20
    >>> height = 5 * 9
    >>> width * height
    900

変数が "定義" されていない (つまり値が代入されていない) 場合、その変数を使おうとするとエラーが発生します:

    >>> n  # try to access an undefined variable
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'n' is not defined

浮動小数点を完全にサポートしています。演算対象の値(オペランド)に複数の型が入り混じっている場合、演算子は整数のオペランドを浮動小数点型に変換します:

    >>> 4 * 3.75 - 1
    14.0

対話モードでは、最後に表示された結果は変数 `_` に代入されます。このことを利用すると、Python を電卓として使うときに、計算を連続して行う作業が多少楽になります。以下に例を示します:

    >>> tax = 12.5 / 100
    >>> price = 100.50
    >>> price * tax
    12.5625
    >>> price + _
    113.0625
    >>> round(_, 2)
    113.06

この変数には読取りだけを行い、明示的な代入を行ってはいけません --- そんなことをすれば、同じ名前で別のローカル変数が生成され、元の特別な動作をする組み込み変数を覆い隠してしておかしなことになってしまうかもしれません。

`int` と `float` に加え、 Python は `Decimal` や `Fraction` などの他の数値型もサポートしています。 複素数 も組み込み型としてサポートしており、 `j` もしくは `J` 接尾辞を使って虚部を示します (例: `3+5j`)。

### 3.1.2. テキスト

Python は数値だけでなくテキスト (いわゆる「文字列」である `str` 型によって表現されます) を扱うことができます。 `!` のような文字や `rabbit` のような単語、 `Paris` のような名前、 `Got your back.` ような文もすべて文字列です。 文字列はシングルクォート (`'...'`) またはダブルクォート (`"..."`) で囲み、どちらを使っても違いはありません [2] 。

    >>> 'spam eggs'  # single quotes
    'spam eggs'
    >>> "Paris rabbit got your back :)! Yay!"  # double quotes
    'Paris rabbit got your back :)! Yay!'
    >>> '1975'  # digits and numerals enclosed in quotes are also strings
    '1975'

クォートの中でクォートを使いたい場合、 `\` を前に付け加えることで「エスケープ」をする必要があります。 もしくは、文字列で使用したいクォートとは別の方のクォートで囲むこともできます。

    >>> 'doesn\'t'  # use \' to escape the single quote...
    "doesn't"
    >>> "doesn't"  # ...or use double quotes instead
    "doesn't"
    >>> '"Yes," they said.'
    '"Yes," they said.'
    >>> "\"Yes,\" they said."
    '"Yes," they said.'
    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'

Python シェルでは、文字列を定義するときと文字列が出力されるときでは見え方が異なることがあります。 `print()` 関数を使うと、両端のクォートがなくなり、エスケープされた文字や特殊文字が表示されるため、より読みやすい形で出力できます。

    >>> s = 'First line.\nSecond line.'  # \n means newline
    >>> s  # without print(), special characters are included in the string
    'First line.\nSecond line.'
    >>> print(s)  # with print(), special characters are interpreted, so \n produces new line
    First line.
    Second line.

`\` に続く文字を特殊文字として解釈されたくない場合は、最初の引用符の前に `r` を付けた raw strings が使えます:

    >>> print('C:\some\name')  # here \n means newline!
    C:\some
    ame
    >>> print(r'C:\some\name')  # note the r before the quote
    C:\some\name

raw文字列には微妙な面があります: raw文字列は奇数個の```` 文字では終了できません。詳細と解決方法については the FAQ entry を参照してください。

文字列リテラルは複数行にまたがって書けます。1 つの方法は三連引用符 (`"""..."""` や `'''...'''`) を使うことです。改行文字は自動的に文字列に含まれますが、行末に `\` を付けることで含めないようにすることもできます。次の例:

    print("""\
    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to
    """)

は次のような出力になります (最初の改行文字は含まれていないことに注意してください):

    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to

文字列は `+` 演算子で連結させる (くっつけて一つにする) ことができ、`*` 演算子で反復させることができます:

    >>> # 3 times 'un', followed by 'ium'
    >>> 3 * 'un' + 'ium'
    'unununium'

連続して並んでいる複数の 文字列リテラル (つまり、引用符に囲われた文字列) は、自動的に連結されます。

    >>> 'Py' 'thon'
    'Python'

この機能は、長い文字列を改行したいときにとても役に立ちます:

    >>> text = ('Put several strings within parentheses '
    ...         'to have them joined together.')
    >>> text
    'Put several strings within parentheses to have them joined together.'

これは 2 つのリテラルどうしに対してのみ働き、変数や式には働きません:

    >>> prefix = 'Py'
    >>> prefix 'thon'  # can't concatenate a variable and a string literal
      File "<stdin>", line 1
        prefix 'thon'
               ^^^^^^
    SyntaxError: invalid syntax
    >>> ('un' * 3) 'ium'
      File "<stdin>", line 1
        ('un' * 3) 'ium'
                   ^^^^^
    SyntaxError: invalid syntax

変数どうしや変数とリテラルを連結したい場合は、`+` を使ってください:

    >>> prefix + 'thon'
    'Python'

文字列は インデックス (添字) を指定して文字を取得できます。最初の文字のインデックスは 0 になります。文字を表す、専用のデータ型は用意されていません; 文字とは、単に長さが 1 の文字列です:

    >>> word = 'Python'
    >>> word[0]  # character in position 0
    'P'
    >>> word[5]  # character in position 5
    'n'

インデックスには、負の値も指定できまます。この場合、右から数えていきます:

    >>> word[-1]  # last character
    'n'
    >>> word[-2]  # second-last character
    'o'
    >>> word[-6]
    'P'

-0 は 0 と区別できないので、負のインデックスは -1 から始まります。

In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you to obtain substring:

    >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
    'Py'
    >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
    'tho'

スライスのインデックスには、便利なデフォルト値があります; 最初のインデックスを省略すると、0 と見なされます。二番め のインデックスを省略すると、スライスする文字列のサイズとみなされます。

    >>> word[:2]   # character from the beginning to position 2 (excluded)
    'Py'
    >>> word[4:]   # characters from position 4 (included) to the end
    'on'
    >>> word[-2:]  # characters from the second-last (included) to the end
    'on'

開始値は常に含まれ、終了値は常に含まれないことに注意してください。なので `s[:i] + s[i:]` は常に `s` と等しくなります:

    >>> word[:2] + word[2:]
    'Python'
    >>> word[:4] + word[4:]
    'Python'

スライスの使い方をおぼえる良い方法は、インデックスが文字と文字の あいだ (between) を指しており、最初の文字の左端が 0 になっていると考えることです。そうすると、 n 文字からなる文字列中の最後の文字の右端はインデックス n となります。例えばこうです:

     +---+---+---+---+---+---+
     | P | y | t | h | o | n |
     +---+---+---+---+---+---+
     0   1   2   3   4   5   6
    -6  -5  -4  -3  -2  -1

1行目の数字は文字列の 0 から 6 までのインデックスの位置を示しています; 2行目は対応する負のインデックスを示しています。i から j までのスライスは、それぞれ i と付いた境界から j と付いた境界までの全ての文字から成っています。

正のインデックスの場合、スライスされたシーケンスの長さは、スライスの両端のインデックスが範囲内にあるかぎり、インデックス間の差になります。例えば、 `word[1:3]` の長さは 2 になります。

大き過ぎるインデックスを使おうとするとエラーが発生します:

    >>> word[42]  # the word only has 6 characters
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    IndexError: string index out of range

しかし、スライスで範囲外のインデックスを使ったときは、上手く対応して扱ってくれます:

    >>> word[4:42]
    'on'
    >>> word[42:]
    ''

Python の文字列は変更できません -- つまり 不変 です。従って、文字列のインデックスで指定したある場所に代入を行うとエラーが発生します:

    >>> word[0] = 'J'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment
    >>> word[2:] = 'py'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment

元の文字列と別の文字列が必要な場合は、新しく文字列を作成してください:

    >>> 'J' + word[1:]
    'Jython'
    >>> word[:2] + 'py'
    'Pypy'

組込み関数 `len()` は文字列の長さ (length) を返します:

    >>> s = 'supercalifragilisticexpialidocious'
    >>> len(s)
    34

参考

テキストシーケンス型 --- str

  文字列は代表的な シーケンス型 で、シーケンス型でサポートされている共通の操作をサポートしています。

文字列メソッド

  文字列は、基本的な変換や検索を行うための数多くのメソッドをサポートしています。

f-strings

  式の埋め込みをサポートした文字列リテラル

書式指定文字列の文法

  `str.format()` を使った文字列のフォーマットについての情報があります。

printf 形式の文字列書式化

  文字列が `%` 演算子の左オペランドである場合に呼び出される古いフォーマット操作について、詳しく記述されています。

### 3.1.3. リスト型 (list)

Pythonは多くの 複合 (compound) データ型を備えており、複数の値をまとめるのに使われます。最も汎用性が高いのは リスト (list) で、コンマ区切りの値 (要素) の並びを角括弧で囲んだものとして書き表されます。リストは異なる型の要素を含むこともありますが、通常は同じ型の要素のみを持ちます。

    >>> squares = [1, 4, 9, 16, 25]
    >>> squares
    [1, 4, 9, 16, 25]

文字列 (や他の全ての組み込みの シーケンス 型) のように、リストはインデックスやスライスができます:

    >>> squares[0]  # indexing returns the item
    1
    >>> squares[-1]
    25
    >>> squares[-3:]  # slicing returns a new list
    [9, 16, 25]

リストは、リストの連結などもサポートしています:

    >>> squares + [36, 49, 64, 81, 100]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

不変 な文字列とは違って、リストは 可変 型ですので、要素を入れ替えられます:

    >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
    >>> 4 ** 3  # the cube of 4 is 64, not 65!
    64
    >>> cubes[3] = 64  # replace the wrong value
    >>> cubes
    [1, 8, 27, 64, 125]

`list.append()` を使って、リストの末尾に新しい要素を追加できます (このメソッドについては後で詳しく見ていきます):

    >>> cubes.append(216)  # add the cube of 6
    >>> cubes.append(7 ** 3)  # and the cube of 7
    >>> cubes
    [1, 8, 27, 64, 125, 216, 343]

単純な代入ではPythonは決してデータをコピーしません。リストを変数に代入すると、その変数は 既存のリスト を参照します。ある変数を通してリストに任意の変更を行うと、そのリストを参照したすべての他の変数を通して確認できます。:

    >>> rgb = ["Red", "Green", "Blue"]
    >>> rgba = rgb
    >>> id(rgb) == id(rgba)  # they reference the same object
    True
    >>> rgba.append("Alph")
    >>> rgb
    ["Red", "Green", "Blue", "Alph"]

全てのスライス操作は、指定された要素を含む新しいリストを返します。例えば、次のスライスは、リストの 浅いコピー を返します。:

    >>> correct_rgba = rgba[:]
    >>> correct_rgba[-1] = "Alpha"
    >>> correct_rgba
    ["Red", "Green", "Blue", "Alpha"]
    >>> rgba
    ["Red", "Green", "Blue", "Alph"]

スライスには、代入もできます。スライスの代入で、リストのサイズを変更したり、全てを削除したりもできます:

    >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> letters
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> # replace some values
    >>> letters[2:5] = ['C', 'D', 'E']
    >>> letters
    ['a', 'b', 'C', 'D', 'E', 'f', 'g']
    >>> # now remove them
    >>> letters[2:5] = []
    >>> letters
    ['a', 'b', 'f', 'g']
    >>> # clear the list by replacing all the elements with an empty list
    >>> letters[:] = []
    >>> letters
    []

組込み関数 `len()` はリストにも使えます:

    >>> letters = ['a', 'b', 'c', 'd']
    >>> len(letters)
    4

リストを入れ子 (ほかのリストを含むリストを造る) にできます。例えば:

    >>> a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'

## 3.2. プログラミングへの第一歩

もちろん、2 たす 2 よりももっと複雑な課題にも Python を使えます。 例えば、Fibonacci series の先頭の部分列は次のように書けます:

    >>> # Fibonacci series:
    ... # the sum of two elements defines the next
    ... a, b = 0, 1
    >>> while a < 10:
    ...     print(a)
    ...     a, b = b, a+b
    ...
    0
    1
    1
    2
    3
    5
    8

上の例では、いくつか新しい機能を使用しています。

- 最初の行には 複数同時の代入 (multiple assignment) が入っています: 変数 `a` と `b` は、それぞれ同時に新しい値 0 と 1 になっています。この代入は、最後の行でも使われています。代入文では、まず右辺の式がすべて評価され、次に代入が行われます。右辺の式は、左から右へと順番に評価されます。

- `while` は、条件 (ここでは `` a < 10``) が真である限り実行を繰り返し (ループし) ます。Python では、C 言語と同様に、ゼロでない整数値は真となり、ゼロは偽です。条件式には、文字列値やリスト値なども使えます。それ以外のシーケンスも、条件式として使用できます。長さが 1 以上のシーケンスは真で、空のシーケンスは偽になります。サンプルで使われている条件テストはシンプルな比較です。標準的な比較演算子は C 言語と同様です: すなわち、 `<` (より小さい)、 `>` (より大きい)、 `==` (等しい)、 `<=` (より小さいか等しい)、 `>=` (より大きいか等しい)、および `!=` (等しくない)、です。

- ループの 本体 (body) は、 インデント (indent, 字下げ) されています: インデントは Python において、実行文をグループにまとめる方法です。対話的プロンプトでは、インデントされた各行を入力するにはタブや (複数個の) スペースを使わなければなりません。実用的には、もっと複雑な処理を入力する場合はテキストエディタを使うことになるでしょう。 ほとんどのテキストエディタは、自動インデント機能を持っています。複合文を対話的に入力するときには、入力完了のしるしとして最後に空行を入力します。これは、パーザはどれが最後の行を入力なのか、判断できないためです。基本的なブロック内では、全ての行は同じだけインデントされていなければならないので注意してください。

- The `print()` function writes the value of the argument(s) it is given. It differs from just writing the expression you want to write (as we did earlier in the calculator examples) in the way it handles multiple arguments, floating point quantities, and strings. Strings are printed without quotes, and a space is inserted between items, so you can format things nicely, like this:

      >>> i = 256*256
      >>> print('The value of i is', i)
      The value of i is 65536

  キーワード引数 end を使うと、出力の末尾に改行文字を出力しないようにしたり、別の文字列を末尾に出力したりできます:

      >>> a, b = 0, 1
      >>> while a < 1000:
      ...     print(a, end=',')
      ...     a, b = b, a+b
      ...
      0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

脚注

[1]

`**` は `-` より優先順位が高いので、`-3**2` は `-(3**2)` と解釈され、計算結果は `-9` になります。これを避けて `9` を得たければ、`(-3)**2` と書きます。

[2]

他の言語と違って、`\n` のような特殊文字は、単引用符 (`'...'`) と二重引用符 (`"..."`) で同じ意味を持ちます。両者の唯一の違いは、単引用符で囲われた箇所では `"` をエスケープする必要がない (ただし `\'` はエスケープする必要がある) ことで、逆もまた同様です。