This document is for an old version of Python that is no longer supported. You should upgrade and read the Python documentation for the current stable release.

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

以下の例では、入力と出力は (>>> や ...) といったプロンプトの有無で区別します: 例を実際に試してみるためには、プロンプトが表示されているときに、例中のプロンプトから後ろの内容全てを入力しなければなりません; プロンプトが先頭にない行はインタプリタからの出力です。例中には2つ目のプロンプトだけが表示されている行がありますが、これは空行を入力しなければならないことを意味しています; 空行の入力は複数の行からなる命令の終わりをインタプリタに教えるために使われます。

このマニュアルにある例の多くは、対話プロンプトで入力されるものでもコメントを含んでいます。 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. 数

インタプリタは単純な電卓のように動作します: 式を入力すると、その結果が表示されます。式の文法は素直なものです: 演算子 `+`, `-`, `*`, `/` は (Pascal や C といった) 他のほとんどの言語と同じように動作します; 丸括弧 (`()`) をグループ化に使うこともできます。例えば:

    >>> 2 + 2
    4
    >>> 50 - 5*6
    20
    >>> (50 - 5.0*6) / 4
    5.0
    >>> 8 / 5.0
    1.6

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

割り算 (`/`) の戻り値は、その被演算子に依存します。被演算子の両方が `int` 型ならば、 floor division が計算されて `int` が返ります。被演算子のどちらかが `float` の場合は良く知られた方の割り算が計算されて、 `float` が返ります。 `//` 演算子も floor division を計算しますが、被演算子によりません。剰余は `%` 演算子で計算出来ます

    >>> 17 / 3  # int / int -> int
    5
    >>> 17 / 3.0  # int / float -> float
    5.666666666666667
    >>> 17 // 3.0  # explicit floor division discards the fractional part
    5.0
    >>> 17 % 3  # the % operator returns the remainder of the division
    2
    >>> 5 * 3 + 2  # result * 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

浮動小数点を完全にサポートしています。演算対象の値(オペランド)の型が統一されていない場合、演算子は整数のオペランドを浮動小数点型に変換します:

    >>> 3 * 3.75 / 1.5
    7.5
    >>> 7.0 / 2
    3.5

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

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

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

`int` と `float` に加え、 Python は `Decimal` や `Fraction` のような他の数値型をサポートしています。 Python はビルトインで 複素数 もサポートし、 `j` もしくは `J` 接尾辞を使って虚部を示します (例。 `3+5j`)。

### 3.1.2. 文字列

数のほかに、Python は文字列の操作ができ、文字列はいくつもの方法で表現できます。文字列は単引用符 (`'...'`) もしくは二重引用符 (`"..."`) で囲み、結果はどちらも同じ文字列になります。2 `\` は引用符をエスケープするのに使います:

    >>> 'spam eggs'  # single quotes
    'spam eggs'
    >>> '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.'

対話的インタプリタでは、出力文字列は引用符に囲まれ、特殊文字はバックスラッシュでエスケープされます。これは入力とは違って見える (囲っている引用符が変わる) こともありますが、その 2 つの文字列は同じ文字列です。文字列が単引用符を含み二重引用符を含まない場合、二重引用符で囲われ、それ以外の場合は単引用符で囲われます。`print` キーワードは、囲っている引用符を落とし、エスケープした特殊文字を出力することで、より読み易い出力を作成します:

    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'
    >>> print '"Isn\'t," they said.'
    "Isn't," they said.
    >>> s = 'First line.\nSecond line.'  # \n means newline
    >>> s  # without print, \n is included in the output
    'First line.\nSecond line.'
    >>> print s  # with print, \n produces a 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

文字列リテラルは複数行にまたがって書けます。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
      ...
    SyntaxError: invalid syntax
    >>> ('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 から始まることに注意してください。

インデクス表記に加え、 スライス もサポートされています。インデクス表記は個々の文字を取得するのに使いますが、 スライス を使うと部分文字列を取得することができます:

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

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

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

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

    >>> 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'

スライスの働きかたをおぼえる良い方法は、インデクスが文字と文字の あいだ (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 の文字列は変更できません -- つまり不変 (immutable) なのです。従って、文字列のインデクスで指定したある場所に代入を行うとエラーが発生します:

    >>> word[0] = 'J'
      ...
    TypeError: 'str' object does not support item assignment
    >>> word[2:] = 'py'
      ...
    TypeError: 'str' object does not support item assignment

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

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

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

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

参考

シーケンス型 --- str, unicode, list, tuple, bytearray, buffer, xrange

  次節で記述されている文字列および Unicode 文字列は シーケンス型 の例であり、シーケンス型でサポートされている共通の操作をサポートしています。

文字列メソッド

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

書式指定文字列の文法

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

文字列フォーマット操作

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

### 3.1.3. Unicode 文字列

Python 2.0 から、プログラマはテキスト・データを格納するための新しいデータ型、 Unicode オブジェクトを利用できるようになりました。 Unicode オブジェクトを使うと、Unicode データ (http://www.unicode.org/ 参照) を記憶したり、操作したりできます。また、 Unicode オブジェクトは既存の文字列オブジェクトとよく統合されていて、必要に応じて自動変換されます。

Unicode には、古今のテキストで使われているあらゆる書き文字のあらゆる文字について、対応付けを行うための一つの序数を規定しているという利点があります。これまでは、書き文字のために利用可能な序数は 256 個しかなく、テキストは書き文字の対応付けを行っているコードページに束縛されているのが通常でした。このことは、とりわけソフトウェアの国際化 (internationalization. よく、 `i18n` と書かれます --- `'i'` + 18 文字 + `'n'` の意) に対して大きな混乱をもたらしました。Unicode では、すべての書き文字に対して単一のコードページを定義することで、これらの問題を解決しています。

Python では、Unicode 文字列の作成は通常の文字列を作成するのと同じように単純なものです。

    >>> u'Hello World !'
    u'Hello World !'

クオートの前にある小文字の `'u'` は、Unicode 文字列を生成することになっていることを示します。文字列に特殊な文字を含めたければ、Python の Unicode-Escape エンコーディングを使って行えます。以下はその方法を示しています。

    >>> u'Hello\u0020World !'
    u'Hello World !'

エスケープシーケンス `\u0020` は、序数の値 0x0020 を持つ Unicode 文字 (スペース文字) を、指定場所に挿入することを示します。

他の文字は、それぞれの序数値をそのまま Unicode の序数値に用いて解釈されます。多くの西洋諸国で使われている標準 Latin-1 エンコーディングのリテラル文字列があれば、Unicode の下位 256 文字が Latin-1 の 256 文字と同じになっていて便利だと思うことでしょう。

上級者のために、通常の文字列の場合と同じく raw モードもあります。これには、文字列を開始するクオート文字の前に 'ur' を付けて、 Python に Raw-Unicode-Escape エンコーディングを使わせなければなりません。このモードでは、上記の `\uXXXX` の変換は、小文字の 'u' の前に奇数個のバックスラッシュがあるときにだけ適用されます。

    >>> ur'Hello\u0020World !'
    u'Hello World !'
    >>> ur'Hello\\u0020World !'
    u'Hello\\\\u0020World !'

raw モードは、正規表現を記述する時のように、沢山のバックスラッシュを入力しなければならないときとても役に立ちます。

これら標準のエンコーディングにとは別に、Python では、既知の文字エンコーディングに基づいて Unicode 文字列を生成する一連の手段を提供しています。

組込み関数 `unicode()` は、登録されているすべての Unicode codecs (COder: エンコーダと DECoder デコーダ) へのアクセス機能を提供します。codecs が変換できるエンコーディングには、よく知られているものとして Latin-1, ASCII, UTF-8 および UTF-16 があります。後者の二つは可変長のエンコードで、各 Unicode 文字を 1 バイトまたはそれ以上のバイト列に保存します。デフォルトのエンコーディングは通常 ASCIIに設定されています。ASCIIでは 0 から 127 の範囲の文字だけを通過させ、それ以外の文字は受理せずエラーを出します。 Unicode 文字列を印字したり、ファイルに書き出したり、 `str()` で変換すると、デフォルトのエンコーディングを使った変換が行われます。(訳注: IDLE をはじめ、ほとんどの Python 2 用のインタラクティブシェルは、非ASCII 文字を含む Unicode リテラルを利用することができません。このサンプルを実行するには、インタプリタ内蔵のインタラクティブシェルを利用する必要があります。この問題は Python 3 では解決されています。)

    >>> u"abc"
    u'abc'
    >>> str(u"abc")
    'abc'
    >>> u"äöü"
    u'\xe4\xf6\xfc'
    >>> str(u"äöü")
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
    UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

特定のエンコーディングを使って Unicode 文字列を 8 ビットの文字列に変換するために、Unicode オブジェクトは `encode()` メソッドを提供しています。このメソッドは第一引数としてエンコーディングの名前をとります。エンコーディング名には小文字の使用が推奨されています。

    >>> u"äöü".encode('utf-8')
    '\xc3\xa4\xc3\xb6\xc3\xbc'

特定のエンコーディングで書かれているデータがあり、そこから Unicode 文字列を生成したいなら、 `unicode()` を使い、第 2 引数にエンコーディング名を指定します。

    >>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
    u'\xe4\xf6\xfc'

### 3.1.4. リスト

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

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

文字列 (や他の全てのビルトインのシーケンス (sequence) 型) のように、リストはインデクス表記やスライス表記ができます:

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

全てのスライス操作は指定された要素を含む新しいリストを返します。これは、次のスライスはリストの新しい (浅い) コピーを返すことを意味します:

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

リストは文字列の連結に似た操作もサポートしています:

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

不変 (immutable) な文字列とは違って、リストは可変 (mutable) 型、つまり含んでいる要素を取り替えることができます:

    >>> 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]

`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]

スライスに代入することもできます。スライスの代入を行って、リストのサイズを変更したり、完全に消すことさえできます:

    >>> 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 級数列の先頭の部分列は次のようにして書くことができます:

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

上の例では、いくつか新しい機能を取り入れています。

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

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

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

- `print` は指定した (1つまたは複数の) 式の値を書き出します。 `print` は、(電卓の例でしたように) 単に値を出力したい式を書くのとは、複数の式や文字列を扱う方法が違います。文字列は引用符無しで出力され、複数の要素の間にはスペースが挿入されるので、以下のように出力をうまく書式化できます。

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

  末尾にコンマを入れると、出力を行った後に改行されません。

      >>> a, b = 0, 1
      >>> while b < 1000:
      ...     print b,
      ...     a, b = b, a+b
      ...
      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` のような特殊文字は単引用符 (`'...'`) と二重引用符 (`"..."`) で同じ意味を持ちます。両者の唯一の違いは、単引用符で囲われた箇所では `"` をエスケープする必要がない (ただし `\'` はエスケープする必要がある) ことで、逆もまた同様です。