関数¶

1. オリジナルの関数¶

関数の必要性とメリット¶

関数とは何か？: プログラムを書くとき、同じ処理を何度も繰り返し記述するのは効率が悪く、ミスの原因にもなります。関数を使うことで、「ひとまとまりの処理をまとめて定義し、必要なときに呼び出せる」ようになります。

関数のメリット

関数を使うと、次のようなメリットがあります。

コードの再利用性が向上する

一度定義した関数を何度でも呼び出せるため、同じコードを繰り返し書く必要がなくなる。
コードが見やすく、保守しやすくなる

関数を使うことで、プログラムが「処理ごとに分割」され、どの部分が何をしているかが明確になる。
バグを減らしやすい

ひとつの処理を関数としてまとめることで、エラーが起きた際に修正が容易になる。
他のプログラムでも使い回せる

汎用的な関数を作れば、別のプログラムでも再利用できる。

関数を使わない場合の問題点

関数を使わずに、同じ処理を繰り返し記述するとどうなるでしょうか？たとえば、「名前を入力して挨拶を表示する」プログラムを考えてみます。

name1 = input("名前を入力してください: ")
print(f"こんにちは、{name1}さん！")

name2 = input("名前を入力してください: ")
print(f"こんにちは、{name2}さん！")

name3 = input("名前を入力してください: ")
print(f"こんにちは、{name3}さん！")

このコードでは、同じ処理を何度も書いているため、もし挨拶のメッセージを変更したい場合、すべての print 文を修正しなければなりません。

関数を使うとどうなるか？

この処理を関数でまとめると、簡潔で柔軟なコードになります。

プログラム：

def greet():
    name = input("名前を入力してください: ")
    print(f"こんにちは、{name}さん！")

greet()
greet()
greet()

出力：

名前を入力してください: アイ
こんにちは、アイさん！
名前を入力してください: ノブ
こんにちは、ノブさん！
名前を入力してください: ダイゴ
こんにちは、ダイゴさん！

このように関数を使うことで、コードが短くなり、修正も容易になります。また、関数を定義すれば、繰り返し回数を自由に変更したり、ループを使ったりすることも可能です。

for _ in range(10):
    greet()

関数を使うための基本的な2ステップ¶

Python で関数を使うためには、次の 2つのステップを理解することが重要です。

関数を定義する
関数を呼び出す

この2つのステップを順番に詳しく解説します。

関数定義と呼び出し¶

ステップ1: 関数を定義する

関数を使うためには、まず def キーワードを使って関数を定義する必要があります。

関数の基本的な書き方

関数を定義するには、次のように書きます。

def 関数名():
    処理

def は関数を定義するためのキーワード。
関数名には自由に名前をつけることができる。
() はこの関数が実行する処理のまとまりであることを示す。
:（コロン）のあとにインデント（半角スペース4つまたはタブ）して処理を書いていく。

具体例

次のコードでは、「画面に挨拶を表示する」関数 greet を定義しています。

def greet():
    print("こんにちは！")
    print("Pythonの世界へようこそ！")

この greet 関数は、「こんにちは！」と「Pythonの世界へようこそ！」を表示する処理」をまとめたものです。

ポイント：

print 文がインデントされていることに注意（インデントを忘れるとエラーになる）。
関数を定義しただけでは、まだ何も実行されない。

ステップ2: 関数を呼び出す

関数を定義しただけでは動作しません。定義した関数を実行する（呼び出す）ことで、初めて処理が実行されます。

関数の呼び出し方 関数を呼び出すには、次のように関数名と () を書くだけです。

関数名()

具体例

先ほど定義した greet 関数を実際に呼び出してみましょう。

プログラム：

# 関数の定義
def greet():
    print("こんにちは！")
    print("Pythonの世界へようこそ！")

# 関数の呼び出し
greet()

出力：

こんにちは！
Pythonの世界へようこそ！

このように、関数を定義し、それを呼び出すことで初めて処理が実行されることがわかります。

ローカル変数と独立性¶

関数を使う際に重要な概念の一つが ローカル変数（Local Variable） です。ローカル変数を理解することで、関数が他の部分と独立した動作をすることが分かります。

ローカル変数とは？: 関数内で定義された変数はローカル変数と呼ばれ、関数の外からはアクセスできません。これは関数が他の部分と干渉しないための仕組みです。

プログラム：

def say_hello():
    message = "こんにちは！"  # 関数内で定義されたローカル変数
    print(message)

say_hello()

出力：

こんにちは！

この message 変数は say_hello 関数の中でしか使えません。関数の外で message を使おうとするとエラーになります。

プログラム：

def say_hello():
    message = "こんにちは！"  # 関数内で定義されたローカル変数
    print(message)

print(message)

出力：

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

/var/folders/lc/k7jt3gx9283453ptp9t9ty5m0000gn/T/ipykernel_7791/3463849412.py in <module>
----> 1 print(message)


NameError: name 'message' is not defined

このエラーは、message という変数が関数の外では定義されていないために発生します。

ローカル変数の独立性

関数を何度も呼び出しても、ローカル変数は毎回リセットされます。関数内で定義された変数は、他の呼び出しと影響を及ぼし合うことはありません。

プログラム：

def counter():
    count = 0
    count += 1
    print(count)

counter()
counter()
counter()

出力：

1
1
1

関数を呼び出すたびに count は 0 にリセットされるため、結果は毎回 1 になります。

ローカル変数が関数ごとに独立することのメリット

関数が他の部分に影響を与えない
バグの発生を防ぎやすい
関数を安心して再利用できる

例えば、プログラムが大きくなると変数の上書きによるバグが起こりやすくなります。しかし、ローカル変数を使えば、関数ごとに独立しているため変数の衝突を防げます。

2. 引数と戻り値¶

関数をより便利に使うためには「引数」と「戻り値」の概念が重要になります。これによって、関数に値を渡したり、処理の結果を受け取ったりできるようになります。

引数¶

引数とは？: 関数を呼び出す際に、外部から値を渡すための仕組みを「引数（ひきすう）」といいます。関数定義の () 内に変数名を記述し、関数を呼び出すときに値を渡します。

引数の基本構造：

def 関数名(引数1, 引数2, ...):
    処理

引数の具体例：

def greet(name):
    print(f"こんにちは、{name}さん！")

greet("太郎")  # 「こんにちは、太郎さん！」と出力
greet("花子")  # 「こんにちは、花子さん！」と出力

出力：

こんにちは、太郎さん！
こんにちは、花子さん！

この name は関数内でのみ使えるローカル変数です。関数を呼び出す際に "太郎" や "花子" を渡すことで、異なる出力が得られます。

複数の引数を渡す¶

引数を複数指定することもできます。例えば、足し算をする関数を考えてみましょう。

プログラム：

def add(a, b):
    print(a + b)

add(3, 5)
add(10, 20)

出力：

8
30

このように、a と b の 2つの値を引数として渡し、その合計を計算しています。引数には、数値や文字列はもちろん、コンテナも引数に渡すことができます。

戻り値¶

戻り値とは？: 関数は計算結果を出力するだけでなく、「戻り値」を使って値を返すこともできます。 return を使うことで、関数の外でその値を使えるようになります。

戻り値の基本構造：

def 関数名(引数):
    処理
    return 戻り値

戻り値の具体例：

def add(a, b):
    return a + b

result = add(4, 6)
print(result)

出力：

この return によって、計算結果を関数の外で使えるようになりました。例えば、戻り値を使ってさらに計算することもできます。

プログラム：

x = add(10, 15)
y = add(x, 5)
print(y)

出力：

関数呼び出しの正体¶

関数呼び出し演算子 () について

Python では、関数を実行するときに関数名の後に () を付けることで呼び出します。この () を「関数呼び出し演算子」と呼びます。

関数呼び出し演算子の役割

関数呼び出し演算子 () の重要なポイントは次の 2 つです。

() を付けると関数が実行される
() を付けないと関数自体（オブジェクト）が参照される

例えば、以下のコードを見てみましょう。

プログラム：

def greet():
    return "こんにちは！"

print(greet)
print(greet())

出力：

<function greet at 0x7fc1295ea700>
こんにちは！

greet → 関数オブジェクトの参照（関数そのもの）
greet() → 関数の実行結果（戻り値）

関数オブジェクトの参照を使う例

関数を () を付けずに変数に代入すると、関数自体を代入できます。

プログラム：

def square(n):
    return n * n

calc = square

print(calc(5))

出力：

calc = square により、calc(5) で square(5) と同じ動作になります。これは関数を引数として渡したり、動的に切り替えたりするときに役立ちます。

関数の連携¶

関数の連携を使った例

ここでは、数値を受け取り、それを加工しながら連携していく例を考えます。

3つの関数を定義

double: 数値を2倍にする
add_five: 数値に5を加える
square: 数値を2乗する

プログラム：

def double(n):
    """数値を2倍にする"""
    return n * 2

def add_five(n):
    """数値に5を加える"""
    return n + 5

def square(n):
    """数値を2乗する"""
    return n ** 2

num = 3
step1 = double(num)       # 3 * 2 = 6
step2 = add_five(step1)   # 6 + 5 = 11
step3 = square(step2)     # 11 ** 2 = 121

print(step3)

出力：

このように書くと、各処理の結果が明確になり、デバッグもしやすくなります。

関数の連携のポイント

関数の戻り値を、次の関数の引数として渡す
ネストを避けて、処理を分けて書くと可読性が向上
データの流れを意識すると、プログラムが整理しやすくなる

3. 関数の応用テクニック¶

暗黙のタプルによる複数の戻り値¶

例えば、「円の面積」と「円周の長さ」を同時に計算して返す関数を考えます。

プログラム：

import math

def circle_properties(radius):
    """半径を受け取り、円の面積と円周の長さを返す"""
    area = math.pi * radius ** 2
    circumference = 2 * math.pi * radius
    return area, circumference  # 暗黙のタプル

result = circle_properties(5)
print(result)

出力：

(78.53981633974483, 31.41592653589793)

return area, circumference のようにカンマで区切ると、戻り値はタプルとして返されます。これは、タプルと定義する丸括弧 () を省略して記述していることになります。

戻り値を個別の変数に代入する¶

タプルは「アンパック（展開）」することで、個々の変数に分解できます。

プログラム：

area, circumference = circle_properties(5)
print(f"円の面積: {area}")
print(f"円周の長さ: {circumference}")

出力：

円の面積: 78.53981633974483
円周の長さ: 31.41592653589793

明示的に丸括弧を実装しても同じ意味になります。

プログラム

(area, circumference) = circle_properties(5)
print(f"円の面積: {area}")
print(f"円周の長さ: {circumference}")

出力

円の面積: 78.53981633974483
円周の長さ: 31.41592653589793

デフォルト引数¶

関数を呼び出すとき、引数を省略してもデフォルトの値が使われるように設定できる機能を「デフォルト引数」といいます。デフォルト引数を使うことで、関数の使い勝手が向上し、コードの可読性が向上します。

デフォルト引数の基本構文: デフォルト引数は、関数定義時に = を使って値を指定します。

プログラム：

def greet(name="ゲスト"):
    print(f"こんにちは、{name}さん！")

greet()
greet('吉田栄作')

出力：

こんにちは、ゲストさん！
こんにちは、吉田栄作さん！

複数のデフォルト引数

デフォルト引数は複数設定可能です。ただし、デフォルト値のある引数は、デフォルト値のない引数より後に書く 必要があります。

プログラム：

def order(product, quantity=1, price=1000):
    total = quantity * price
    print(f"{product} を {quantity} 個注文しました。合計 {total} 円です。")

order("リンゴ") 
order("オレンジ", 3)
order("バナナ", 2, 500)

出力：

リンゴ を 1 個注文しました。合計 1000 円です。
オレンジ を 3 個注文しました。合計 3000 円です。
バナナ を 2 個注文しました。合計 1000 円です。

デフォルト引数の注意点

デフォルト引数を使うと便利ですが、変更可能なオブジェクト（リストや辞書）をデフォルト引数に使うと意図しない動作をすることがあります。

def add_item(item, item_list=[]):  # リストをデフォルト引数にする
    item_list.append(item)  # リストにアイテムを追加
    return item_list

# 最初の呼び出し
print(add_item("リンゴ"))  
# → ['リンゴ']

# 2回目の呼び出し
print(add_item("バナナ"))  
# → ['リンゴ', 'バナナ']  （意図せず前回のリストを引き継いでしまう！）

Python はデフォルト引数を関数定義時に 1 回だけ評価するため、リストが毎回同じオブジェクトを参照してしまいます。

正しい書き方

変更可能なオブジェクトをデフォルト引数にしたい場合は、デフォルト値を None にして、関数内で新しいオブジェクトを作るのが定石です。

def add_item(item, item_list=None):
    if item_list is None:
        item_list = []  # 新しいリストを作成
    item_list.append(item)
    return item_list

# 毎回新しいリストが作られる
print(add_item("リンゴ"))  # → ['リンゴ']
print(add_item("バナナ"))  # → ['バナナ']

引数のキーワード指定¶

Python では関数の引数を「キーワード指定（キーワード引数）」で渡すことができます。キーワード指定を使うことで、関数の可読性が向上し、引数の順番を気にせずに関数を呼び出すことが可能になります。

キーワード指定の基本

通常の関数呼び出しでは、引数は定義された順番で渡します。

プログラム：

def introduce(name, age, city):
    print(f"私は {name} です。{age} 歳で、{city} に住んでいます。")

introduce("太郎", 25, "東京")

出力：

私は 太郎 です。25 歳で、東京 に住んでいます。

しかし、引数が増えると順番を間違えやすくなります。そこで、キーワード指定（名前付き引数）を使うと、引数の順番を気にせずに渡せます。

プログラム：

introduce(name="太郎", age=25, city="東京")
introduce(city="大阪", age=30, name="花子")

出力：

私は 太郎 です。25 歳で、東京 に住んでいます。
私は 花子 です。30 歳で、大阪 に住んでいます。

キーワード引数とデフォルト引数の組み合わせ

キーワード引数はデフォルト引数と組み合わせて使うことが多いです。デフォルト値を設定しておけば、省略した場合に自動で値が補完されます。

プログラム：

def order(product, quantity=1, price=1000):
    total = quantity * price
    print(f"{product} を {quantity} 個注文しました。合計 {total} 円です。")

# デフォルト引数を利用
order(product="りんご")  

# キーワード指定で一部を変更
order(product="バナナ", quantity=3)

出力：

りんご を 1 個注文しました。合計 1000 円です。
バナナ を 3 個注文しました。合計 3000 円です。

注意点

キーワード引数は位置引数（通常の引数）より後に書く必要があります。

プログラム：

order("みかん", price=500)

出力：

みかん を 1 個注文しました。合計 500 円です。

プログラム：

order(quantity=2, "ぶどう")

出力：

File "/var/folders/lc/k7jt3gx9283453ptp9t9ty5m0000gn/T/ipykernel_7791/1935673085.py", line 1
    order(quantity=2, "ぶどう")
                            ^
SyntaxError: positional argument follows keyword argument

可変長引数¶

Pythonでは、引数の数が不定な関数を定義することができます。これを「可変長引数」といい、 *args や **kwargs を使って実装します。

*args（位置引数の可変長引数）: *args を使うと、複数の引数をタプルとして受け取ることができます。関数の中で args はタプルになります。

基本的な使い方：

def sum_numbers(*args):
    total = sum(args)
    print(f"合計: {total}")

sum_numbers(1, 2, 3) 
sum_numbers(10, 20, 30, 40, 50)

出力：

合計: 6
合計: 150

特徴

✅ 引数の数が決まっていなくても関数を呼び出せる
✅ args はタプルなので、リストのように要素を取得できる

プログラム：

def show_args(*args):
    print(f"引数の個数: {len(args)}")
    for i, value in enumerate(args):
        print(f"引数 {i+1}: {value}")

show_args("Python", "Java", "C++")

出力：

引数の個数: 3
引数 1: Python
引数 2: Java
引数 3: C++

**kwargs（キーワード引数の可変長引数）: **kwargs を使うと、キーワード付きの可変長引数を辞書として受け取ることができます。

基本的な使い方：

def show_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

show_info(name="太郎", age=25, city="東京")

name: 太郎
age: 25
city: 東京

特徴

✅ kwargs は辞書（dict）なので、キーと値のペアで管理できる
✅ どの引数が渡されるかわからない場合に便利

プログラム：

def display_settings(**kwargs):
    if "theme" in kwargs:
        print(f"テーマ: {kwargs['theme']}")
    if "font_size" in kwargs:
        print(f"フォントサイズ: {kwargs['font_size']}")

display_settings(theme="dark", font_size=14, language="Japanese")

出力：

テーマ: dark
フォントサイズ: 14

*args と **kwargs を組み合わせる

*args と **kwargs を同時に使用することも可能です。

プログラム：

def mixed_example(*args, **kwargs):
    print("位置引数:")
    for arg in args:
        print(arg)

    print("\nキーワード引数:")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

mixed_example(1, 2, 3, name="太郎", age=30)

出力：

位置引数:
1
2
3

キーワード引数:
name: 太郎
age: 30

使う順番に注意！

関数を定義するときは、以下の順番で記述する必要があります。

位置引数（通常の引数）
*args（可変長の位置引数）
**kwargs（可変長のキーワード引数）

def example(a, b, *args, **kwargs):
    pass

✅ 正しい順番: (通常の引数, *args, **kwargs)
❌ エラーになる順番: (通常の引数, **kwargs, *args)

4. 独立性の破れ¶

グローバル変数¶

Pythonでは、関数の外側で定義された変数をグローバル変数と呼びます。通常、関数内で変数を定義するとローカル変数となり、関数外の変数（グローバル変数）とは別のものとして扱われます。しかし、関数内からグローバル変数を直接書き換えたり、global キーワードを使って変更することも可能です。

1. グローバル変数を関数内で使用する

関数内からグローバル変数を参照するだけなら、そのまま利用できます。

プログラム：

count = 0

def show_count():
    print(f"現在のカウント: {count}")

show_count()

出力：

現在のカウント: 0

✅ グローバル変数を読むだけならエラーにならない

2. グローバル変数を関数内で書き換えるとエラー

関数内でグローバル変数を変更しようとするとエラーになります。

プログラム：

count = 0

def increment():
    count += 1
    print(f"カウント: {count}")

increment()

出力：

---------------------------------------------------------------------------

UnboundLocalError                         Traceback (most recent call last)

/var/folders/lc/k7jt3gx9283453ptp9t9ty5m0000gn/T/ipykernel_9855/3299216266.py in <module>
        5     print(f"カウント: {count}")
        6 
----> 7 increment()


/var/folders/lc/k7jt3gx9283453ptp9t9ty5m0000gn/T/ipykernel_9855/3299216266.py in increment()
        2 
        3 def increment():
----> 4     count += 1
        5     print(f"カウント: {count}")
        6 


UnboundLocalError: local variable 'count' referenced before assignment

🔴 count を関数内で変更しようとすると、Pythonは count をローカル変数とみなす。しかし、ローカル変数として定義される前に参照しようとしているためエラーが発生するからです。

3. global キーワードを使って書き換える

global キーワードを使うと、関数内でグローバル変数を書き換えることができます。

プログラム：

count = 0

def increment():
    global count
    count += 1
    print(f"カウント: {count}")

increment()  
increment()

出力：

カウント: 1
カウント: 2

✅ global count を宣言すれば、関数内で count を書き換え可能

4. グローバル変数の問題点

(1) 副作用が発生しやすい

グローバル変数を関数内で変更すると、どこで値が変わるのか分かりにくくなるため、バグの原因になりやすい。

count = 0

def increment():
    global count
    count += 1

def reset():
    global count
    count = 0

increment()
increment()
reset()
increment()
print(count)

✅ 関数の動作が予測しづらくなる

(2) 関数の独立性が失われる関数の中でグローバル変数を使うと、その関数は外部の変数に依存するため、再利用しにくくなる。

total = 0

def add(x):
    global total
    total += x
    print(f"合計: {total}")

add(10)
add(20)

この関数は total に依存しているため、別の計算には使い回しにくい。

5. グローバル変数を避ける方法

✅ 関数の引数と戻り値を使うことで、グローバル変数を避けることができる。

def add(x, total):
    total += x
    return total

total = 0
total = add(10, total)
total = add(20, total)
print(total)

メリット:

total の値を明示的にやり取りするため、関数の独立性が保たれる。
関数がどの変数に影響を与えるのかが明確になり、バグが減る。

引数と戻り値の存在価値¶

プログラミングにおいて、関数は単なるコードの塊ではなく、「データの流れを整理し、再利用性を高める仕組み」です。その中核を担うのが「引数」と「戻り値」です。特に、チーム開発や大規模なシステムでは、関数の独立性が重要になり、それを確保するために引数と戻り値を適切に活用することが求められます。

関数の独立性を保つことの重要性

ソフトウェア開発において、関数が独立して動作することは極めて重要です。特にチーム開発では、複数人が同じコードベースを編集するため、関数が不用意に外部の状態を変更すると、意図しないバグや予期せぬ挙動が発生する原因になります。

引数と戻り値を適切に設計することで、関数の動作が明確になり、他のメンバーが関数を利用しやすくなります。

1. グローバル変数への依存が生む問題

もし関数がグローバル変数に依存していると、次のような問題が発生します。

チーム開発での競合 ... 同じグローバル変数を複数人が別々の意図で変更してしまい、思わぬバグを引き起こす。
関数の影響範囲が不明確になる ... どこで値が変更されるかわからず、デバッグが困難になる。
再利用性が低下する ... あるプロジェクトでは動いても、別のプロジェクトでは使えない可能性がある。

例えば、ある関数が外部の変数を変更する場合、その関数を呼び出す前後でどのような値がセットされているかを常に意識しなければならず、開発の負担が増えます。

2. 引数の意義：関数に必要なデータを明示的に渡す

関数に引数を渡すことで、「この関数が何を処理するのか」が明確になります。

関数の再利用性が高まる：引数を変更するだけで、異なるデータに対して処理を実行できる。
関数のテストが容易になる：さまざまな値を引数として渡すことで、関数の動作を簡単に検証できる。
コードの可読性が向上する：関数のインターフェースが明確になり、チームメンバーが直感的に利用しやすくなる。

また、引数を適切に定義することで、関数の責務がはっきりし、他の開発者が関数の目的を理解しやすくなります。

3. 戻り値の意義：関数の結果を適切に受け取る

関数の結果を戻り値として返すことで、関数の内部で行われた処理の結果を適切に取得できます。

データの流れが明確になる

関数の呼び出し元が、関数の処理結果を受け取って次の処理に活かせる。
関数の副作用を減らせる

関数内で不用意に外部の変数を書き換えないため、意図しない挙動を防げる。
関数の独立性を維持できる

戻り値を返すことで、関数が特定の環境に依存せず、どこでも使えるようになる。

例えば、関数の戻り値を変数に格納し、それを別の関数に渡すことで、関数間のデータの流れをシンプルに管理できます。

4. チーム開発における引数と戻り値の設計

チーム開発では、関数の引数と戻り値を適切に設計することが、バグの削減・可読性の向上・保守性の向上につながります。

設計のポイント:

必要なデータはすべて引数として渡す
- グローバル変数に依存せず、関数の動作を明確にする。
関数の結果は戻り値として返す
- 関数を呼び出した側が結果を明示的に受け取れるようにする。
関数が1つの責務に集中するようにする
- 複数の機能を詰め込まず、シンプルな構造を保つ。
引数や戻り値の型を統一する
- チームでのコードの一貫性を保ち、予測しやすい関数を作る。

結論：引数と戻り値の適切な利用が、良いコードを生む¶

関数の引数と戻り値を適切に設計することで、プログラムの可読性・保守性・再利用性が向上し、バグを減らしやすくなります。

特にチーム開発では、「誰が見ても分かりやすく、意図したとおりに動くコード」を書くことが重要です。そのために、関数の引数と戻り値を適切に活用し、グローバル変数への依存を避けることが、開発効率の向上と品質の安定につながります。

この章のまとめ¶

本章では、Pythonにおける「関数」について学びました。関数は、コードの再利用性を高め、プログラムの可読性を向上させる重要な仕組みです。

1. 関数の基本

def を使って関数を定義し、呼び出し演算子 () で実行する。
ローカル変数を利用することで、関数の独立性を保つ。

2. 引数と戻り値

引数を使って外部からデータを受け取り、戻り値を通じて処理結果を返す。
関数同士を連携させることで、より柔軟なプログラムが書ける。

3. 関数の応用テクニック

デフォルト引数で省略可能なパラメータを設定できる。
キーワード引数を活用すると、可読性の高い関数呼び出しが可能。
可変長引数 (*args, **kwargs) で柔軟な関数を作成できる。

4. 独立性の破れとその対策

グローバル変数は関数の独立性を損なうため、極力避けるべき。
引数と戻り値を適切に利用することで、関数の責務を明確にする。

関数を適切に設計し、データの流れを整理することで、保守性の高いプログラムを作成できるようになります。

練習問題¶

問題 1: 関数の基本

次の説明が正しい場合は〇、誤っている場合は× を答えてください。

関数を定義するには def キーワードを使用する。
関数の名前の後に () をつけて定義する必要がある。
return を使うことで関数の実行結果を呼び出し元に返せる。
Python では関数を定義しなくても、コードを繰り返し使うことは可能である。
関数を呼び出すには、関数名の後に () をつける必要がある。

問題 2: 引数と戻り値

次の関数 calculate_area は、四角形の面積を計算する関数です。この関数には「引数」と「戻り値」があるかどうかを答えてください。

def calculate_area(width, height):
    area = width * height
    print(f"面積は {area} です")

問題 3: デフォルト引数

次の関数 greet には、デフォルト引数を設定しようとしています。適切に修正してください。

def greet(message="こんにちは", name):
    print(f"{message}, {name}さん！")

問題 4: 可変長引数

次の sum_numbers 関数は、渡された数値をすべて足し合わせる関数です。*args を利用して修正してください。

def sum_numbers(a, b, c):
    return a + b + c

問題 5: グローバル変数の影響

次のコードを実行すると、どのような出力になりますか？また、このコードの問題点を説明してください。

count = 0  

def increment():
    count += 1  
    print(count)  

increment()

👉 次の章では、オブジェクト について学び、より実用的なプログラムを作成していきましょう！