Python 関数

関数の定義、呼び出し

関数は、defを使って次のように定義する。
関数には引数を持たせることができる。
returnを使うと、値を戻り値として出力できる。

# 関数の定義
def hello():
    print("hello world")

# 関数の定義、引数有り
def sum(x, y):
    return x+y  # 関数の戻り値

# 関数の呼び出し
hello() # hello world
print(sum(3, 4)) # 7

関数引数の値渡しと参照渡し

関数引数の型が変更不可(immutable)な型の場合、引数は値渡しとなる。
関数引数の型が変更可能(mutable)な型の場合、引数は参照渡しとなる。
基本的にはこのように考えればよい。※厳密にはちょっと異なる。

• 変更不可(immutable)な型
  • 数値型(int, float等)、文字列型(string)、タプル型(tuple)、等
• 変更可能(mutable)な型
  • リスト型(list)、辞書型(dict)、等

# 関数定義
def func1(x):
    x = 2
    return x + 3

# 関数引数の型が変更不可(immutable)な型の場合 
a = 1
print("a = " + str(a)) # a = 1
b = func1(a)
print("a = " + str(a)) # a = 1 関数の中で引数変数が変更されても、関数の外に影響なし。
print("b = " + str(b)) # b = 5


# 関数定義
def func2(x):
    x[0] = 2
    x[1] = 3
    return x[0]+x[1]

# 関数引数の型が変更可能(mutable)な型の場合 
p = [0,0]
print("p = " + str(p)) # p = [0, 0]
q = func2(p)
print("p = " + str(p)) # p = [2, 3] 関数の中で引数変数が変更すると、関数の外にも影響する。
print("q = " + str(q)) # q = 5

複数の戻り値

複数の変数をカンマ区切りしてreturnで返すと、複数の値を戻り値として出力できる。
関数呼び出しでは、カンマ区切りした変数で戻り値を受け取る。
関数呼び出しで、１つの変数で戻り値を受け取ると、tuple型となる。

# 関数定義
def func():
    return 10, 20, "abc"
    
# カンマ区切りした変数で戻り値を受け取る。
a, b, c = func()
print (a) # 10
print (b) # 20
print (c) # abc

# １つの変数で戻り値を受け取ると、tuple型となる。
d = func()
print(type(d)) # <class 'tuple'>
print(d) # (10, 20, 'abc')

関数内ローカル変数、グローバル変数宣言

関数内で代入される変数は、関数内のローカル変数として扱われて、そのスコープは関数内部になる。
関数の外側で代入される変数は、グローバル変数として扱われる。

同じ変数aでも、グローバル変数とローカル変数は別物として扱われる。

a = 100 # グローバル変数

# 関数定義
def func1():
    a = 1 # ローカル変数
    print("関数内 a = " + str(a))

# 関数呼び出し
print("関数外 a = " + str(a))
func1()
print("関数外 a = " + str(a))
# 関数外 a = 100
# 関数内 a = 1
# 関数外 a = 100

関数内で変数aをグローバル変数宣言すれば、関数内でも変数aはグローバル変数として扱われる。

a = 100 # グローバル変数

# 関数定義
def func2():
    global a # グローバル変数宣言
    a = 1 # グローバル変数
    print("関数内 a = " + str(a))

# 関数呼び出し
print("関数外 a = " + str(a))
func2()
print("関数外 a = " + str(a))
# 関数外 a = 100
# 関数内 a = 1
# 関数外 a = 1

関数内部において、グローバル変数宣言なしのグローバル変数は参照のみ許可されている。

a = 100 # グローバル変数

# 関数定義
def func3():
    b = a # ローカル変数 = グローバル変数参照
    print("関数内 a = " + str(a))
    print("関数内 b = " + str(b))

# 関数呼び出し
print("関数外 a = " + str(a))
func3()
print("関数外 a = " + str(a))
# 関数外 a = 100
# 関数内 a = 100
# 関数内 b = 100
# 関数外 a = 100

デフォルト引数、キーワード引数

関数定義で引数=デフォルト値とすると、引数のデフォルト値を設定できる。
関数呼び出しで、引数を省略した場合に、自動的にこのデフォルト引数が使用される。
関数呼び出しで、引数名=値とすると、関数定義での引数の順序に関わらずに引数に値を渡すことができる。

# 関数定義、デフォルト引数付き
def func(mono = "リンゴ", nedan = 100):
    print(mono + "は、" + str(nedan) + "円です。")

# 関数呼び出し
func()                          # リンゴは、100円です。
func("ミカン")                  # ミカンは、100円です。
func("ミカン", 50)              # ミカンは、50円です。
# 関数呼び出し、キーワード引数
func(mono="ミカン", nedan = 50) # ミカンは、50円です。
func(nedan = 50, mono="ミカン") # ミカンは、50円です。
func(nedan = 200)               # リンゴは、200円です。
func(mono = "トマト")           # トマトは、100円です。

可変長引数

関数定義で、引数にアスタリスクを付けると、その引数は可変長引数として扱われる。
関数呼び出しで、可変長引数の部分に複数の引数を与えると、
関数内部では、それがタプルとして扱われる。

# 関数定義、可変長引数
def iremonoNakami(iremono, *nakamis):
    print(type(nakamis)) # <class 'tuple'>
    print(nakamis)
    print(iremono + "には、")
    for nakami in nakamis:
        print(nakami + "、", end="")
    print("が入っている。")

# 関数呼び出し
iremonoNakami("かばん", "本", "筆箱", "財布")
# かばんには、
# 本、筆箱、財布、が入っている。

辞書型可変長引数

関数定義で、引数にアスタリスクを２つ付けると、その引数は辞書型可変長引数として扱われる。
関数呼び出しで、可変長引数の部分にキー="値"を与えると、
関数内部では、それが辞書型として扱われる。

# 関数定義、辞書型可変長引数
def iremonoNakami(**aaas):
    print(type(aaas)) # <class 'dict'>
    print(aaas)
    for iremono, nakami in aaas.items():
        print(iremono + "には、" + nakami + "が入っている。")

# 関数呼び出し"
iremonoNakami(bag="本", box="おもちゃ", wallet="お金")
# bagには、本が入っている。
# boxには、おもちゃが入っている。
# walletには、お金が入っている。