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 から始まります。

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

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