3. Pythonの非公式な紹介—Pythonドキュメント

3.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*6) / 4
5.0
>>> 8 / 5  # division always returns a floating point number
1.6

整数（例： 2、4、20）のタイプは int で、小数部分があります（例： 5.0、1.6）のタイプは float です。 数値型については、チュートリアルの後半で詳しく説明します。

除算（/）は常に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  # 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

浮動小数点は完全にサポートされています。 混合型オペランドを持つ演算子は、整数オペランドを浮動小数点に変換します。

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

この変数は、ユーザーが読み取り専用として扱う必要があります。 値を明示的に割り当てないでください。同じ名前の独立したローカル変数を作成して、組み込み変数をその魔法の動作でマスクします。

Pythonは、 int と float に加えて、 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を追加して、生の文字列を使用できます。

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

2つ以上の文字列リテラル（つまり 引用符で囲まれたもの）が隣り合っていると、自動的に連結されます。

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

開始が常に含まれ、終了が常に除外されることに注意してください。 これにより、s[:i] + s[i:]が常にsと等しくなるようになります。

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

スライスインデックスには便利なデフォルトがあります。 省略された最初のインデックスはデフォルトでゼロになり、省略された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'

スライスがどのように機能するかを覚える1つの方法は、インデックスを文字間を指し、最初の文字の左端に0の番号が付けられていると考えることです。 次に、 n 文字の文字列の最後の文字の右端に、インデックス n があります。次に例を示します。

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -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（）は、文字列の長さを返します。

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

も参照してください

テキストシーケンスタイプ— str

文字列はシーケンスタイプの例であり、そのようなタイプでサポートされる一般的な操作をサポートします。

文字列メソッド

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

フォーマットされた文字列リテラル

式が埋め込まれた文字列リテラル。

フォーマット文字列構文

str.format（）を使用した文字列フォーマットに関する情報。

printfスタイルの文字列フォーマット

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

3.1.3。 リスト

Pythonは、他の値をグループ化するために使用される化合物データ型をいくつか知っています。 最も用途が広いのは 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[:]
[1, 4, 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]

append() method を使用して、リストの最後に新しいアイテムを追加することもできます（メソッドについては後で詳しく説明します）。

>>> 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。 プログラミングへの第一歩

もちろん、Pythonを使用して、2つと2つを足し合わせるよりも複雑なタスクを実行できます。 たとえば、フィボナッチ数列の最初のサブシーケンスを次のように記述できます。

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

この例では、いくつかの新機能を紹介します。

• 最初の行には複数の割り当てが含まれています。変数aとbは同時に新しい値0と1を取得します。 最後の行では、これが再び使用されており、割り当てが行われる前に、右側の式がすべて最初に評価されることを示しています。 右側の式は、左から右に評価されます。

• while ループは、条件（ここではa < 10）が真である限り実行されます。 Pythonでは、Cと同様に、ゼロ以外の整数値はすべてtrueです。 ゼロは偽です。 条件は、文字列またはリスト値、実際には任意のシーケンスにすることもできます。 長さがゼロ以外のものはすべて真であり、空のシーケンスは偽です。 この例で使用されているテストは、単純な比較です。 標準の比較演算子は、Cと同じように記述されています：<（より小さい）、>（より大きい）、==（等しい）、 [X139X ]（以下）、>=（以上）、!=（等しくない）。

• ループの body はインデントです。インデントはPythonのステートメントのグループ化方法です。 インタラクティブプロンプトで、インデントされた行ごとにタブまたはスペースを入力する必要があります。 実際には、テキストエディタを使用してPython用のより複雑な入力を準備します。 すべてのまともなテキストエディタには、自動インデント機能があります。 複合ステートメントを対話形式で入力する場合は、完了を示すために空白行を続ける必要があります（パーサーは最後の行をいつ入力したかを推測できないため）。 基本ブロック内の各行は、同じ量だけインデントする必要があることに注意してください。

• print（）関数は、指定された引数の値を書き込みます。 複数の引数、浮動小数点数、および文字列を処理する方法が、（電卓の例で前に行ったように）記述したい式を記述することとは異なります。 文字列は引用符なしで印刷され、アイテム間にスペースが挿入されるため、次のように適切にフォーマットできます。

  >>> 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などの特殊文字は、一重引用符（'...'）と二重引用符（"..."）の両方で同じ意味を持ちます。 2つの違いは、一重引用符内で"をエスケープする必要がないことです（ただし、\'をエスケープする必要があります）。その逆も同様です。