Python 05：関数 ― 引数は札、既定値の罠、スコープの探し方

def で作る。return が無ければ None を返す

関数は def 名前(引数): と書き、その下に字下げして本体を書きます。

def to_f(c):
    """摂氏を華氏にする"""
    return c * 1.8 + 32

本体の最初に置いた """…""" の文字列は docstring（ドックストリング）と呼ばれる関数の説明です。JS の JSDoc にあたりますが、Python ではただのコメントではなく、関数のオブジェクトに to_f.__doc__ としてしまわれ、help(to_f) やエディタの説明表示に使われます。

return で値を返すのも JS と同じです。違うのは、return を書かなかったときです。

図の hello は print するだけで何も返さないので、r = hello("東京") の r は None になります。第3章で「Python の『無い』は None だけ」と書いたのは、このことも含んでいます。

return lat, lon と書くと、第4章で見たとおりカンマが tuple を作るので、2つの値が1つの tuple にまとまって返ります。受け取る側で lat, lon = f() と分ければ、複数の値を返したのと同じように使えます。

def も代入の一種：関数に名前の札が付く

ここから、関数を呼んだときに何が起きているかを、札の図で追います。

まず、def の行そのものが何をしているかです。

def to_f(c):
    return c * 1.8 + 32
x = 30

def to_f を実行すると、Python は関数の中身を関数のオブジェクト（型は function）として1つ作り、to_f という名前の札をそれに付けます。図のとおり、x = 30 で 30 に札 x を付けるのと同じ形です。

図の緑の囲みは、このファイル全体で使える名前の置き場です。これをグローバル（そのファイルの一番外側）と呼びます。

「def も札を付けるだけ」と分かると、次のようなことも自然に理解できます。同じ名前で def を2回書くと、後の関数に札が付け替わり、前の関数は使えなくなります。JS の関数宣言の「巻き上げ（hoisting）」のような仕組みは無いので、def の行を実行する前に関数を呼ぶと NameError になります。Python のファイルは上から順に実行されるからです（第8章で、import のときにもこの「上から実行」が効いてきます）。

呼び出すと、関数の中の名前の置き場ができる

次に、関数を呼びます。

y = to_f(x)

to_f(x) を実行すると、Python はその呼び出し専用の名前の置き場を新しく作ります。図の黄色の囲みです。これをフレーム（またはローカルの名前空間）と呼びます。

そして、引数を渡します。引数を渡すとは、関数の中の名前 `c` の札を、渡されたオブジェクトに付けることです。図のように、c の札は、x が付いているのと同じ 30 に付きます。30 がコピーされるわけではありません。

つまり、引数を渡すことは、`c = x` という代入と同じです。第4章で「代入は札を付けるだけで、コピーはしない」と見ました。引数もまったく同じルールで動いています。

この渡し方は「参照渡し」でも「値渡し」でもなく、Python の公式の FAQ では「代入による受け渡し」（引数は代入で渡される）と説明されています。言葉は覚えなくてかまいません。札の絵が描ければ十分です。

return で値を返し、置き場は片付けられる

本体の return c * 1.8 + 32 が実行されると、計算結果の 86.0 という float のオブジェクトが新しく作られ、それが呼んだ側に返されます。呼んだ側の y = to_f(x) は、その戻り値に札 y を付けます。

同時に、to_f の呼び出しのために作った置き場（フレーム）は片付けられます。中にあった札 c も一緒に消えます。図から黄色の囲みが消えたのはそのためです。

c は関数の中だけで使えるローカルな名前です。関数の外で print(c) とすると NameError: name 'c' is not defined になります。JS の関数の中で let した変数が外から見えないのと同じです。

同じ関数を10回呼べば、置き場も10回作られて10回片付けられます。呼び出しごとに別々の置き場なので、1回目の c と2回目の c が混ざることはありません。

この「呼ぶたびに新しい置き場ができる」は、後で見るデフォルト値の罠を理解する鍵になります。置き場は毎回新しいのに、ある物だけは毎回同じ、という話です。

list を渡すと、中で変えたものが外にも見える

引数を渡すのが「札を付けるだけ」なら、変更できる物（第4章）を渡したときに何が起きるかは、もう予想できます。

def add99(lst):
    lst.append(99)

a = [1]
add99(a)
print(a)      # [1, 99]

図のように、グローバルの札 a と、add99 の中の札 lst は、同じ1つの list に付いています。lst.append(99) はその list そのものを変えるので、関数が終わった後に a から見ても 99 が増えています。

一方、関数の中で lst = [0] と付け替えた場合は、a は変わりません。付け替わるのは関数の中の札 lst だけだからです（第4章の b = [0] と同じ）。

これは JS で配列やオブジェクトを関数に渡したときと同じ動きです。

Python の関数でよくある作法は、「渡された list を中で変えるなら、関数の名前や docstring でそう分かるようにする」か、「中で変えずに、新しい list を作って return する」かのどちらかにすることです。標準の list.sort()（元を変える、戻り値は None）と sorted()（新しい list を返す）が、ちょうどこの2つの作法の見本になっています。

デフォルト引数：省略したときの値

引数の後ろに = 値 と書いておくと、呼ぶ側で省略したときにその値が使われます。デフォルト引数（既定値）です。JS の既定値とほぼ同じ書き方です。

def fmt(temp, unit="C", digits=1):
    return f"{temp:.{digits}f}{unit}"

{temp:.{digits}f} は、f-string の書式指定（第3章）の中にさらに {digits} を埋め込んで、小数の桁数を引数で変えられるようにしたものです。

図の表の呼び方は、どれも python3 で実際に動かした結果です。

3行目と4行目の digits=0 のように、呼ぶ側で引数の名前を書いて渡すのが、次に見るキーワード引数です。JS には無い仕組みで、これがあるおかげで「2番目は省略して、3番目だけ変えたい」が素直に書けます。

1つ決まりがあります。既定値の無い引数は、既定値のある引数より前に置く必要があります。def f(a=1, b): と書くと SyntaxError: parameter without a default follows parameter with a default になります。省略されたときに、どの位置の値がどの引数か決められなくなるからです。

キーワード引数：名前を付けて渡す

呼ぶときに 名前=値 の形で渡す引数をキーワード引数と呼びます。JS から来た人にとって、Python の関数でいちばん便利に感じるところかもしれません。

JS で「引数が多い関数」を作るとき、よく設定のオブジェクトを1つ渡し、受け取る側で分割代入します（図の左）。

function fmt(temp, { unit = "C", digits = 1 } = {}) { … }
fmt(21.456, { digits: 0 });

これは、JS に「引数を名前で渡す」仕組みが無いための工夫です。Python は言語の仕組みとしてそれを持っているので、ふつうに引数を並べておけば、呼ぶ側で名前を付けて渡せます（図の右）。

def fmt(temp, unit="C", digits=1): …
fmt(21.456, digits=0)

第3章の print("東京", 31, sep=" / ", end="!\n") の sep= と end= も、このキーワード引数です。

JS でも「真偽値の引数は読みにくい」（save(true, false) では何のことか分からない）と言われますが、Python ではそういう引数は save(overwrite=True, backup=False) のように名前で渡すのが作法です。後で見るように、名前でしか渡せない引数を作ることもできます。

*args：残りの位置引数を tuple にまとめる

引数の名前の前に * を付けると、いくつ渡されても全部まとめて受け取れる引数になります。

def avg(*temps):
    return sum(temps) / len(temps)

avg(28, 31, 33)       # temps は (28, 31, 33)

受け取った temps は tuple です（公式のチュートリアルにも「tuple に包まれる」とあります）。JS の残余引数 function avg(...temps) とまったく同じ役割で、JS では配列になるところが、Python では tuple になります。

逆に、呼ぶ側で list や tuple の前に * を付けると、中身を広げて1つずつの引数として渡せます。

nums = [28, 31]
avg(*nums)            # avg(28, 31) と同じ

JS の ... が「まとめる」と「広げる」の両方に使われるのと同じく、Python の * も両方に使われます。

名前は *args（arguments の略）がよく使われますが、これはただの慣習です。*temps のように意味の分かる名前にしてかまいません。大事なのは * の記号のほうです。

**kwargs：残りのキーワード引数を dict にまとめる

* が位置引数をまとめるのに対し、** はキーワード引数をまとめて dict で受け取ります。

def report(city, **opts):
    print(city, opts)

report("東京", unit="F", lang="ja")
# 東京 {'unit': 'F', 'lang': 'ja'}

city という名前の引数に当てはまらなかった unit="F" と lang="ja" が、opts という dict に入ります。名前は **kwargs（keyword arguments）が慣習です。

呼ぶ側で dict の前に ** を付けると、中身を広げてキーワード引数として渡せます。

o = {"unit": "F"}
report("東京", **o)     # report("東京", unit="F") と同じ

JS と並べると、図の表のようになります。

第4章の dict のコピー {**d} も、この「広げる」の ** です。

図の右下のとおり、いつも使っている print も、実はこの仕組みでできています。help(print) で説明を表示すると、print(*args, sep=' ', end='\n', file=None, flush=False) と出てきます。*args で表示したい値をいくつでも受け取り、sep や end はキーワード引数で受け取っているわけです。

引数の並びには決まった順番がある

ここまでの種類を全部使うと、引数の並びは次の順番になります。

def f(a, b=1, *args, c, d=2, **kwargs):
    ...

*args は要らないけれど「ここから後ろは名前で渡してほしい」ときは、* だけを書きます。

def show(day, temp, *, unit="C"):
    ...
show("月", 31, unit="F")    # OK
show("月", 31, "F")         # TypeError: … takes 2 positional arguments but 3 were given

逆に、/ を書くと「ここより前は位置でしか渡せない」になります（Python 3.8 から）。組み込みの関数によく使われていて、help(len) を見ると len(obj, /) と出てきます。

全部を覚える必要はありません。自分で書くときに使うのは、ほとんどが「ふつうの引数」「既定値つき」と、ときどき「* の後ろのキーワード専用」です。他の人のコードや help() の表示で見かけたときに、意味が分かれば十分です。

罠：デフォルト値に [] を書くと、呼ぶたびに増える

ここで、Python でいちばん有名な罠を見ます。都市の名前を list に足していく関数です。list を渡さなければ、新しい list から始めてほしいので、既定値に [] を書きました。

def add_city(city, cities=[]):
    cities.append(city)
    return cities

print(add_city("東京"))
print(add_city("大阪"))

['東京']
['東京', '大阪']

2回目は ['大阪'] になってほしいのに、1回目の「東京」が残っています。3回目を呼べば3つに増えます。

JS で同じことを書くと、期待どおりに動きます。

function addCity(city, cities = []) {
  cities.push(city);
  return cities;
}
addCity("東京");   // ['東京']
addCity("大阪");   // ['大阪']

JS の既定値は、呼ぶたびに評価されて、毎回新しい [] ができるからです。

Python の公式チュートリアルは、この動きを「重要な警告」として載せています。「デフォルト値は1回だけしか評価されない。これは、デフォルト値が list や dict のような変更できるオブジェクトのときに違いを生む」。

「1回だけ」とは、いつの1回なのでしょうか。札の図で見てみます。

デフォルト値は、def を実行したときに1回だけ作られる

前に見たとおり、def の行を実行すると、関数のオブジェクトが1つ作られます。

このとき Python は、既定値の式 [] もその場で1回だけ評価して、できた list を関数のオブジェクトの中にしまっておきます。図の黄色の面が関数のオブジェクト、その中の白い面が「デフォルト値の置き場」です。そこから、def のときに作られた list へ矢印が伸びています。

1回目の呼び出し add_city("東京") では、cities を渡していないので、札 cities は「しまってあった list」に付きます。呼び出しの置き場（フレーム）は毎回新しく作られますが、札が付く先の list は、関数のオブジェクトにしまわれているあの1つです。

そこに append("東京") するので、しまってあった list そのものが ["東京"] に変わります。

2回目も、同じ list に札が付く

2回目の add_city("大阪") でも、cities を渡していないので、札 cities はまた同じ list に付きます。既定値は作り直されません。1回目で ["東京"] になったその list に "大阪" が足されて、["東京", "大阪"] になります。

しまわれている既定値は、実際に見ることができます。

print(add_city.__defaults__)
# (['東京', '大阪'],)

__defaults__ は、関数のオブジェクトが持っている「既定値の置き場」そのものです（引数が複数あれば既定値も複数並ぶので、tuple になっています）。関数もオブジェクトだ、という話は後でもう一度出てきます。

なぜ Python はこういう作りなのでしょうか。既定値の式を呼ぶたびに評価するなら、呼ぶたびに式を実行するぶん遅くなります。Python は「def のときに1回だけ計算しておく」ほうを選びました。既定値が数や文字列や None なら、変更できない物なので、1つを使い回しても何の問題もありません（第4章）。問題になるのは、変更できる物を既定値にしたときだけです。

直し方：None を置いて、中で作る

直し方は決まっています。既定値には変更できない None を置き、関数の中で「None だったら新しい list を作る」と書きます。公式のチュートリアルにも、この形がそのまま載っています。

def add_city(city, cities=None):
    if cities is None:
        cities = []          # 呼ぶたびに新しく作る
    cities.append(city)
    return cities

print(add_city("東京"))   # ['東京']
print(add_city("大阪"))   # ['大阪']

cities = [] の行は関数の本体にあるので、呼ぶたびに実行され、毎回新しい list ができます。None の確認に is を使うのは、第3章で見た作法どおりです。

この罠はとても有名なので、第15章で紹介する ruff などのリンター（コードの検査の道具）には、既定値の [] や {} を見つける規則（ruff では B006）が用意されています。

lambda：式1つだけの小さな関数

JS のアロー関数 (c) => c * 1.8 + 32 にあたるのが、Python の lambda（ラムダ）です。

lambda c: c * 1.8 + 32

lambda 引数: 式 と書き、式の値がそのまま返されます。return は書きません。

JS のアロー関数との大きな違いは、中に書けるのは式1つだけということです。公式ドキュメントにも「構文上、1つの式に限られる」とあります。{ } で囲んで何行も書くことはできません。

これは「複雑な処理には名前を付けて def で書いてほしい」という Python の考え方の表れです。JS ではアロー関数を何でも使いますが、Python で lambda を使うのは主に、関数を引数として渡す場面の、ごく短い処理です。

いちばんよく使うのは、並べ替えの key= です。

forecast = [{"day": "月", "temp": 31}, {"day": "火", "temp": 27}]
sorted(forecast, key=lambda f: f["temp"])
# [{'day': '火', 'temp': 27}, {'day': '月', 'temp': 31}]

key= には「要素を1つ受け取って、並べ替えの基準になる値を返す関数」を渡します。JS の arr.sort((a, b) => a.temp - b.temp) のように2つを比べる関数ではなく、1つから基準の値を取り出す関数を渡すところが違います。max(forecast, key=lambda f: f["temp"]) で、いちばん暑い日も取り出せます。

名前は L・E・G・B の順に探される

関数の中で名前を使ったとき、Python はその名前をどこから探すのでしょうか。公式のチュートリアルは、こう説明しています。「変数を参照すると、まずローカルの記号表を見て、次に外側の関数のローカルの記号表、次にグローバルの記号表、最後に組み込みの名前の表を見る」。

この4つの頭文字を取って、LEGB と呼ばれます。図の入れ子の囲みが、それぞれの範囲です。

図の右のコードでは、inner の中で print(x) をしています。x という名前は、inner の中では作られていません。赤い小包の位置、つまりいちばん内側の L から探し始めます。

JS にも、内側から外側へ名前を探しに行く仕組み（スコープチェーン）があり、考え方は同じです。違いは、JS は { } のブロックごとに範囲ができるのに対して、Python は関数ごとにしか範囲ができないことです（後で見ます）。

内側から外へ。最初に見つかったものを使う

inner の中（L）に x が無いので、Python は1つ外側、outer の中（E）を探します。そこには x = "enclosing" があるので、そこで探すのをやめて、その値を使います。だから、結果は enclosing です。

グローバル（G）にも x = "global" がありますが、そこまでは探しに行きません。内側から探して、最初に見つかったものが使われます。

もし outer の中の x = "enclosing" を消せば、E にも無いので G まで行き、global と表示されます。4つのどこにも無ければ、NameError: name 'x' is not defined です。

内側の関数が、外側の関数の名前を覚えていて使えることを、JS と同じくクロージャと呼びます。outer の呼び出しが終わった後でも、inner が生きていれば、inner は outer の x を見続けられます。

print や len は、いちばん外の組み込み（B）にある

では、print や len や int は、どこにあるのでしょうか。どの関数の中にも、どのファイルにも def print とは書いていません。

これらは、いちばん外側の B（組み込み、built-in） にある名前です。図のように、L・E・G のどこにも len が無いので、最後に B まで探しに行って見つかります。

組み込みの名前は、Python が起動したときに最初から用意されていて、どのファイルからも import せずに使えます。実体は builtins という名前の特別なモジュールで、中身は次のように確かめられます。

import builtins
print(len(dir(builtins)))   # 159（3.13 で確かめた数。版によって増減する）

print、len、int、str、list、dict、range、sorted、sum、type、isinstance、True、None や、TypeError などの例外の名前も、すべてここにあります。JS でいえば、console や Math や parseInt のような、どこでも使えるグローバルな名前にあたります。

1つ注意があります。LEGB は内側が優先なので、自分で list = [1, 2] や sum = 0 のように組み込みと同じ名前に代入すると、組み込みが隠れてしまいます。その後で list("abc") と書くと、G の list（ただの list のオブジェクト）が見つかってしまい、TypeError: 'list' object is not callable になります。変数に list・dict・str・sum・id・type などの名前を付けないようにしましょう。

関数の中で代入した名前は、その関数のローカルになる

LEGB の探し方には、1つ大事な例外があります。関数の中で代入している名前は、その関数全体でローカル（L）扱いになるのです。

count = 0
def bump():
    count += 1
bump()
# UnboundLocalError: cannot access local variable 'count'
#   where it is not associated with a value

count += 1 は count = count + 1 なので、bump の中に count への代入があります。Python は def bump を読んだ時点で「count は bump のローカルな名前だ」と決めます。そのため、右辺の count を読むとき、グローバルの 0 ではなく、まだ札の付いていないローカルの `count` を読もうとして、エラーになります。

公式のチュートリアルも「関数の中の代入は、すべてローカルの記号表に値をしまう」と書いています。JS では let や const を書いた場所で範囲が決まりますが、Python には宣言の言葉が無いので、「代入があるかどうか」で決めているのです。

外のグローバルな名前に代入したいときは、global と宣言します。

count = 0
def bump():
    global count
    count += 1
bump()
print(count)    # 1

ただし、global は最後の手段です。関数の外の状態を関数の中から書き換えると、どこで値が変わったのか追いにくくなります。ふつうは、必要な値は引数で受け取り、結果は return で返すようにします。状態をまとめて持ちたいなら、第7章のクラスを使います。

if や for は、名前の範囲（スコープ）を作らない

JS から来た人がもう1つ驚くのが、これです。

for i in range(3):
    last = i

print(i, last)     # 2 2

JS の let や const は { } の中だけで生きるので、for の外で i を使うと ReferenceError になります（ブロックスコープ）。Python には、ブロックスコープがありません。if・for・while・with・try の中で作った名前は、その外でもそのまま使えます。

Python で名前の範囲（スコープ）を作るのは、主に関数・クラス（第7章）・モジュール（ファイル。第8章）です。第4章の内包表記の中の名前も、外には漏れません。

第3章の tenki で、if の中で作った feel を if の外の print で使えたのは、このためです。

注意点は、if の中が実行されなかった場合です。そのときは名前が作られていないので、外で使うと NameError になります。if と else の両方で同じ名前に代入するか、if の前に feel = None のように先に作っておくと安全です。

nonlocal：外側の関数の名前を書き換える

内側の関数から、外側の関数の名前を読むのは自由にできました（前に見た E）。では、書き換えるにはどうすればよいでしょうか。

呼ぶたびに1ずつ増える数を返す「カウンター」を作ってみます。JS では、こう書けます。

function counter() {
  let n = 0;
  return () => { n += 1; return n; };
}

内側の関数で n += 1 と書けば、外側の n が変わります。let n を書いた場所で、n がどの範囲の名前かが決まっているからです。

Python で同じように n += 1 と書くと、前に見た規則により、n は内側の関数のローカルになってしまい、UnboundLocalError になります。そこで、「この n は外側の関数のものだ」と伝えるのが nonlocal です。

def counter():
    n = 0
    def inc():
        nonlocal n
        n += 1
        return n
    return inc

c = counter()
c()
print(c())     # 2

nonlocal を使うのは、こうした小さなクロージャを書くときくらいです。状態が大きくなってきたら、第7章のクラスを使うほうが読みやすくなります。

関数もオブジェクト：札を付け、渡し、返せる

前に見たとおり、def は function 型のオブジェクトを作り、名前の札を付けるだけでした。ということは、関数のオブジェクトに別の札を付けることもできます。

f = to_f        # ( ) を付けない＝呼ばずに、同じ関数に札を付ける
f(0)            # 32.0
f.__name__      # 'to_f'（オブジェクトが覚えている自分の名前）
type(f)         # <class 'function'>

to_f() と ( ) を付ければ「呼ぶ」、to_f とだけ書けば「関数のオブジェクトそのもの」です。この区別は JS と同じです。

関数がオブジェクトなので、引数として渡すことも、関数から返すこともできます。

def apply(fn, x):
    return fn(x)

apply(to_f, 100)    # 212.0

これは JS の関数とまったく同じ性質で、「関数は第一級オブジェクト」と言われます。

この性質は、第17章でとても大事になります。FastAPI の @app.get("/weather") という書き方（デコレーター）は、実は「関数を受け取って、どこかに登録する関数」です。あなたが書いた関数のオブジェクトをフレームワークに渡して、フレームワークが後で呼んでくれる。その土台が、ここで見た「関数もオブジェクト」です。

tenki を関数に分ける

この章の内容で、tenki を関数に分けます。

# tenki.py ― 第5章の版
def to_f(c):
    """摂氏を華氏にする"""
    return c * 1.8 + 32

def feel(temp):
    if temp >= 30:
        return "暑い"
    if temp >= 20:
        return "ちょうどいい"
    return "寒い"

def show(day, temp, *, unit="C"):
    t = to_f(temp) if unit == "F" else temp
    print(f"{day}: {t:.0f}{unit} ({feel(temp)})")

def main():
    forecast = [("月", 31), ("火", 27), ("水", 18)]
    for day, temp in forecast:
        show(day, temp)
    show("月", 31, unit="F")

main()

$ python3 tenki.py
月: 31C (暑い)
火: 27C (ちょうどいい)
水: 18C (寒い)
月: 88F (暑い)

最後の main() の1行で、全体が動き始めます。def の行は関数を作って札を付けるだけで、呼ぶまでは中身は動かないからです。

この「ファイルの最後で main() を呼ぶ」形は、第8章で if __name__ == "__main__": という1行に変わります。tenki を他のファイルから import したときに、勝手に main() が動かないようにするためです。

よくある間違いと、出るエラー

関数まわりのエラーは、ほとんどが TypeError です。メッセージには関数の名前と引数の名前が入るので、それを見れば何を直せばよいか分かります。どれも python3 3.13 で確かめたものです。

エラーが出ないのに結果がおかしい、というときは、表の「エラーは出ない」の行を疑ってください。とくに return の書き忘れ（結果が None になる）と、既定値の `[]`（前の結果が残る）がよくある原因です。