魔術師見習いのノート

本稿は私のPython学習のメモやまとめ、特にPythonの基本をまとめたものである。学習には主に次の2つの情報源を使用した。

単純文

単純文とは、単一の論理行内に収められる文のことである。

代入文

いくつかの言語では、代入や複合代入は演算の1つであり、式文として記述される。しかしPythonでは、それらは文として独立している。とはいえ、以下のような単純な代入ではその違いは感じないだろう。

v = 5

v = (w = 5) 

v = w = 5

v, w = 5, 10

v, w = w, v

代入とは名前(識別子)をオブジェクトに束縛、または再束縛することである。代入文では既にその名前が束縛されている場合、オブジェクトの参照カウントを1つ減らす。もしオブジェクトの参照カウントが0になった場合、オブジェクトは解放され、そのデストラクタが呼び出される。

>>> class Hoge:
...     def __del__(self): # デストラクタ
...             print("release")
... 
>>> v = Hoge()
>>> v = 0
release
>>> x = y = Hoge()
>>> x = 1
>>> y = 2
release

del文

del文は指定した名前の束縛を解除し、オブジェクトの参照カウントを1つ減らす。もしオブジェクトの参照カウントが0になった場合、オブジェクトは解放され、そのデストラクタが呼び出される。

del x

また、del文はカンマで区切って複数の名前を指定できる。その際、ターゲットは左から右に順に再帰的に削除される。

式文

式文とは演算を行う文のことである。Pythonの演算子の種類と計算順序は以下を参照されたし。

演算子の優先順位

演算子の優先順位は表の上に行くほど高く、下に行くほど低い。同じ優先順位を持つ場合、結合/連鎖に従って評価順が決まる。

v = lambda x, y : x + y
v(1, 2)

break文

break文はwhile文やfor文などのループを終了させる。もしelse節があってもそれは無視される。

continue文

continue文はwhile文やfor文などのループの次の周期の処理へ移動させる。

return文

return文は関数定義内で現れ、制御を関数呼び出し側に戻して指定した値を、式を指定した場合はその評価結果の値を返す。

def func():
  return 5

yield文

ジェネレータ関数では、return文の代わりにyield文を使用する。というよりもyield文を使用した関数定義はジェネレータ関数となる。ジェネレータ関数でreturn文を使用するとエラーとなる。ジェネレータ関数はジェネレータオブジェクトを生成する。例えばこのようなジェネレータ関数を定義したとする。

def myGenerator():
  i = 0
  while i < 5:
    yield i
    i += 1

>>> for x in myGenerator():
...   print(x)
... 
0
1
2
3
4

global文

global文は指定した名前(識別子)をグローバル変数として解釈するようにする文である。global文にはカンマで区切って複数指定できる。

str = "global"
class Cls:
  str = "instance"
  def func1(self):
    pass
    str = "func"
    print(str)
  def func2(self):
    print(str)
  def func3(self):
    print(self.str)

str = "global"
class Cls:
  str = "instance"
  def func1(self):
    global str
    str = "func"
    print(str)
  def func2(self):
    print(str)
  def func3(self):
    print(self.str)

>>> c = Cls()
>>> c.func1()
func
>>> c.func2()
global
>>> c.func3()
instance

>>> c = Cls()
>>> c.func1()
func
>>> c.func2()
func
>>> c.func3()
instance

nonlocal文

関数内の名前(識別子)のスコープのことをローカルスコープという。Pythonでは、関数内で別の関数を定義できるため、内側と外側の関数で名前の競合が発生する。nonlocal文は指定した名前(識別子)が最も近傍のローカルスコープで以前に束縛された変数を参照するようにする。

def exFunc():
  str = "ex"
  def inFunc():
    pass
    str = "in"
    print(str)
  inFunc()
  print(str)

def exFunc():
  str = "ex"
  def inFunc():
    nonlocal str
    str = "in"
    print(str)
  inFunc()
  print(str)

>>> exFunc()
in
ex

>>> exFunc()
in
in

raise文

指定した例外を送出する。

def div(x, y):
  if y==0:
    raise ZeroDivisionError
  return x // y

例外はtry文で受け取り処理を行うことができる。例外については「try文」で詳述する。

assert文

条件が偽だった場合にAssertionErrorを送出する文である。 例えばこのような関数を定義したとする。

def test(left, right):
  assert left < right

>>> test(1, 3)
>>> test(3, 1)
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 2, in test
AssertionError

pass文

pass文は意味のない文であり、構文上何か必要な場合に記述する。例えば、関数定義で処理内容を記述しない場合はこのように書く。

def func(): pass

import文

import文はモジュールのロードに使用する文である。モジュールの読み込み先ディレクトリは、sysモジュールのpathで定義されている。

import文には、asやfromキーワードの組合せでいくつかのパターンがある。以下にいくつか例を示す。

• import sys
  sys.path

• import sys as hoge
  hoge.path

• from sys import path
  path

• from sys import *
  path

import文では、ロードするモジュールは、カンマで区切って複数記述できる。また、指定したモジュールがなかった場合、ImportError例外が送出される。

モジュール

Pythonスクリプトを記述し、ライブラリとして利用できるようにしたファイルをモジュールという。モジュールとモジュールを利用したコードのサンプルを以下に示す。 なおhoge.pyで記述したドキュメントを記述した文字列については、「ドキュメンテーション文字列」で後述する。

hoge.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-
"サンプルモジュールを定義"
class Hoge:
  "サンプルモジュールのクラス"
  def add(self, addee:"被加数", adder:"加数") -> "和":
    "サンプルモジュールのメンバ関数"
    return addee + adder

fuga.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import hoge
h = Hoge()
print(h.add(1, 2))

hoge.pyについて記述したドキュメントは、import後にhelp(hoge)と指定することで閲覧できる。

パッケージ

全ての機能を1つのモジュールに集約するのではなく、複数のモジュールを記述し、それを一括にロードする方法がある。それがパッケージである。パッケージはモジュールと同様にimport文でロードできる。パッケージとは普通のディレクトリであり、必ず__init__.pyというファイルが格納されている。__init__.pyは存在していれば中身が空でも構わない。パッケージの内容は__init__.pyの中身となる。すなわち、"hoge/"というディレクトリのパッケージがあるとする。この時、"import hoge"と行うとロード対象は"hoge/__init__.py"の中身となる。

複合文

複合文とは、2行以上の複数の論理行に収められる文のことである。

if文

if文は分岐文である。if文には次の3つのキーワードがある。

• if
• elif
• else

def func(i):
  if i < 10:
    print("10未満である")
  else:
    print("10以上である")

while文

while文は繰り返し文の1つである。

while 条件式:
  処理1
[else:
  処理2]

また、Pythonのwhile文にはelse節がある。

for x in 1, 2, 3, 4:
  print(x)
else:
  print("loop end")

for文

for文は繰り返し文の1つである。Pythonでは、イテレータを使用し各要素に何らかの処理を行うような場合にfor文を使用する。

for ターゲットリスト in 式リスト :  
  処理1
[else:
 処理2]

>>> for x in 0,1,2,3:
  print(x)

>>> for x, y in [0,10], [5,20], [10,30]:
...     print(str(x) + "," + str(y))
... 
0,10
5,20
10,30

>>> def func():
...     print("hoge")
...     return 1
... 
>>> for x in func(), func():
...     print("fuga")
... 
hoge
hoge
fuga
fuga

Pythonのfor文にはelse節がある。もしループの条件式の評価結果が偽となった場合、ループが終了した後に実行される。break文で終了した場合、else節はスキップされる。

with文

with文を使用すると、開始処理と終了処理があるような場合に、それを明示的に表現した簡潔なコードを記述できる。

with open("./write.txt", "w") as f:
  f.write("Hello\n")
  f.write("ハロー\n")
  f.write("はろー\n")

class Cls:
  def __enter__(self):
    print("begin")
    return self
  def __exit__(self, type, value, traceback):
    print("end")
    return True
  def func(self, str):
    print(str)

>>> with Cls() as c:
...     c.func()
... 
begin
end

with open("./write.txt", "w") as w
  with open("./read.txt", "r") as r:
    print(r.read(), file=w)

with open("./write.txt", "w") as w, open("./read.txt", "r") as r:
  print(r.read(), file=w)

関数定義

関数定義はdefキーワードを使用する。

def add(x, y):
  return x + y

引数

デフォルト引数

関数定義では、引数を省略した際に代入されるオブジェクトを指定できる。

>>> def func(str = "default"):
...     print(str)
... 
>>> func("hoge")
hoge
>>> func()
default

可変引数

Pythonでは、引数の数が任意個数の関数を定義できる。

*arg

タプル型で順に格納される。

>>> def func(arg1, *args):
...     print(args)
...
>>> func(0,1,2,3,4,5)
(1, 2, 3, 4, 5)

**arg

辞書型で格納される。

>>> def func(arg1, **args):
...     print(args)
... 
>>> func(0)
{}
>>> func(0, v=1, w=2)
{'w': 2, 'v': 1}

引数名指定

関数呼び出しで引数を渡す際、引数の名前を指定して渡すことができる。

>>> def add(addee, adder):
...     return addee + adder
... 
>>> add(adder=10,addee=5)
15

関数デコレータ

関数デコレータとは、関数に機能を明示的に追加または変更するための機能である。関数定義は1つ以上の関数デコレータでラップできる。

def decorator_called(f):
  def wrapper():
    print("called ", f.__name__)
    return f()
  return wrapper

@decorator_called
def hello():
  print("Hello, World")

called  hello
Hello, World

ジェネレータ関数

ジェネレータ関数はイテレータの一種で、ジェネレータオブジェクトを作成する関数である。Pythonでは、関数定義でreturn文の代わりにyield文を記述することでジェネレータ関数を定義できる。

def fib():
  x, y = 0, 1
  while True:
    yield x
    x, y = y, x + y

>>> f = fib()
>>> f.__next__()
0
>>> f.__next__()
1
>>> f.__next__()
1
>>> f.__next__()
2
>>> f.__next__()
3
>>> f.__next__()
5

def fib(max):
  x, y = 0, 1
  while x < max:
    yield x
    x, y = y, x + y

>>> f = fib(10)
>>> for x in f:
...     print(x)
... 
0
1
1
2
3
5
8

クラス定義

クラスは次のようにして定義する。

class Cls:
  def __init__(self):     # <コンストラクタ>
    self.str = "instance" # インスタンス変数
    print("called constructor")
  def __del__(self):      # <デストラクタ>
    print("called destructor")
  def func(self, arg0, arg1):
    str = "local"         # ローカル変数
    print(self.str)
    print(str)
    print(arg0)
    print(arg1)

>>> c = Cls()
called constructor
>>> c.func(0, 1)
instance
local
0
1
>>> del c
called destructor

class Hoge:
  def __new__(cls):
    print("new Parent")
    return super().__new__(cls)
  def __init__(self):
    print("init Parent")

>>> h = Hoge()
new Parent
init Parent

継承

継承は次のように記述する。

class Sub(Parent):
  pass

また、Pythonは多重継承をサポートする。多重継承では、基底クラスをカンマで区切って記述する。

class Sub(Parent1, Parent2):
  pass

オブジェクトの型を取得する場合はtype関数を使用する。また、オブジェクトの型が指定したクラスか、そのサブクラスであるかを調べたい場合は、isinstanceを使用する。

>>> class Parent: pass
... 
>>> class Child(Parent): pass
... 
>>> p, c = Parent(), Child()
>>> isinstance(p, Parent)
True
>>> isinstance(c, Parent)
True

カプセル化

Pythonでは、メンバへのアクセス制御の種類はあまり多くない。

• 非公開(private)な名前を設定する場合、名前の接頭辞に__を付ける。
• 前述以外の名前は全て公開(public)な名前となる。

なおPythonでは、非公開な名前はPythonによって名前を変更されるだけで、アクセスは可能である。

ポリモフィズム(多態化)

Pythonでは、メンバ関数は標準でオーバーライド可能である。

演算子の多重定義

Pythonでは、いくつかの特殊関数をオーバーロードすることで演算子の多重定義を実装できる。以下に例をいくつか紹介する。

関数名	演算子	サンプル
__add__(self, other)	+
__sub__(self, other)	-
__mul__(self, other)	*
__truediv__(self, other)	/
__floordiv__(self, other)	//
__mod__(self, other)	%
__pow__(self, other)	**
__lshift__(self, other)	<<
__rshift__(self, other)	>>
__or__(self, other)	|
__and__(self, other)	&
__xor__(self, other)	^
__lt__(self, other)	<
__le__(self, other)	<=
__eq__(self, other)	==
__ne__(self, other)	!=
__gt__(self, other)	>
__ge__(self, other)	>=
__neg__(self)	-
__pos__(self)	+
__call__(self, [args])	()

この他にも累積代入文や型チェックなどをオーバーライドするために、さまざまな特殊関数が用意されている。

クラス関数

クラス変数

クラス関数やクラス変数は次のように関数デコレータで定義できる。

class Cls:
  @classmethod
  def set(cls, v):
    cls.v = v
  @classmethod
  def p(cls):
    print(cls.v)

以下に実行例を示す。

>>> o1, o2 = Cls(), Cls()
>>> o1.set("hoge")
>>> o2.p()
hoge

クラスデコレータ

クラスデコレータとは、クラス定義に処理を加える機能のことである。

import sys
def py_major_version(major):
  def wrap(cls):
    if sys.version_info[0] < major:
      raise RuntimeError("version error")
    return cls
  return wrap

@py_major_version(3)
class Hoge:
  pass

メタクラス

メタクラスは、クラスを生成するためのクラスである。

def ham(self, arg):
  print(arg)

class MetaSpam(type): #組込み型typeを基に
  @classmethod
  def __prepare__(metacls, name, bases):
    print(name)
    print(bases)
    return {'ham':ham}

class Hoge(metaclass=MetaSpam):
  pass

• class クラス名(metaclass=メタクラス)
• class クラス名(親クラス, metaclass=メタクラス)
• class クラス名(metaclass=メタクラス, 引数名=引数)

try文

try文は例外処理やクリーンアップ処理を行う文である。いくつかの言語では、エラー発生を通知するための手段として例外処理機構を持つ。例外処理機構は、呼び出し側へのエラー通知機能や、エラー処理とエラー通知の分離などさまざまな特徴を持つが、本稿ではそれらの詳細については言及しない。

try文は、以下のように例外が送出し得る文をtry節に記述し、送出するとexcept節で受け取ることができる。else節を記述した場合、制御がtry節の末尾までいった場合に実行される。これに対し、finally節を記述した場合、どの節を処理したかに関わらず必ず最後に呼び出される。

def div(x, y):
  try:
    result = x // y
  except ZeroDivisionError:
    result = "Error"
  finally:
    print(result)

また、except節は送出された例外オブジェクトをasで指定した名前に束縛することができる。

class myError(Exception):
  msg = ""

class Cls:
  def func(self):
    e = myError()
    e.msg = "error"
    raise e

c = Cls()
try:
  c.func()
except myError as my:
  print(my.msg) # 画面に"error"を出力

コメント

Pythonには、コメントは#から行末までの1つしかない。

func() # 関数funcを呼び出す。

ドキュメンテーション文字列

Pythonでは、コメントとは別にドキュメントを読み書きする仕組みがある。関数のドキュメントはhelp関数で閲覧できる。

関数アノテーション

関数の引数と返り値を説明するドキュメント(関数アノテーション)は次のように記述できる。

def sum(addee:"被加数", adder:"加数") -> "和":
  return addee + adder

ドックストリング

関数やクラス、モジュールの説明(ドックストリング)は、スイート内の(Pythonの)文が始まる前に文字列リテラルを置くことで記述できる。

def sum(addee:"被加数", adder:"加数") -> "和":
  """
  2つの値を受け取ってその加算結果を返す
  """
  return addee + adder

組込み型

Pythonには、組み込みの型がいくつかある。以下にいくつか紹介する。

論理型(bool)

論理型はTrueかFalseの2つのいずれかの値を持つ。リテラルの書き方もまたTrueかFalseである。

数値型

数値型には次のようなものがある。

型	説明	リテラルの例
整数型(int)	メモリサイズの制限があるだけで無限の定義域を持つ。負の数は2の補数で表しており符号ビットが左に無限に続くような値となる。	10, 0x1a, 017, 0b1011
浮動小数点型(float)	他の言語同様2進数で保持されるため、10進数との誤差が生じる。例えば"0.1+0.1+0.1"は"0.30000000000000004"となるため、"0.1+0.1+0.1==0.3"は偽となる。	3.14, 1e3
複素数型(complex)		3j

数値型のための関数には、絶対値を求める関数absやべき数を求める関数pow、文字列の文字コードを取得する関数ordなどがある。

NotImplemented

Ellipsis

Python独特の型で、それぞれ未実装と省略を表す型。値はそれぞれ1種類しかなく、それぞれ型と同じ名前のリテラルである。評価結果は必ず真となる。

None

Cのvoidに該当する型として、Pythonには値が存在しないことを表すNone型がある。Cのvoid型がオブジェクトも値も持っていないのに対し、None型のオブジェクトは1つだけあり、値も1つだけある。NoneはCのnilにも該当し、Noneの評価結果は常に偽となる。また、Pythonでは関数の返り値を省略した場合はこのリテラルが返される。

データ構造

Pythonのデータ構造には次の3種類がある。

シーケンス型

シーケンス型はシーケンシャルに処理するためのデータ構造である。シーケンス型には以下のようなものがある。

型	説明	リテラル例
tuple	イミュレータブルな配列	(0, 1, 2)
list	ミュータブルな配列	[0, 1, 2]
string	文字列	"aiueo"

シーケンス型の詳細は「シーケンス型」で説明する。

集合型

集合型は非シーケンスなデータ構造である。

型	説明	リテラル例
set	格納順が不定なデータ構造	{1, 2, 3}

辞書型

辞書型はキーでデータにアクセスするデータ構造である。

型	説明	リテラル例
dict	ハッシュ	{"key1":1, "key2":"hello"}

シーケンス型

シーケンス型はシーケンシャルに処理するためのデータ構造である。Pythonのシーケンス型には次の3種類のものがある。

• コンテンナ
• イテレータ
• ジェネレータ

>>> "Hello" in "Hello, World"
True

>>> "Hello" not in "Hello, World"
False

>>> [0,1,2,3] + [4,5,6]
[0, 1, 2, 3, 4, 5, 6]

>>> [1,2,3]*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

>>>"Hello"[1]
e

>>> (0,1,2,3,4,5,6,7,8)[1:-2]
(1, 2, 3, 4, 5, 6, 7)

>>> [0,1,2,3,4,5,6,7,8][1:-2:2]
[1, 3, 5]

>>> len([0,1,2,3])
4

>>> min([0,1,2,3])
0

>>> max([0,1,2,3])
3

>>> [4,3,2,1,0].index(3)
1

>>> [1,2,3,1,4,1].count(1)
3