動的プログラミング言語を知っている人のためのPython入門

原著: Matthew Brett; 翻訳: 黒下彰喜, 本多皓一, 根本清貴

本チュートリアルは、Brisk introduction to Python を、著者のMatthew Brettの許諾を得て翻訳したものです。

---

このページは、動的プログラミング言語を既に理解している人のためのPython入門です。動的プログラミング言語には、MatlabやRがあげられます。

このページの使い方

このページを最初から最後まで通して読んでください。 Pythonのすべての基本的なデータ型を扱うとともに、関連するPythonの言語の特徴を説明します。

読みながら Jupyter notebook を開き、コードを打ち込むかコピー＆ペーストして実行すると良いでしょう。

このページが終わるまでには、Pythonの概要が理解でき、この言語を学ぶときの導きになるでしょう。

数

Pythonには２種類の数があります。それは整数と浮動小数点です。 Pythonにおいて、整数はint型オブジェクトで、浮動小数点はfloat型オブジェクトです:

a = 99

print(type(a))

<class 'int'>

b = 99.0

print(type(b))

<class 'float'>

int型とfloat型は、 int と float を使って次のように作ります:

float('1')

1.0

float(1)

1.0

int('1')

1

int(1)

1

int型とfloat型がまざった四則演算の結果はfloat型になります:

a + b

198.0

a * b

9801.0

int型をint型で割ってもfloat型になります。ただしこれはPython3以降での話です。(脚注[1]参照):

1 / 2

0.5

割り算において、商だけ必要なときは、 // を使います:

1 // 2

0

1.0 // 2.0

0.0

Pythonには round と呼ばれる組み込み関数があります: (訳注: 偶数への丸めであり、四捨五入ではありません)

round(5.0 / 2.0)

2

% 演算子は、整数の割り算における余りを出力します（modとも言います）:

5 % 2

1

5.0 % 2.0

1.0

True と False

True と False はPythonでは特別なオブジェクトです。これらは真偽を表すためのブール型です:

type(True)

bool

type(False)

bool

True == False

False

True == True

True

False == False

True

ブール値を使った論理式には、論理演算子 and, or そして not が使えます:

True and True

True

True and False

False

True or False

True

False or False

False

not True

False

True and not False

True

None

None もPythonでは特別なオブジェクトです。Pythonの作法として、操作の結果適切な値が得られなかった場合や、パラメータの値がない場合、しばしば None を使います:

type(None)

NoneType

Pythonの他の値とは違い、 None はデフォルトでは何も表示されません：

None

等号

MATLABやRと同様に、= は代入に使い、== は等しいことの評価に使います：

a = 1
a

1

a == 1

True

Rと同様に、Python は != をオブジェクト同士が等しくないことの評価に使います。 ~= を使うMATLABとは異なります：

a != 1

False

“If” 文、ブロック、インデント

Pythonで条件文は次のようになります：

my_var = 10
if my_var == 10:
    print("The conditional is True!")
    print("my_var does equal 10")

The conditional is True!
my_var does equal 10

条件文の１行目には、条件式を記載し、コロンで終わります。これをif式と呼びましょう。 if式に続けてインデントされた行が続きます。これらのインデントされた行をifブロックと呼びます。 Pythonはif式が True のときだけifブロック内の文を実行します。 例えば次の場合、if式が False なので、ブロックは実行されません：

my_var = 11
# 今回は条件は False になります
if my_var == 10:  # "if テスト"
    # インデントがついている行が "if ブロック" になります
    print("The conditional is True!")
    print("my_var does equal 10")

if式と同じレベルのインデントに戻った行で、ブロックが終わります。 ifブロック内に別のインデントされたブロック（例えば別のifブロック）がなければ、ブロック内のすべての行は同じインデントになります。 RとMATLABのif文については注[2]を参照してください。 ifブロックに条件文 else: の別のブロックが続く場合があります。 そのブロックは最初の条件式が False のときだけ実行されます:

my_var = 11
if my_var == 10:
    print("The conditional is True!")
    print("my_var does equal 10")
else:
    print("The conditional is False!")
    print("my_var does not equal 10")

The conditional is False!
my_var does not equal 10

さらに他の条件ブロックを持つ条件式がある場合もあります。そのときは elif 条件式 を使います。elif は else if の略です：

my_var = 12
if my_var == 10:
    print("The conditional is True!")
    print("my_var does equal 10")
elif my_var == 11:
    print("The second conditional is True!")
    print("my_var does equal 11")
elif my_var == 12:
    print("The third conditional is True!")
    print("my_var does equal 12")
else:
    print("All conditionals are False!")
    print("my_var does not equal 10, 11 or 12")

The third conditional is True!
my_var does equal 12

“While” 文

while文も最初の条件式にインデントされたブロックが続きます。1000未満のフィボナッチ数のうち最も大きい数を見つけ出す例を示しましょう：

last_but_1 = 0
fibonacci = 1
while fibonacci < 1000:
    last_but_2 = last_but_1
    last_but_1 = fibonacci
    fibonacci = last_but_2 + last_but_1
print("Largest Fibonacci < 1000 is", last_but_1)

Largest Fibonacci < 1000 is 987

最初のwhile条件式: while fibonacci < 1000: に注目してください。この後にインデントされたwhileブロックが続きます。if文とは異なり、Pythonはwhile条件式がFalseと判定されるまではwhileブロック内に記述された文を実行し続けます。

リスト

リストは以下のようにして作成します：

my_list = [9, 4, 7, 0, 8]

my_list

[9, 4, 7, 0, 8]

type(my_list)

list

リストの要素にはどのオブジェクト型でも使うことができます。要素にリストを使うこともできます：

mixed_list = [9, 3.0, True, my_list]

mixed_list

[9, 3.0, True, [9, 4, 7, 0, 8]]

type(mixed_list)

list

PythonのリストはMATLABにおけるセル配列やRにおけるリストに似ています。

“for” ループと繰り返し

リストに対しては繰り返し処理ができます。繰り返しとは、リストのようなコンテナ（訳注：複数のオブジェクトを格納できるデータ型のこと）から要素を次々に取り出すことです。リストからの繰り返しにはforループを利用できます：

for e in my_list:
    print(e)

9
4
7
0
8

forループはif文やwhileループと同様に、最初の行がコロンで終わり、そこにインデントされたブロックが続きます。

forループの最初の行は、次のようになります：for ループ変数 in コンテナ:。このコンテナとはそこから要素を取り出すためのものです。forループの繰り返しにおいて、Pythonはコンテナから新しい要素を取り出し、ループ変数に代入します。コンテナの各々の要素に対してPythonはforブロックを実行します。

脚注[3]にPython、R、MATLABでの同じ内容を表すforループを示しました。

連続整数に対する繰り返しにおいてforループをどのように書くかについては、Rangeのセクションを確認してください。

リストはシーケンスである

シーケンスはPythonオブジェクトの型の1つです。決まった要素の順番を持ち、長さを持ち、イテラブル(繰り返し可能)であり、整数でインデックス付けすることができ、スライスができます(下記参照)。もしオブジェクトsがシーケンスならば、以下のようになります：

• sは長さを持ち、それはlen(s)で分かります;

• for 要素 in s: # 要素を用いた処理 の形でsの要素に対する繰り返し処理が行えます;

• 位置nの要素は s[n] で取得できます;

• sをスライスすることで別のシーケンスのオブジェクトを作成できます。例えば、 s[0:n] は、sの最初からn個の要素を含む新たなシーケンスとなります。

# 長さを持ちます
len(my_list)

5

# 繰り返せます
for e in my_list:
    print(e)

9
4
7
0
8

# インデックスで特定の要素を表示できます
my_list[1]

4

# スライスできます
my_list[0:2]

[9, 4]

Pythonのインデックスは0を基準とする

Pythonでは、シーケンスのインデックスは0から始まります。最初の要素にはインデックス0が、2番目の要素にはインデックス1が割り当てられ、以下同様に続きます：

my_list[0]

9

my_list[1]

4

負のインデックス

インデックスに負の数を使うと、リストの終わりから逆順に数え上げられます。例えば、インデックス -1 を使うとリストの最後の要素を取得できます：

my_list

[9, 4, 7, 0, 8]

my_list[-1]

8

上の -1 のインデックスは以下と同じです：

my_list[len(my_list) - 1]

8

最後から3番目の要素はこうなります：

my_list[-3]

7

全てのPythonの変数はポインタである

Pythonでは、変数名はオブジェクトがメモリ上に保存されている場所を指し示します。そのため、Pythonの変数はポインタと呼ばれることもあります。

標準的なPythonを実行している場合、変数がメモリ上のどこにあるかを id() 関数を用いて確認することが出来ます。コンピュータのメモリ上の場所を示すいくらか長い整数が出力されます：

id(my_list)

139943313314568

another_variable=a_variable を実行する場合、 another_variale という名称は a_variable という名称と同じオブジェクトを指し示すということを伝えていることになります。そのため、その変数はメモリ上の同じ場所を指し示します:

another_list = my_list

another_list

[9, 4, 7, 0, 8]

id(another_list)

139943313314568

id(another_list) == id(my_list)

True

リストは変更可能である

リストはミュータブル mutable なオブジェクトです。ミュータブルとは、新しいリストを作らなくてもリストの要素を変更できるということを意味します:

my_list[1] = 99

my_list

[9, 99, 7, 0, 8]

リストはミュータブルなため、全てのPython変数がポインタであることは心に留める必要があります：

another_list = my_list

another_list

[9, 99, 7, 0, 8]

id(another_list) == id(my_list)

True

my_listはanother_listと同じオブジェクトを指し示すため、my_list(によって指し示されるオブジェクト)を修正すると、another_listの値も修正されます。なぜならmy_listとanother_listとは同じリストを指し示すからです：

my_list[1] = 101

another_list

[9, 101, 7, 0, 8]

リストの結合

2つのリストを+で足し合わせると、2つのリストを連結した新たなリストが出力されます：

new_list = my_list + [False, 1, 2]

new_list

[9, 101, 7, 0, 8, False, 1, 2]

要素の追加と除去

append メソッドで要素を追加することができます。

メソッドは、オブジェクトに備わっている関数です。Pythonにおける関数について詳しくは関数のセクションをご覧ください。

appendがメソッドであることはmy_list.appendの値を表示することで分かります：

my_list.append

<function list.append>

メソッドを呼び出すには、メソッドに渡したい引数をかっこ内に加えます。この場合追加する要素に引数が渡されます：

my_list.append(20)

my_list

[9, 101, 7, 0, 8, 20]

appendメソッドはリストを返さず、その場でリストを変更してしまうことに注意しましょう。PythonではappendメソッドからはNoneが返ってきます：

result = my_list.append(42)

result == None

True

他のメソッドでも直接リストを変更するものがあります。例えば sort メソッドです：

new_list = [10, 1, 3]

result = new_list.sort()
# 戻り値は None です

result == None

True

# しかし、元のリストはソートしたために昇順になっています
new_list

[1, 3, 10]

pop メソッドを使うとリストから要素を除去できます：

# リストから最後の要素を除いたリストを返します
my_list.pop()

42

my_list

[9, 101, 7, 0, 8, 20]

# リストから3番目の要素を除いたリストを返します
my_list.pop(2)

7

my_list

[9, 101, 0, 8, 20]

スライス

リストなどのシーケンスからは、一部を切り出すことができます。これをスライスと呼びます。スライスするには、取り出したい領域を指定子として角括弧に入れます。例えば、ここではリストの最初の3要素が返されます：

my_list[0:3]

[9, 101, 0]

角括弧の後、そして、コロンの前にある最初の数字は、開始インデックスです。この場合、インデックスは0なので、最初の要素からはじまります。コロンの後の2番めの数字は終止インデックスです。この数字は終わりのインデックスに1を足したものになります。この場合はインデックス0, 1, 2を返すことになります。つまり、要素はインデックス3まで返すのですが、インデックス3は含まれないということになります。

最初の数字(開始インデックス)を省略した場合、Pythonは開始インデックスは0とみなします：

my_list[:3]

[9, 101, 0]

2番目の数字を省略した場合、Pythonはリストの長さを終止インデックスと見なします：

my_list[2:]

[0, 8, 20]

my_list[2:len(my_list)]

[0, 8, 20]

どちらの数字も省略することもでき、その場合リストの要素全てが返されます。これは、最初のリストと同じ要素を含む新規のリストを作りたい場合に有用です：

another_list = my_list[:]

another_list

[9, 101, 0, 8, 20]

これは新規のリストオブジェクトであるので、オリジナルのリストを変更しても新規のリストは変更されません：

my_list[1] = 999

another_list

[9, 101, 0, 8, 20]

2番目のコロンと3番目の数字を指定することもできます。このとき、3番目の数字がステップサイズです。例えば、リストの1つおきの要素を取得するなら：

my_list[0:len(my_list):2]

[9, 0, 20]

# 終止インデックスが省略された場合、リストの長さが終止インデックスとみなされます
my_list[0::2]

[9, 0, 20]

開始インデックスと終止インデックスに負の数を使うことができます。インデックスに関しては、負の開始値と終止値はリストの終わりから逆順に数えます:

my_list

[9, 999, 0, 8, 20]

my_list[-4:-2]

[999, 0]

ステップに負の数を用いると、開始インデックスから終止インデックスまで逆順に数えます:

my_list[4:1:-1]

[20, 8, 0]

負のステップサイズを用い、開始インデックスを指定しなかった場合、開始インデックスのデフォルトはリストの最後の要素となります。終止インデックスを指定しなかった場合は、終止インデックスはインデックス0より左側となります:

my_list

[9, 999, 0, 8, 20]

my_list[-1:1:-1]

[20, 8, 0]

my_list[:1:-1]

[20, 8, 0]

my_list[-2::-1]

[8, 0, 999, 9]

覚えておく価値があることは、 [: : -1] で中を逆順にしたリストのコピーが得られるということです：

my_list[::-1]

[20, 8, 0, 999, 9]

タプル

タプルはリストとほとんど同じものです。ただしリストと異なりミュータブルでありません。つまり、タプルの要素も、要素の数も変更不可能です:

my_tuple = (9, 4, 7, 0, 8)

my_tuple

(9, 4, 7, 0, 8)

my_tuple[1] = 99

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-102-0f927aac1466> in <module>
----> 1 my_tuple[1] = 99

TypeError: 'tuple' object does not support item assignment

これは空のタプルです：

empty_tuple = ()

empty_tuple

()

2つの要素を持つタプルです：

two_tuple = (1, 5)

two_tuple

(1, 5)

1つの要素でタプルを作るときには少し複雑なことがあります：

not_a_tuple = (1)

not_a_tuple

1

これは、この式をかっこで囲まれた表現ではなくタプルとしたい、という意図をPythonが認識できないことによります：

not_a_tuple = (1 + 5 + 3)

not_a_tuple

9

この式は長さ1のタプルとしたい、という意図をPythonに伝えるには、要素の後ろ、かっこ閉じの前にカンマを加えます：

one_tuple = (1,)

one_tuple

(1,)

文字列

文字列はこのように作ります：

my_string = 'interesting text'

my_string

'interesting text'

文字列については、シングルクォーテーションでもダブルクォーテーションでも使うことができ、どちらも同義です：

another_string = "interesting text"

another_string

'interesting text'

my_string == another_string

True

str を使って他のオブジェクトを文字列に変換します:

# 整数型を文字列に変換します
str(9)

'9'

# 浮動小数点型を文字列に変換します
str(1.2)

'1.2'

文字列はシーケンスである

リストと同様に、文字列はシーケンスです。つまり、長さを持ち、繰り返し可能で、インデックスが使え、スライスもできます:

# 長さを持つ
len(my_string)

16

# 繰り返せる
for c in my_string:
    print(c)

i
n
t
e
r
e
s
t
i
n
g
 
t
e
x
t

# インデックスが使える
my_string[1]

'n'

# スライスできる
my_string[1:5]

'nter'

文字列は変更不可能である

リストと異なり、文字列はイミュータブルであり、変更不可能です。文字列内の文字は変更できません：

my_string[1] = 'N'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-124-ebca256d5213> in <module>
----> 1 my_string[1] = 'N'

TypeError: 'str' object does not support item assignment

文字列の結合

my_string + ' with added insight'

'interesting text with added insight'

文字列のメソッド

文字列には、様々な興味深いメソッドが備わっています。Jupyter Notebookで、文字列の変数名の後にピリオドを打ってからタブ補完を試してみてください。例えば、 my_string. とタイプしてからタブキーを押します。Python docsにあるstring methodsのリストも見てみましょう。

興味深いメソッドのひとつに replace があります。このメソッドは入力した文字列のコピーを返しますが、文字列を別の文字列に置き換えてから返します:

another_string = my_string.replace('interesting', 'extraordinary')

another_string

'extraordinary text'

オリジナルの文字列は変更されていない(変更不可能である)ことに注意しましょう：

my_string

'interesting text'

文字列を分割してリストにするには、splitメソッドを使います。デフォルトでは、splitは文字列をあらゆる空白(スペース、タブ区切り、改行)で分割します：

my_string.split()

['interesting', 'text']

ある文字で文字列を分割するには、その文字をsplitに渡します：

another_example = 'one:two:three'

another_example.split(":")

['one', 'two', 'three']

stripメソッドは、文字列の最初と最後からスペース、タブ、行末文字を取り除いた文字列を返します：

# 文字列の最後に改行コードである\n をつけます
my_string = ' a string\n'

my_string

' a string\n'

my_string.strip()

'a string'

値の文字列への挿入

Inserting values into strings を参照してください。(訳注：別の文書のため、まだ訳されていません)

Range型

Python3において、 range は rangeオブジェクトを返します。rangeオブジェクトはシーケンスのため、かなりリストに似ています[4]。rangeで引数を1つのみ使うと、引数の値は終止インデックスとなります。例えば、0から5まで、しかし5を含まないようなrangeオブジェクトを作るには以下のようにします:

my_range = range(5)

my_range

range(0, 5)

listを使うと rangeオブジェクトをリストに変換できます：

list(range(5))

[0, 1, 2, 3, 4]

rangeオブジェクトはシーケンスです：

# 長さを持つ
len(my_range)

5

# 繰り返せる
for e in my_range:
    print(e)

0
1
2
3
4

# インデックスが使える
my_range[1]

1

# スライスできる
my_range[0:2]

range(0, 2)

引数を2つ渡すと、rangeの開始要素を指定できます：

my_range = range(1, 7)

my_range

range(1, 7)

list(my_range)

[1, 2, 3, 4, 5, 6]

3番目の引数でステップサイズを指定できます：

my_range = range(1, 7, 2)

my_range

range(1, 7, 2)

list(my_range)

[1, 3, 5]

rangeをよく使う場面としては、forループで一連の数だけ繰り返す場合です：

for i in range(5):
    print(i)

0
1
2
3
4

セット

セットは順番が決まっていない要素の集まりです。要素の順番はPythonが決めます：

# セットでは要素は重複しません
my_set = set((5, 3, 1, 3))

my_set

{1, 3, 5}

決まった順番がないので、セットにインデックスを付けることはできません：

my_set[1]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-151-d447519d8314> in <module>
----> 1 my_set[1]

TypeError: 'set' object does not support indexing

addメソッドでセットに要素を加えることができます：

my_set.add(10)

my_set

{1, 3, 5, 10}

セットの要素は一意でなければならず、既にセット内にある要素を加えてもセットは変化しません：

my_set.add(5)

my_set

{1, 3, 5, 10}

セットでも繰り返しはできますが、要素の順序は任意です。プログラムの2度の実行で同じ順序になるとは限りません:

# 要素の順番は決まっていません
for element in my_set:
    print(element)

1
10
3
5

difference, union, intersectionといった興味深い操作については、セットオブジェクトのメソッドを見てください。

セット、リスト、タプルはコンテナである

コンテナは要素に対し、そのコンテナに属しているかどうかを確かめることができるオブジェクトです。オブジェクトcがコンテナである場合、ある要素がそのコンテナに属しているかどうか、 要素 in c の結果が True か False かで確かめることができます。

注意してください。 inという単語はfor 要素 in c:とtrue_or_false = 要素 in cとで違う意味を持ちます。for 要素 in c:では、inはforループ構文の一部です。true_or_false = 要素 in cでは、inは要素がコンテナに属しているかどうかを確認し、 True か False を返すトリガーとなっています:

5 in my_set

True

11 in my_set

False

要素がコンテナに入っていないことを確かめるには not in を使います：

11 not in my_set

True

リストとタプルもコンテナです：

9 in [9, 4, 7, 0, 8]

True

3 in (1, 3, 5)

True

辞書

辞書は順序を持たず、「キー key」と「値 value」がペアになったものです。キーは要素を特定するもので、値は各キーに対応する値です:

# 空の辞書を作ります
software = {}

ここで、キーと値のペアを辞書に追加します。キーは文字列 'MATLAB' 、それに対応する値は整数の 50 です：

software['MATLAB'] = 50

software

{'MATLAB': 50}

別のキーと値のペアを追加します：

software['Python'] = 100

software

{'MATLAB': 50, 'Python': 100}

あるキーに対応する値は、辞書とキーを指定することにより取り出します：

software['Python']

100

辞書でキーを取り出して繰り返し処理することができます。しかしキーの順序は一意ではありません。Pythonが決めた順序でキーを返します。そしてプログラム中で毎回同じ順序になるとは限りません：

for key in software.keys():
    print(key)

MATLAB
Python

値で繰り返し処理することもできますが、上記と同じく順序は一意ではないという制約があります：

for value in software.values():
    print(value)

50
100

キーと値のペアで繰り返し処理を行うには items メソッドを使います。この場合、要素は長さ2のタプルで、第1の要素がキー、第2の要素が値となります：

for key_value in software.items():
    print(key_value)

('MATLAB', 50)
('Python', 100)

辞書は中括弧を使っても作れます。コロンでキーと値を分け、コンマでペアを分けます：

software = {'MATLAB': 50, 'Python': 100}

software

{'MATLAB': 50, 'Python': 100}

キーは重複があってはいけません。同じキーがあった場合、最初のキーと値のペアは、後のキーと値のペアで上書きされます：

software = {'MATLAB': 50, 'Python': 100, 'MATLAB': 45}

software

{'MATLAB': 45, 'Python': 100}

辞書はコンテナである

辞書もコンテナです。Pythonはコンテナの要素をキーで取り出します。あるキーが辞書に含まれるかを確認するのは次の方法が便利でしょう：

'MATLAB' in software

True

'happiness' in software

False

“for”, “while”, “continue”, “break”

for文とwhile文はループです。for に指定した要素を全部使い切るか、 while 条件が False になるまで、Pythonは for や while のブロックを実行し続けます。break文を使ってループから抜けられます:

for i in range(10):
    if i == 6:
        break
    print(i)

0
1
2
3
4
5

continue文は、for や while ブロックにおいて、現在の繰り返し分の実行を切り上げ、次の繰り返しから再開します：

for i in range(10):
    if i == 6:
        continue
    print(i)

0
1
2
3
4
5
7
8
9

ループと break について更に詳しく知りたい場合は、 “for” and “while”, “break” and “else:” を参照してください。

関数

関数をPythonで作ってみます：

def my_function(an_argument):
    return an_argument + 1

関数の定義は、キーワード def と続いて半角スペース1つで始まります。関数名 my_function がその次に来ます。次に丸括弧と、関数に渡す引数の指定が続きます。今回の場合、関数が想定している引数は1個です。この関数では、実行開始時に入力された引数の値に an_argument という名前が付きます。最後に、関数が呼び出されたときに実行するコードのインデントブロックが来ます:

my_function(10)

11

my_function に丸括弧で囲んだ引数を付けて呼び出します。関数は、変数 an_argument に10が代入された状態で実行されます。この関数は 10 + 1 = 11 を返します。

引数なしの関数もできます：

def my_second_function():
    return 42

my_second_function()

42

return文がない関数もできます。return文がない場合、その関数はNoneを返します:

def function_with_no_return():
    # return文がない関数
    a = 1

function_with_no_return() == None

True

複数の引数を受け入れる関数もできます:

def my_third_function(first_argument, second_argument):
    return first_argument + second_argument

my_third_function(10, 42)

52

引数の初期設定値

関数を定義する際、引数に初期設定値を与えることができます：

def my_fourth_function(first_argument, extra_argument=101):
    return first_argument + extra_argument

この関数は my_third_function と同じく2個の引数を持ち、my_third_function と同じ呼び出し方ができます：

my_fourth_function(10, 42)

52

一方、初期設定値があるので2番目の引数を省略することもできます。その場合、その引数には初期設定値が使われます：

my_fourth_function(10)  # 1番目の引数を渡し、2番めは初期設定値を使う

111

これまでの例では、引数を順番で渡してきました。つまり、最初の引数が関数の第1引数となったわけです。引数は名前で渡すこともできます。たとえば、extra_argument を変数名と値で次のように渡せます：

my_fourth_function(10, extra_argument=202)

212

引数をこの方法で渡すことはコードの可読性を向上させます。なぜなら、関数において引数名を見ればそれが何の目的で使われるのか手がかりになることがあるからです。多くの変数に初期設定値を与えることも有用です。その場合、引数名を使うことで、初期設定値と異なる一部の引数を渡すことが楽にできるようになります。

関数もオブジェクトである

Pythonではすべてがオブジェクトであることを覚えておいてください。関数もオブジェクトであり、関数名は変数で、その変数の型を調べると関数であることがわかります：

my_fourth_function

<function __main__.my_fourth_function(first_argument, extra_argument=101)>

type(my_fourth_function)

function

関数を呼び出す時は、関数名の後に丸括弧で囲まれた引数を付けます：

my_fourth_function(10)

111

その他のPythonの変数と同様に、同じ関数を指す別の名前を簡単に作ることができます：

another_reference_to_func4 = my_fourth_function

type(another_reference_to_func4)

function

# 関数を新たな名前で呼び出す
another_reference_to_func4(10)

111

並べ替え Sorting

Pythonの sorted 関数は何かを並べ替えて、繰り返し処理が可能なリスト型にして出力します:

sorted('adcea')

['a', 'a', 'c', 'd', 'e']

sorted((1, 5, 3, 2))

[1, 2, 3, 5]

並べ替えの際、Python は ある要素 < 別の要素 で比較します。例えば、先ほどの並べ替えをするためにPythonは以下の結果を必要とします：

3 < 5

True

要素を単に比較するのではなく、その他の方法でオブジェクトを並べたいこともあります。その場合、ソートするための関数を定義できます。この関数は、要素を引数として受け取り、並べ替えに用いられる値を出力します。Pythonは要素自体でなく、並べ替えに用いられる値を使って並べ替えを行います。

例えば、タプルとして並べたファーストネームと苗字があったとします：

people = [('JB', 'Poline'), ('Matthew', 'Brett'), ('Mark', 'DEsposito')]

デフォルトでは、Pythonはタプルをまず第1の値で比較、次に第２の値で比較、…というように比較します。今回の例の場合だと、ファーストネームの順に並ぶことになります:

('Matthew', 'Brett') > ('Mark', 'DEsposito')

True

sorted(people)

[('JB', 'Poline'), ('Mark', 'DEsposito'), ('Matthew', 'Brett')]

これは望んだ結果ではないかもしれません。タプルの第２の値である苗字で並べたい場合もあるでしょう。そのような場合、要素を入力(この場合はタプル)として受け取り、値（苗字）を出力する並べ替えのための関数を作れます:

def get_last_name(person):
    return person[1]  # 苗字を返す

Pythonではすべてがオブジェクトであることを思い出してください。今、定義したこの関数も、get_last_name という名のオブジェクトです：

get_last_name

<function __main__.get_last_name(person)>

この値を並べ替えのために関数 sorted に渡すことができます。その際、key というパラメータを使って渡します。

sorted(people, key=get_last_name)

[('Matthew', 'Brett'), ('Mark', 'DEsposito'), ('JB', 'Poline')]

ファイル

ファイルを異なるモードで開くことができます。モードによってファイルを読むか書くか、ファイル内のデータがテキスト(文字列)かバイナリ(バイト)かが決まります。例としてファイルを、テキストを書く(wt)ために開きます。 (訳注："wt”モードで既存のファイルを開くと上書きされ元の内容は失われます。既存のファイルに追記する場合は"at”モードで開きます):

my_file = open("a_text_file.txt", "wt")

バイナリ(バイト)データを書く場合、モードは wb (Write Binary)を使います。通常、Jupyter notebook では オブジェクト名の後にピリオドをつけ (例えば my_file.)、そしてTabキーを押すと、この新規ファイルのアトリビュートやメソッドの一覧を表示することができます。

ファイルに書き込むには、write メソッドを使います:

# 文章を書き、最後に改行を意味する \n をつけます
# このメソッドは書かれた文字数を返します
my_file.write("MATLAB is good for matrices\n")

28

# 別の行を追加します
my_file.write("Python is good for coding\n")

26

終わったらファイルを close します:

my_file.close()

ファイルを読み込むときは、read モードで開きます:

# ファイルを読み込みモードで開きます
my_file2 = open("a_text_file.txt", "rt")

引数なしで read メソッドを呼び出すと、ファイルの内容をすべて読み込みます:

contents = my_file2.read()

print(contents)

MATLAB is good for matrices
Python is good for coding

後でファイルを close することを忘れないでください:

my_file2.close()

テキストファイルはイテラブル（繰り返し可能）であり、1行ずつ表示できます。for ループ内でファイルオブジェクトに内容を１行づつ出力させることもできます:

my_file2 = open("a_text_file.txt", "rt")

for line in my_file2:  # オブジェクト内の各行に対して繰り返します
    print("Line is:", line)

Line is: MATLAB is good for matrices

Line is: Python is good for coding

my_file2.close()

脚注

[1] Python 3では整数同士の割り算は浮動小数点で返されますが、Python 2では商の整数部分が返されます。そのためPython 2では、1 / 2 の結果は 1 // 2 の結果すなわち 0 と同じです。自作のコードを Python 2で使うときは、整数同士の割り算でPython 3と同じ結果になるように、 from future import division をソースコードファイルの最初に追加しておいて下さい。

[2]

Pythonのif文です:

# Python
my_var = 10
if my_var == 10:
    print("The conditional is True!")
    print("my_var does equal 10")

同じものがRではこうなります:

# R
my_var = 10
if (my_var == 10) {
    print("The conditional is True!")
    print("my_var does equal 10")
}

MATLABの場合:

% MATLAB
my_var = 10;
if my_var == 10
    disp('The conditional is True!');
    disp('my_var does equal 10');
end

Pythonではインデントでブロックが決まります。RやMATLABでは、インデントはコードの見た目を良くするための意味合いしかありません。RやMATLABでは、インデントなしのコードは同じように動きますが、ほとんどの人は読みにくいと感じるでしょう:

# R
my_var = 10
if (my_var == 10) {
# Indentation is optional
print("The conditional is True!")
print("my_var does equal 10")
}

% MATLAB
my_var = 10;
if my_var == 10
% Indentation is optional
disp('The conditional is True!');
disp('my_var does equal 10');
end

[3]

これはPythonのループです:

# Python
for element in [9, 4, 7, 0, 8]:
    print(element)

同じものがRとMATLABではこうなります:

# R
for (element in list(9, 4, 7, 0, 8)) {
    print(element)
}

% MATLAB
for element = {9, 4, 7, 0, 8}
    disp(e);
end

[4]

Python 2では、 range関数は list型を返します。 Python 3のrange型オブジェクトは大抵list型と同じように使えますので、おそらくコードを扱う側にとって Python 2 と 3 の違いは問題にならないでしょう。ただ、list型はできても range型ではできないもの(追加など)が存在します。例えば、 range(4) + range(5) は Python 2だと動きますが(listの結合)、Python 3だと失敗します(rangeオブジェクトは結合できません)。