かばんを渡すとき：関数と引数

昼休み、スタートアップの開発者がノートパソコンを抱えて駆け込んできます。最初のお客さんの注文はコーヒー一杯だったのに、二人目のお客さんのレシートにコーヒーとベーグルが一緒に印刷されたというのです。

ド・ミラン班長が、関数定義の1行を指でたどります。「かばんを渡すときは、かばんじゃなくてタグがもう一枚付くんだ。それに、この空のかばんは、関数を作ったときに一度だけ買ったものだね」

4-1. 関数はかばんにタグをもう一枚付ける (11分)

関数を呼んでも、引数として渡したオブジェクトはコピーされません。関数の中の引数名が、同じオブジェクトにタグとしてもう一枚付くのです。これをオブジェクト参照渡し（call by object reference、call by sharing）といいます。

mine = ["laptop"]
def show(bag):
    print(bag is mine)
show(mine)
# True

タグがもう一枚付いただけなので、1限目の二つの動作がそのまま当てはまります。

• かばんの変更：関数の中で bag.append(...) のように中身を変えると、外側の名前からも見えます。同じかばんだからです。
• タグの付け替え：関数の中で bag = ... と再束縛すると、関数の中のタグだけが移ります。外側の名前は元のかばんに付いたままです。

def pack(bag):
    bag.append("charger")

def swap(bag):
    bag = ["new"]
    bag.append("charger")

mine = ["laptop"]
pack(mine)
print(mine)
# ['laptop', 'charger']
swap(mine)
print(mine)
# ['laptop', 'charger']

下のタグボードには、初めて呼び出し枠（フレーム）が登場します。関数を呼ぶと左側に pack の枠ができ、その中のタグ bag が外側の mine と同じかばんを指します。関数が終わると枠は消えます。

2限目の += がここで再び出てきます。同じ += でも、型によって外側から見えたり見えなかったりします。

def bump(n):
    n += 1          # int：新しいオブジェクト。関数の中のタグだけを付け替える

def extend(lst):
    lst += [1]      # list：__iadd__。同じかばんを変える

count, items = 0, []
bump(count)
extend(items)
print(count, items)
# 0 [1]

Pythonには「外側の変数を書き換える引数」はありません。関数が外側に影響を与える道は、受け取ったミュータブルなオブジェクトを変えるか、値を返すかのどちらかだけです。

4-2. デフォルト引数は定義したときに一度だけ作られる (11分)

届出人の関数を縮めると、こうなります。

def f(x=[]):
    x.append(1)
    return x

print(f())
# [1]
print(f())
# [1, 1]
print(f.__defaults__)
# ([1, 1],)

デフォルト値 [] は、関数を呼ぶときではなく、def 文が実行されるときに一度だけ計算されます。そうして作られたリストは関数オブジェクトの __defaults__ タプルにぶら下がり、関数が生きているあいだ残ります。引数を省略して呼ぶたびに、引数 x はその一つしかないリストに付くのです。

print(f() is f.__defaults__[0])
# True

下のタグボードで、2回の呼び出しを追ってみてください。呼び出し枠はできては消えますが、defaults にぶら下がったリストはずっと残り、注文が積み重なっていきます。

直し方は決まっています。デフォルト値には None を置き、関数の中でそのつど新しいリストを作ります。

def add_order(item, orders=None):
    if orders is None:
        orders = []
    orders.append(item)
    return orders

print(add_order("coffee"), add_order("bagel"))
# ['coffee'] ['bagel']
print(add_order.__defaults__)
# (None,)

None 自体が意味のある値で、「引数が渡されなかった」と区別しなければならないときは、誰も使わないオブジェクトを一つ作って番兵（sentinel）にします。世界に一つしかないオブジェクトなので、is で比べます。

_MISSING = object()

def lookup(key, default=_MISSING):
    if default is _MISSING:
        return f"no default for {key}"
    return default

print(lookup("gate"), lookup("gate", None))
# no default for gate None

• 危ないのはデフォルト値の []、{}、set() だけではありません。def のときに一度だけ計算されるという規則は、すべてのデフォルト値に同じように当てはまります。
• キーワード専用引数のデフォルト値は、f.__kwdefaults__ に別にぶら下がります。

4-3. 変える関数と、新しく返す関数 (7分)

関数は二種類に分けて考えると楽です。受け取ったかばんをその場で変える関数と、元はそのままにして新しいかばんを返す関数です。

nums = [3, 1, 2]
print(nums.sort(), nums)
# None [1, 2, 3]

nums = [3, 1, 2]
out = sorted(nums)
print(out, nums, out is nums)
# [1, 2, 3] [3, 1, 2] False

Pythonには慣習があります。その場で変える関数やメソッドは None を返します。list.sort()、list.append()、list.reverse()、dict.update()、random.shuffle() はどれもそうです。変わったのが元のオブジェクトだという事実を隠さないための約束です。

そのため、こんなミスが起こります。

nums = [3, 1, 2]
nums = nums.sort()
print(nums)
# None

自分で関数を作るときも、どちらか一方を選びましょう。変えたうえに返しもすると、呼び出し側は元が変わったことに気づかずに使ってしまいがちです。

4-4. *args と **kwargs、そして防御的コピー (7分)

*args は余った位置引数を新しいタプルに、**kwargs は余ったキーワード引数を新しい dict に集めます。ただし、その中に差してあるのは、渡したオブジェクトのタグです。

def g(*args, **kwargs):
    return args, kwargs

items = ["a"]
opts = {"tag": items}
a, k = g(items, **opts)
print(type(a), type(k))
# <class 'tuple'> <class 'dict'>
print(a[0] is items, k is opts, k["tag"] is items)
# True False True

**opts で展開して渡しても、関数が受け取る kwargs は新しい dict です。だから関数が kwargs にキーを足しても、opts はそのままです。けれども、値として入っていたリストは同じオブジェクトです。

受け取ったミュータブルなオブジェクトを長く保管する関数は、特に注意が必要です。呼び出し側があとでそのオブジェクトを変えると、保管しておいたものも一緒に変わります。

def make_flight(code, passengers):
    return {"code": code, "passengers": passengers}

names = ["Ari", "Bo"]
f1 = make_flight("HS1", names)
names.append("Cy")
print(f1["passengers"])
# ['Ari', 'Bo', 'Cy']

こういうときは、受け取った瞬間に自分の分を新しく作ります。これを防御的コピー（defensive copy）といいます。

def make_flight(code, passengers):
    return {"code": code, "passengers": list(passengers)}

names = ["Ari", "Bo"]
f1 = make_flight("HS1", names)
names.append("Cy")
print(f1["passengers"])
# ['Ari', 'Bo']

list(passengers) は浅いコピーです（3限目）。中身が文字列なので、これで十分です。逆に、受け取ったものを少し読むだけの関数なら、コピーする必要はありません。

4-5. 戻り値もタグの付け替え (4分)

return もオブジェクトをコピーしません。関数の中で作ったかばんを呼び出し側に渡し、呼び出し側の名前がそのかばんにタグを付けます。関数の枠が消えても、外側のタグがあるので、かばんは残ります。

def build():
    bag = ["boarding pass"]
    return bag

b = build()
print(b)
# ['boarding pass']

複数の値を返しているように見える return a, b は、タプルを一つ返しています。受け取る側でアンパックすると、タグが一枚ずつ付きます。

def stats(xs):
    return min(xs), max(xs)

res = stats([4, 9, 2])
print(res, type(res))
# (2, 9) <class 'tuple'>
lo, hi = stats([4, 9, 2])
print(lo, hi)
# 2 9

return のない関数は None を返します。4-3の「変える関数」が None を返すのも、このためです。

事件解決 (10分)

届出人の関数と、直した関数です。

def new_order(item, cart=[]):
    cart.append(item)
    return cart

print(new_order("coffee"))
# ['coffee']
print(new_order("bagel"))
# ['coffee', 'bagel']
print(new_order.__defaults__)
# (['coffee', 'bagel'],)

def new_order(item, cart=None):
    if cart is None:
        cart = []
    cart.append(item)
    return cart

print(new_order("coffee"), new_order("bagel"))
# ['coffee'] ['bagel']

前の注文は、関数オブジェクトの __defaults__ にぶら下がったリストの中にありました。サーバーは関数を一度定義したら呼び続けるので、そのリストはサーバーが止まるまで、お客さんごとの注文を集め続けたのです。

開発者が帰ったあと、班長が一言付け加えます。「タグは関数が終われば外れる。でも、関数オブジェクトがつかんでいるかばんは外れない。関数もかばんだからね」

練習問題

1. def add(x, seen=set()) が seen.add(x) のあと len(seen) を返すとき、add(1)、add(2)、add(1) の結果を予想し、add.__defaults__ を確かめてください。
2. def clear(lst): lst = [] と def clear(lst): lst.clear() は、外側のリストにそれぞれどんな影響を与えるでしょう？
3. リストを受け取り、元は変えずに並べ替えた新しいリストを返す関数を、二通りの方法（sorted、コピーしてから sort）で作ってみてください。