プログラミングの関数とは？初心者がつまずく使い方・引数・戻り値をわかりやすく解説

はじめに

プログラミングを学び始めると、早い段階で「関数」という言葉に出会います。しかし、関数の定義や呼び出し方を覚えても、「引数と戻り値の違いが分からない」「なぜ関数を使う必要があるのか理解できない」と悩む初心者は少なくありません。

プログラミングにおける関数とは、複数の処理をひとまとまりにし、必要なときに呼び出せるようにした仕組みです。同じ処理を何度も書く必要がなくなるため、コードを短く整理でき、修正や再利用もしやすくなります。

この記事では、プログラミングの関数について、引数や戻り値、変数のスコープ、初心者がつまずきやすいポイントを、Pythonのコード例を中心にわかりやすく解説します。JavaScriptやJava、C言語における関数の書き方も紹介するので、関数の基本を身につけたい方は順番に確認していきましょう。

1. プログラミングの関数とは？

1-1. 関数は複数の処理をひとまとまりにしたもの

プログラミングにおける関数とは、特定の目的を持つ処理をひとまとまりにしたものです。

例えば、ユーザーの名前を受け取り、あいさつを表示する処理を考えてみましょう。

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

この例では、文字列を作成して画面に表示するまでの処理を、greetという名前の関数にまとめています。

関数を使用するときは、次のように関数名を書いて呼び出します。

greet("田中")

実行結果は次のとおりです。

こんにちは、田中さん

一度関数を定義すれば、必要な場所から何度でも呼び出せます。

greet("田中")greet("佐藤")greet("鈴木")

関数は、よく使う処理に名前を付けて保存しておく仕組みだと考えると理解しやすいでしょう。

1-2. 関数を使う目的とメリット

関数を使う主な目的は、コードを整理し、同じ処理を再利用できるようにすることです。

関数には、次のようなメリットがあります。

• 同じコードを何度も書かずに済む

• プログラム全体の見通しがよくなる

• 処理内容を変更するときに修正箇所を減らせる

• 関数単位で動作確認やテストができる

• 複数人でプログラムを分担しやすくなる

• 別のプログラムでも処理を再利用できる

例えば、商品の税込価格を計算する処理を複数の場所に直接書くと、税率を変更するときにすべての箇所を修正しなければなりません。

price1 = 1000 * 1.1price2 = 2000 * 1.1price3 = 3000 * 1.1

関数にまとめておけば、計算方法を変更する際は関数の中だけを修正できます。

def calculate_tax_included_price(price):return price * 1.1
price1 = calculate_tax_included_price(1000)price2 = calculate_tax_included_price(2000)price3 = calculate_tax_included_price(3000)

プログラムが大きくなるほど、関数によって処理を分ける重要性も高まります。

1-3. 関数とメソッドの違い

関数と似た言葉に「メソッド」があります。どちらも処理をまとめたものですが、一般的には所属先があるかどうかによって区別されます。

関数は、単独で定義して呼び出せる処理です。

print("こんにちは")

一方、メソッドは、オブジェクトやクラスに所属する関数です。Pythonでは、文字列の後ろに付けて使用するupperなどがメソッドに該当します。

text = "hello"result = text.upper()
print(result)

実行結果は次のとおりです。

HELLO

upperは文字列オブジェクトに所属しているため、text.upper()のように、対象となるオブジェクトとドットでつないで呼び出します。

ただし、関数とメソッドの扱いや呼び方はプログラミング言語によって異なります。Javaのように、基本的な処理をクラス内に定義する言語では、一般的に「関数」ではなく「メソッド」と呼びます。

初心者の段階では、次のように覚えておくとよいでしょう。

• 単独で呼び出す処理：関数

• オブジェクトやクラスに所属する処理：メソッド

1-4. 数学の関数とプログラミングの関数の違い

数学の関数は、入力された値に対して、決められた規則で出力を返すものです。

例えば、次の式を考えてみましょう。

y = 2x + 1

xに3を入力すると、yは7になります。

プログラミングの関数にも、データを受け取り、処理結果を返す仕組みがあります。

def calculate(x):return 2 * x + 1
result = calculate(3)print(result)

実行結果は7です。

ただし、プログラミングの関数は、必ず値を受け取ったり返したりするとは限りません。画面に文字を表示するだけの関数や、ファイルを保存する関数などもあります。

def show_message():print("処理が完了しました")

数学の関数は入力と出力の関係を表すものですが、プログラミングの関数は、さまざまな処理をまとめて実行するための仕組みです。

2. 関数の基本構造と使い方

2-1. 関数を定義する

関数を作成することを「関数を定義する」といいます。

Pythonでは、defの後に関数名を書き、丸括弧とコロンを続けます。実行する処理は、次の行からインデントして記述します。

def greet():print("こんにちは")

基本的な構造は次のとおりです。

def 関数名():実行する処理

この時点では、関数の内容が登録されただけであり、関数内の処理はまだ実行されません。

2-2. 関数を呼び出す

定義した関数を実行するには、関数名の後ろに丸括弧を付けて記述します。この操作を「関数を呼び出す」といいます。

def greet():print("こんにちは")
greet()

実行結果は次のとおりです。

こんにちは

関数は何度でも呼び出せます。

greet()greet()greet()

この場合、「こんにちは」が3回表示されます。

関数を定義しただけでは処理が実行されないため、必要な場所で呼び出すことが重要です。

2-3. 関数名を付けるときの基本ルール

関数名には、その関数が何をするのか分かる名前を付けましょう。

例えば、合計を計算する関数であれば、次のような名前が適しています。

def calculate_total():pass

次のような名前では、処理内容を判断できません。

def func1():pass

Pythonでは、複数の単語をアンダースコアで区切るスネークケースが一般的です。

def calculate_total_price():pass

JavaScriptやJavaでは、2語目以降の先頭を大文字にするキャメルケースがよく使われます。

function calculateTotalPrice() {}

関数名を付ける際は、次の点を意識しましょう。

• 処理内容を表す英単語を使う

• 動作を表す動詞から始める

• 略語を多用しない

• プロジェクト内の命名規則に合わせる

• 言語で予約されている単語を使用しない

表示する関数ならshowやdisplay、取得する関数ならget、判定する関数ならisやhasなどを使うと、役割が伝わりやすくなります。

2-4. 組み込み関数と自作関数の違い

プログラミング言語には、最初から用意されている関数があります。これを「組み込み関数」といいます。

Pythonのprintやlenは、代表的な組み込み関数です。

print("こんにちは")
length = len("programming")print(length)

一方、自分で定義した関数は「自作関数」または「ユーザー定義関数」と呼ばれます。

def show_length(text):print(len(text))
show_length("programming")

組み込み関数は、表示、型変換、要素数の取得など、よく使われる基本的な処理を提供します。自作関数は、作成するプログラムに合わせた独自の処理をまとめるために使用します。

実際の開発では、組み込み関数やライブラリの関数と、自作関数を組み合わせてプログラムを作ります。

2-5. 関数が実行される流れ

関数を含むプログラムは、基本的に次の流れで実行されます。

1. 関数の定義を読み込む

2. 関数が呼び出される

3. 関数内の処理に移動する

4. 関数内の処理を上から順番に実行する

5. 処理が終わると呼び出し元に戻る

次のコードで確認してみましょう。

def greet():print("関数の中です")
print("関数を呼び出す前です")greet()print("関数を呼び出した後です")

実行結果は次のとおりです。

関数を呼び出す前です関数の中です関数を呼び出した後です

関数が呼び出されると、一時的に関数内の処理へ移動し、処理が終わると元の場所に戻ります。この流れを理解しておくと、複数の関数を使うプログラムも追いやすくなります。

3. 関数の引数とは？

3-1. 引数は関数に渡すデータ

引数とは、関数を呼び出すときに渡すデータです。関数は、受け取った引数に応じて処理内容を変えられます。

def greet(name):print(f"こんにちは、{name}さん")
greet("田中")greet("佐藤")

実行結果は次のとおりです。

こんにちは、田中さんこんにちは、佐藤さん

同じ関数でも、渡すデータを変えることで異なる結果を得られます。

引数を使わずに個別の関数を作ると、似たような処理を何度も書かなければなりません。

def greet_tanaka():print("こんにちは、田中さん")
def greet_sato():print("こんにちは、佐藤さん")

引数を利用すれば、1つの関数でさまざまなデータに対応できます。

3-2. 仮引数と実引数の違い

引数には「仮引数」と「実引数」があります。

仮引数は、関数を定義するときに、受け取るデータの入れ物として記述する変数です。

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

このコードでは、nameが仮引数です。

実引数は、関数を呼び出すときに実際に渡す値です。

greet("田中")

このコードでは、"田中"が実引数です。

関数が呼び出されると、実引数の"田中"が仮引数のnameに渡されます。

用語を整理すると、次のようになります。

def greet(name):     # nameは仮引数print(name)
greet("田中")        # "田中"は実引数

日常的な説明では、仮引数と実引数をまとめて「引数」と呼ぶことも多くあります。

3-3. 引数がない関数の書き方

関数は、必ず引数を受け取る必要があるわけではありません。

引数が不要な場合は、丸括弧の中を空にします。

def show_message():print("処理を開始します")
show_message()

現在時刻を表示する処理や、固定されたメッセージを表示する処理など、外部からデータを受け取る必要がない場合に使います。

ただし、引数がない関数でも、呼び出すときの丸括弧は必要です。

show_message()

次のように関数名だけを書くと、通常は関数そのものを参照するだけで、処理は実行されません。

show_message

3-4. 複数の引数を渡す方法

関数には複数の引数を渡せます。Pythonでは、引数をカンマで区切って記述します。

def introduce(name, age):print(f"名前は{name}です")print(f"年齢は{age}歳です")
introduce("田中", 25)

実行結果は次のとおりです。

名前は田中です年齢は25歳です

通常、実引数は仮引数と同じ順番で渡します。

def calculate_price(price, quantity):return price * quantity
total = calculate_price(500, 3)print(total)

この例では、500がpriceに、3がquantityに渡されます。

順番を逆にすると、意図しない計算になる可能性があります。そのため、引数名を見ただけで内容を判断できるようにしておくことが大切です。

3-5. デフォルト引数とキーワード引数

Pythonでは、引数にあらかじめ初期値を設定できます。これをデフォルト引数といいます。

def greet(name, message="こんにちは"):print(f"{message}、{name}さん")
greet("田中")greet("佐藤", "おはようございます")

実行結果は次のとおりです。

こんにちは、田中さんおはようございます、佐藤さん

messageが省略された場合は、初期値の"こんにちは"が使用されます。

また、引数名を指定して値を渡す方法をキーワード引数といいます。

def introduce(name, age, city):print(f"{name}さんは{age}歳で、{city}に住んでいます")
introduce(name="田中", age=25, city="東京")

キーワード引数では、引数名と値の対応が明確になります。また、必要に応じて順番を変えることもできます。

introduce(city="大阪", name="佐藤", age=30)

引数が多い関数では、キーワード引数を使うとコードの意味が読み取りやすくなります。

3-6. 引数の数や順番を間違えたときのエラー

関数が必要とする引数の数と、実際に渡した引数の数が一致しない場合、エラーが発生します。

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

add関数は2つの引数を必要としますが、1つしか渡していないため、PythonではTypeErrorが発生します。

反対に、引数を多く渡してもエラーになります。

add(10, 20, 30)

また、引数の型が想定と異なる場合も注意が必要です。

def add(a, b):return a + b
result = add(10, "20")

整数と文字列をそのまま足すことはできないため、エラーになります。

エラーが発生したときは、次の点を確認しましょう。

• 必要な引数の数

• 引数を渡す順番

• 引数のデータ型

• 引数名のスペル

• デフォルト値の有無

エラーメッセージには、足りない引数や問題のある箇所が示されることが多いため、内容を落ち着いて読むことも大切です。

4. 関数の戻り値とは？

4-1. 戻り値は関数の処理結果

戻り値とは、関数が処理した結果として、呼び出し元に返す値です。

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

この関数を呼び出すと、a + bの計算結果が呼び出し元に返されます。

result = add(10, 20)print(result)

実行結果は次のとおりです。

30

引数が関数への入力であるのに対し、戻り値は関数からの出力です。

• 引数：関数に渡すデータ

• 戻り値：関数から受け取る処理結果

この違いを理解すると、関数の仕組みを整理しやすくなります。

4-2. returnの役割と基本的な書き方

Pythonでは、returnを使って戻り値を返します。

def multiply(a, b):return a * b

returnには、主に2つの役割があります。

1つ目は、値を呼び出し元に返すことです。

result = multiply(4, 5)print(result)

2つ目は、関数の処理を終了することです。

def check_age(age):if age < 0:return "年齢が正しくありません"
return "年齢を受け付けました"</span></code></pre><p><code dir="ltr"><span>age</span></code><span>が負の数だった場合、最初の</span><code dir="ltr"><span>return</span></code><span>が実行された時点で関数が終了します。</span></p><h3><span>4-3. 戻り値を変数に代入する方法</span></h3><p><span>関数から返された戻り値は、変数に代入できます。</span></p><pre dir="ltr"><code dir="ltr"><span>def calculate_area(width, height):return width * height
area = calculate_area(5, 3)print(area)

変数に代入した戻り値は、後続の処理で利用できます。

area = calculate_area(5, 3)double_area = area * 2
print(double_area)

戻り値は、別の関数の引数として直接渡すことも可能です。

print(calculate_area(5, 3))

複数の処理を組み合わせる場合は、一度変数に代入すると処理の流れが分かりやすくなります。

4-4. 戻り値がない関数の動作

関数には、明示的な戻り値がないものもあります。

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

この関数は文字列を表示しますが、returnで値を返してはいません。

Pythonでは、明示的なreturnがない関数は、Noneという特別な値を返します。

result = greet("田中")print(result)

実行結果は次のとおりです。

こんにちは、田中さんNone

Noneは「有効な値が存在しない」ことを表します。

画面表示やファイル保存など、処理の実行自体が目的であれば、戻り値がなくても問題ありません。一方、計算結果を後で使いたい場合は、returnで値を返す必要があります。

4-5. 複数の値を返す方法

Pythonでは、1つの関数から複数の値をまとめて返せます。

def calculate(a, b):total = a + bdifference = a - breturn total, difference

戻り値は、複数の変数に分けて受け取れます。

total, difference = calculate(10, 3)
print(total)print(difference)

実行結果は次のとおりです。

137

Pythonでは、複数の値がタプルとしてまとめられて返されます。

result = calculate(10, 3)print(result)

実行結果は次のとおりです。

(13, 7)

値の意味を分かりやすくしたい場合は、辞書を返す方法もあります。

def calculate(a, b):return {"total": a + b,"difference": a - b}

戻り値が増えるほど内容を把握しにくくなるため、必要な情報だけを返すことが重要です。

4-6. returnと画面への出力の違い

初心者が特に混同しやすいのが、returnとprintの違いです。

printは、値を画面に表示するための関数です。

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

returnは、値を呼び出し元へ返すための命令です。

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

printを使った関数では、表示された値を後の計算に利用できません。

def add(a, b):print(a + b)
result = add(10, 20)print(result)

resultには計算結果ではなく、Noneが代入されます。

一方、returnで返せば、戻り値を別の計算に利用できます。

def add(a, b):return a + b
result = add(10, 20)answer = result * 2
print(answer)

実行結果は60です。

処理結果を確認するだけならprint、処理結果を後から利用するならreturnと考えるとよいでしょう。

5. 関数を使った簡単なプログラム例

5-1. 文字列を表示する関数

最も基本的な例として、メッセージを表示する関数を作成します。

def show_welcome_message():print("プログラミング学習を始めましょう")
show_welcome_message()

引数を追加すると、表示内容を変えられます。

def show_welcome_message(name):print(f"{name}さん、プログラミング学習を始めましょう")
show_welcome_message("田中")

固定された処理は引数なしの関数、データに応じて処理を変えたい場合は引数ありの関数にするとよいでしょう。

5-2. 2つの数値を計算する関数

2つの数値を足し算する関数は、次のように書けます。

def add(a, b):return a + b
result = add(8, 5)print(result)

引き算や掛け算も同様に作成できます。

def subtract(a, b):return a - b
def multiply(a, b):return a * b
print(subtract(10, 4))print(multiply(6, 7))

計算処理を関数にすることで、異なる数値を使って何度でも再利用できます。

5-3. 引数と戻り値を組み合わせた関数

商品の単価と個数を受け取り、合計金額を返す関数を作ってみましょう。

def calculate_total_price(unit_price, quantity):total = unit_price * quantityreturn total
price = calculate_total_price(1200, 3)print(f"合計金額は{price}円です")

実行結果は次のとおりです。

合計金額は3600円です

この関数では、単価と個数が引数、計算した合計金額が戻り値です。

さらに税込価格を計算する関数へ戻り値を渡すこともできます。

def calculate_total_price(unit_price, quantity):return unit_price * quantity
def add_tax(price, tax_rate=0.1):return price * (1 + tax_rate)
subtotal = calculate_total_price(1200, 3)total = add_tax(subtotal)
print(total)

小さな関数を組み合わせることで、複雑な処理も整理しやすくなります。

5-4. 条件分岐を含む関数

関数の中では、ifを使った条件分岐も記述できます。

def check_score(score):if score >= 80:return "合格です"else:return "不合格です"
result = check_score(85)print(result)

条件が複数ある場合は、elifを使います。

def get_grade(score):if score >= 90:return "A"elif score >= 80:return "B"elif score >= 70:return "C"else:return "D"
print(get_grade(82))

関数に判定処理をまとめると、同じ条件分岐を複数の場所で再利用できます。

5-5. 繰り返し処理を含む関数

関数の中にforなどの繰り返し処理を記述することもできます。

def show_names(names):for name in names:print(f"{name}さん")
user_names = ["田中", "佐藤", "鈴木"]show_names(user_names)

数値の合計を計算する例は次のとおりです。

def calculate_sum(numbers):total = 0
for number in numbers:total += numberreturn total
result = calculate_sum([10, 20, 30])print(result)

実行結果は60です。

Pythonには合計を求めるsumという組み込み関数がありますが、繰り返し処理の仕組みを理解する練習として、自分で関数を作ってみるのも有効です。

5-6. 同じ処理を関数化する前後のコード比較

関数化する前のコードを見てみましょう。

price1 = 1000tax_included_price1 = price1 * 1.1print(f"税込価格は{tax_included_price1}円です")
price2 = 2000tax_included_price2 = price2 * 1.1print(f"税込価格は{tax_included_price2}円です")
price3 = 3000tax_included_price3 = price3 * 1.1print(f"税込価格は{tax_included_price3}円です")

同じ計算と表示の処理が繰り返されています。

関数化すると、次のように整理できます。

def show_tax_included_price(price):tax_included_price = price * 1.1print(f"税込価格は{tax_included_price}円です")
show_tax_included_price(1000)show_tax_included_price(2000)show_tax_included_price(3000)

さらに、価格をリストにまとめて繰り返し処理を使えば、より簡潔になります。

def show_tax_included_price(price):tax_included_price = price * 1.1print(f"税込価格は{tax_included_price}円です")
prices = [1000, 2000, 3000]
for price in prices:show_tax_included_price(price)

関数化によってコードの重複が減り、計算方法を変更するときも1か所を修正するだけで済みます。

6. 初心者が関数でつまずきやすいポイント

6-1. 関数を定義しただけで呼び出していない

関数は定義しただけでは実行されません。

def greet():print("こんにちは")

このコードを実行しても、画面には何も表示されません。

処理を実行するには、関数を呼び出す必要があります。

def greet():print("こんにちは")
greet()

「エラーは出ないのに何も起こらない」という場合は、関数を呼び出しているか確認しましょう。

6-2. 引数と戻り値を混同している

引数と戻り値は、データが移動する方向が異なります。

def double(number):return number * 2

この例では、numberが関数に入るデータであり、number * 2が関数から出るデータです。

result = double(5)

• 5：実引数

• number：仮引数

• 10：戻り値

• result：戻り値を受け取る変数

関数を箱に例えるなら、引数は箱に入れる材料、戻り値は箱から出てくる完成品です。

6-3. returnを書き忘れている

計算結果を後から使いたい場合は、returnが必要です。

def add(a, b):total = a + b

この関数では、totalを計算していますが、呼び出し元に返していません。

result = add(10, 20)print(result)

実行結果はNoneになります。

次のようにreturnを追加しましょう。

def add(a, b):total = a + breturn total

関数内で正しく計算されていても、returnがなければ結果を外で利用できない点に注意が必要です。

6-4. returnの後に処理を書いている

returnが実行されると、その時点で関数は終了します。そのため、同じ処理経路にあるreturnの後のコードは実行されません。

def greet():return "こんにちは"print("この処理は実行されません")

printはreturnより後ろにあるため、実行されません。

表示してから値を返したい場合は、順番を入れ替えます。

def greet():print("関数を実行しました")return "こんにちは"

ただし、条件分岐の中にあるreturnの後でも、別の条件で通る処理は実行される可能性があります。

def check_number(number):if number < 0:return "負の数です"
return "0以上です"</span></code></pre><p><code dir="ltr"><span>number</span></code><span>が0以上の場合、最初の</span><code dir="ltr"><span>return</span></code><span>は実行されないため、最後の</span><code dir="ltr"><span>return</span></code><span>まで処理が進みます。</span></p><h3><span>6-5. 変数のスコープを理解できていない</span></h3><p><span>関数の中で作成した変数は、通常、その関数の外では使えません。</span></p><pre dir="ltr"><code dir="ltr"><span>def calculate():total = 100 + 200print(total)
calculate()print(total)

最後のprint(total)では、totalが見つからないためエラーになります。

関数の外で値を使いたい場合は、戻り値として返しましょう。

def calculate():total = 100 + 200return total
result = calculate()print(result)

変数を使える範囲を「スコープ」といいます。スコープについては後の章で詳しく解説します。

6-6. 関数名や引数名が分かりにくい

短すぎる名前や意味のない名前は、処理内容を理解しにくくします。

def f(a, b):return a * b

次のように書けば、関数の役割や引数の意味が明確になります。

def calculate_total_price(unit_price, quantity):return unit_price * quantity

学習用の短いコードではaやbでも問題ありませんが、実際の開発では、何を表す値なのか分かる名前を付けましょう。

6-7. 1つの関数に処理を詰め込みすぎている

1つの関数で、入力、計算、判定、表示、保存などをすべて行うと、コードが読みにくくなります。

def process_order():# 注文データを取得する# 合計金額を計算する# 割引を判定する# 結果を表示する# ファイルに保存するpass

役割ごとに関数を分けると、処理の流れを理解しやすくなります。

def calculate_total_price(items):pass
def apply_discount(total_price):pass
def display_order(total_price):pass
def save_order(order):pass

関数を小さく分ければ、特定の処理だけを修正したり、個別にテストしたりしやすくなります。

7. 関数と変数のスコープ

7-1. ローカル変数とは？

ローカル変数とは、関数の中で定義され、その関数内でのみ使用できる変数です。

def greet():message = "こんにちは"print(message)
greet()

この例のmessageはローカル変数です。

関数の外から使用することはできません。

def greet():message = "こんにちは"
greet()print(message)

このコードでは、messageが定義されていないというエラーが発生します。

ローカル変数は関数ごとに独立しているため、別の関数で同じ変数名を使っても、通常は別の変数として扱われます。

def function_a():message = "Aのメッセージ"print(message)
def function_b():message = "Bのメッセージ"print(message)

7-2. グローバル変数とは？

グローバル変数とは、関数の外で定義され、広い範囲から参照できる変数です。

message = "こんにちは"
def greet():print(message)
greet()

関数の中から、外側にあるmessageを参照できます。

ただし、関数内で同じ名前の変数に値を代入すると、通常は新しいローカル変数として扱われます。

message = "こんにちは"
def greet():message = "おはようございます"print(message)
greet()print(message)

実行結果は次のとおりです。

おはようございますこんにちは

関数内のmessageと、関数外のmessageは別の変数です。

7-3. 関数の外にある変数を使う際の注意点

関数の外にある変数を参照することはできますが、関数が外部の状態に依存すると、動作を理解しにくくなる場合があります。

tax_rate = 0.1
def calculate_price(price):return price * (1 + tax_rate)

この関数の結果は、外部にあるtax_rateの値によって変わります。

引数として渡せば、必要なデータが明確になります。

def calculate_price(price, tax_rate):return price * (1 + tax_rate)
result = calculate_price(1000, 0.1)

関数が必要とする値は、できるだけ引数として受け取るようにすると、再利用やテストがしやすくなります。

7-4. スコープによってエラーが起こる具体例

次のコードでは、関数内で作成した変数を外から使用しようとしています。

def calculate_total():total = 1000 + 2000
calculate_total()print(total)

totalはローカル変数なので、関数外のprintからは参照できません。

戻り値を使って修正します。

def calculate_total():total = 1000 + 2000return total
result = calculate_total()print(result)

次の例では、関数内でグローバル変数を変更しようとしています。

count = 0
def increase_count():count = count + 1

Pythonでは、関数内でcountに代入しようとした時点で、ローカル変数として扱われます。しかし、右辺のcountにはまだ値が入っていないため、エラーになります。

globalを使えば変更できます。

count = 0
def increase_count():global countcount = count + 1

ただし、グローバル変数の書き換えはプログラムを複雑にしやすいため、できるだけ戻り値を使う設計が望ましいでしょう。

def increase_count(count):return count + 1
count = 0count = increase_count(count)

7-5. グローバル変数を多用しないほうがよい理由

グローバル変数は便利ですが、多用すると次のような問題が起こります。

• どこで値が変更されたのか分かりにくい

• 関数の結果が外部の状態によって変化する

• 関数を別のプログラムで再利用しにくい

• テストの条件を整えるのが難しくなる

• 同じ変数名の使用による不具合が起こりやすい

例えば、複数の関数が同じグローバル変数を書き換えると、実行順序によって結果が変わる可能性があります。

必要な値は引数として受け取り、処理結果は戻り値として返す形にすると、関数同士の関係が明確になります。

def calculate_discount(price, discount_rate):return price * (1 - discount_rate)

外部の状態にできるだけ依存しない関数は、動作を予測しやすく、修正や再利用もしやすくなります。

8. プログラミング言語による関数の書き方の違い

8-1. Pythonで関数を定義する方法

Pythonでは、defを使って関数を定義します。

def add(a, b):return a + b
result = add(10, 20)print(result)

Pythonは波括弧を使わず、インデントによって関数の範囲を表します。

戻り値の型を明示したい場合は、型ヒントを付けることもできます。

def add(a: int, b: int) -> int:return a + b

型ヒントは、引数や戻り値として想定するデータ型を示すものです。ただし、型ヒントを書いただけで実行時の型が自動的に強制されるわけではありません。

8-2. JavaScriptで関数を定義する方法

JavaScriptでは、functionを使って関数を定義できます。

function add(a, b) {return a + b;}
const result = add(10, 20);console.log(result);

JavaScriptには、アロー関数という書き方もあります。

const add = (a, b) => {return a + b;};

処理が1つの式だけであれば、さらに短く書けます。

const add = (a, b) => a + b;

通常の関数とアロー関数では、thisの扱いなどに違いがあります。初心者のうちは、まず引数を受け取って戻り値を返す基本的な使い方を理解しましょう。

8-3. Javaでメソッドを定義する方法

Javaでは、基本的にクラスの中にメソッドを定義します。

public class Main {public static int add(int a, int b) {return a + b;}
public static void main(String[] args) {int result = add(10, 20);System.out.println(result);}
}

intは、戻り値が整数であることを表します。引数にもデータ型を指定します。

public static int add(int a, int b)

戻り値がないメソッドでは、voidを指定します。

public static void greet() {System.out.println("こんにちは");}

Javaでは、アクセス修飾子、staticの有無、引数と戻り値の型などを記述する必要があります。

8-4. C言語で関数を定義する方法

C言語では、戻り値の型、関数名、引数の型を記述して関数を定義します。

#include <stdio.h>
int add(int a, int b) {return a + b;}
int main(void) {int result = add(10, 20);printf("%d\n", result);
return 0;
}

戻り値がない関数では、voidを指定します。

void greet(void) {printf("こんにちは\n");}

C言語では、関数を呼び出す位置によっては、事前に関数プロトタイプを宣言する必要があります。

int add(int a, int b);

Pythonに比べると記述する情報は多いものの、引数を受け取り、処理を行い、戻り値を返すという基本的な考え方は同じです。

8-5. 言語が違っても共通する関数の考え方

プログラミング言語によって、関数を定義するためのキーワードや記号、型の書き方は異なります。

しかし、次の基本的な考え方は多くの言語に共通しています。

• 関数には名前がある

• 関数は必要に応じて引数を受け取る

• 関数内に実行する処理を書く

• 必要に応じて戻り値を返す

• 定義した関数は呼び出して使用する

• 同じ関数を何度でも再利用できる

1つの言語で関数の仕組みを理解すれば、別の言語を学ぶ際も、主に文法の違いを覚えるだけで対応しやすくなります。

9. 関数を上手に作るためのコツ

9-1. 1つの関数に1つの役割を持たせる

関数を作るときは、1つの関数に1つの役割を持たせることを意識しましょう。

例えば、合計金額の計算と画面表示を別の関数に分けます。

def calculate_total_price(unit_price, quantity):return unit_price * quantity
def display_total_price(total_price):print(f"合計金額は{total_price}円です")

役割を分けることで、計算だけを別の場所で再利用できます。

total = calculate_total_price(1000, 3)display_total_price(total)

関数名を「○○して○○して○○する」と説明しなければならない場合は、複数の役割が詰め込まれている可能性があります。

9-2. 処理内容が伝わる関数名を付ける

関数名を見ただけで、何をする処理なのか分かるようにしましょう。

def get_user_name():pass
def calculate_average_score():pass
def save_order_data():pass
def is_adult(age):return age >= 18

次のような名前は避けたほうがよいでしょう。

def do_it():pass
def data():pass
def process1():pass

適切な関数名は、コメントがなくてもコードの目的を伝えてくれます。

9-3. 引数の数を増やしすぎない

引数が多すぎる関数は、呼び出し方が分かりにくくなります。

def create_user(name, age, email, city, address, phone, job):pass

関連するデータを辞書やオブジェクトにまとめる方法があります。

def create_user(user_data):name = user_data["name"]email = user_data["email"]

ただし、引数をまとめれば必ずよいわけではありません。関数の役割が大きすぎるために引数が増えている場合は、関数自体を分割することも検討しましょう。

9-4. 戻り値の形式を統一する

同じ関数が、状況によって文字列、数値、リストなど異なる形式を返すと、呼び出し側で扱いにくくなります。

def find_user(user_id):if user_id == 1:return {"id": 1, "name": "田中"}
return "ユーザーが見つかりません"</span></code></pre><p><span>成功時は辞書、失敗時は文字列が返されるため、戻り値の型を毎回確認しなければなりません。</span></p><p><span>見つからない場合は</span><code dir="ltr"><span>None</span></code><span>を返すなど、一定のルールを決めておくと扱いやすくなります。</span></p><pre dir="ltr"><code dir="ltr"><span>def find_user(user_id):if user_id == 1:return {"id": 1, "name": "田中"}return None</span></code></pre><p><span>戻り値の仕様を統一すると、関数を利用する側のコードも単純になります。</span></p><h3><span>9-5. 重複した処理を見つけて関数化する</span></h3><p><span>同じ処理や似た処理が複数の場所に現れたら、関数化を検討しましょう。</span></p><pre dir="ltr"><code dir="ltr"><span>price_a = 1000 * 1.1
price_b = 2000 * 1.1price_c = 3000 * 1.1

共通する計算を関数にまとめます。

def add_tax(price, tax_rate=0.1):return price * (1 + tax_rate)

ただし、一度しか使わない短い処理をすべて関数にする必要はありません。重複を減らせるか、処理に分かりやすい名前を付けられるか、独立してテストする価値があるかを基準に判断しましょう。

9-6. コメントやドキュメントを記述する

関数の目的や使い方が分かりにくい場合は、コメントやドキュメントを記述します。

Pythonでは、関数の先頭にドキュメンテーション文字列であるdocstringを書けます。

def calculate_total_price(unit_price, quantity):"""商品の単価と個数から合計金額を計算する。
unit_price: 商品1個あたりの価格quantity: 商品の個数"""return unit_price * quantity</span></code></pre><p><span>型ヒントと組み合わせると、引数や戻り値の意味がさらに分かりやすくなります。</span></p><pre dir="ltr"><code dir="ltr"><span>def calculate_total_price(unit_price: int, quantity: int) -&gt; int:"""商品の単価と個数から合計金額を返す。"""return unit_price * quantity</span></code></pre><p><span>ただし、コードを読めば分かる内容をコメントで繰り返す必要はありません。処理の背景、注意点、入力条件など、コードだけでは伝わりにくい情報を書くことが重要です。</span></p><h3><span>9-7. 小さな関数から練習する</span></h3><p><span>関数の学習では、最初から複雑な処理を作ろうとせず、小さな関数から練習しましょう。</span></p><p><span>例えば、次のような関数が練習に適しています。</span></p><pre dir="ltr"><code dir="ltr"><span>def square(number):return number * number</span></code></pre><pre dir="ltr"><code dir="ltr"><span>def is_even(number):return number % 2 == 0</span></code></pre><pre dir="ltr"><code dir="ltr"><span>def create_full_name(last_name, first_name):return last_name + first_name</span></code></pre><pre dir="ltr"><code dir="ltr"><span>def convert_minutes_to_seconds(minutes):return minutes * 60</span></code></pre><p><span>慣れてきたら、条件分岐や繰り返し処理を追加し、複数の関数を組み合わせたプログラムへ発展させていきましょう。</span></p><h2><span>10. プログラミングの関数に関するよくある質問</span></h2><h3><span>10-1. 関数は必ず使わなければならない？</span></h3><p><span>短いプログラムであれば、関数を使わなくても動かせます。</span></p><pre dir="ltr"><code dir="ltr"><span>name = "田中"
print(f"こんにちは、{name}さん")

しかし、プログラムが長くなると、処理の重複や修正漏れが起こりやすくなります。関数を使って役割ごとに処理を分ければ、コードを読みやすく保てます。

関数は文法上必ず使わなければならないものではありませんが、保守しやすいプログラムを作るうえで非常に重要です。

10-2. 関数はどのタイミングで作ればよい？

次のような場合は、関数化を検討するタイミングです。

• 同じ処理を複数回書いている

• 一連の処理に分かりやすい名前を付けられる

• 1つの処理が長くなっている

• 独立して動作確認したい

• 別の場所でも再利用する可能性がある

最初からすべての関数構成を決める必要はありません。まずコードを書き、重複や役割のまとまりが見えてきた段階で関数に分ける方法もあります。

10-3. 引数と戻り値は必ず必要？

引数と戻り値は、どちらも必須ではありません。

引数も戻り値もない関数は、次のように書けます。

def greet():print("こんにちは")

引数があり、戻り値がない関数もあります。

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

引数がなく、戻り値がある関数も作れます。

def get_default_tax_rate():return 0.1

必要なデータを外から受け取る場合は引数を使い、処理結果を外で利用する場合は戻り値を使います。

10-4. 同じ関数を何回でも呼び出せる？

定義した関数は、基本的に何回でも呼び出せます。

def greet(name):print(f"こんにちは、{name}さん")
greet("田中")greet("佐藤")greet("鈴木")

呼び出すたびに、関数内の処理が最初から実行されます。

ただし、ファイルの削除やデータの登録など、外部の状態を変更する関数は、何度も呼び出すと結果が変わる可能性があります。関数が何を変更するのかを確認したうえで使用しましょう。

10-5. 関数の中から別の関数を呼び出せる？

関数の中から別の関数を呼び出すことは可能です。

def calculate_subtotal(unit_price, quantity):return unit_price * quantity
def add_tax(price, tax_rate=0.1):return price * (1 + tax_rate)
def calculate_final_price(unit_price, quantity):subtotal = calculate_subtotal(unit_price, quantity)final_price = add_tax(subtotal)return final_price
result = calculate_final_price(1000, 3)print(result)

処理を小さな関数に分け、それらを組み合わせることで、複雑な処理を整理できます。

関数が自分自身を呼び出す「再帰」という方法もありますが、初心者はまず複数の関数を組み合わせる方法から学ぶとよいでしょう。

10-6. 関数とクラスは何が違う？

関数は、特定の処理をひとまとまりにしたものです。

def calculate_area(width, height):return width * height

クラスは、関連するデータと処理をまとめ、オブジェクトを作るための設計図です。

class Rectangle:def init(self, width, height):self.width = widthself.height = height
def calculate_area(self):return self.width * self.height</span></code></pre><p><span>関数は主に処理を整理するために使い、クラスは状態を持つデータと、それを操作する処理をまとめるために使います。</span></p><p><span>学習の順番としては、まず関数、引数、戻り値、スコープを理解してから、クラスへ進むと理解しやすいでしょう。</span></p><h3><span>10-7. 関数を効率よく学ぶにはどうすればよい？</span></h3><p><span>関数を効率よく学ぶには、コードを読むだけでなく、自分で書いて実行することが重要です。</span></p><p><span>まず、次のような小さな課題に取り組みましょう。</span></p><ul data-spread="false"><li><p><span>2つの数値の合計を返す</span></p></li><li><p><span>名前を受け取ってあいさつを表示する</span></p></li><li><p><span>数値が偶数かどうかを判定する</span></p></li><li><p><span>点数から成績を返す</span></p></li><li><p><span>リスト内の数値の合計を計算する</span></p></li></ul><p><span>コードを書いたら、引数を変えて結果がどう変化するか確認します。意図的に引数の数を間違えたり、</span><code dir="ltr"><span>return</span></code><span>を削除したりして、どのようなエラーや動作になるか試すのも有効です。</span></p><p><span>また、既存の長いコードから重複した処理を見つけ、関数に分ける練習も役立ちます。関数を使う前後のコードを比較すると、関数化のメリットを実感しやすくなります。</span></p><h2><span>まとめ</span></h2><p><span>プログラミングの関数とは、複数の処理をひとまとまりにし、必要な場所から呼び出せるようにした仕組みです。関数を利用すると、同じコードの重複を減らし、プログラムを読みやすく整理できます。</span></p><p><span>関数へ渡すデータを引数、関数から返される処理結果を戻り値といいます。Pythonでは</span><code dir="ltr"><span>def</span></code><span>で関数を定義し、</span><code dir="ltr"><span>return</span></code><span>で戻り値を返します。関数を定義しただけでは実行されないため、関数名と丸括弧を記述して呼び出す必要があります。</span></p><p><span>関数を作るときは、1つの関数に1つの役割を持たせ、処理内容が伝わる名前を付けましょう。また、外部の変数に過度に依存せず、必要なデータは引数として受け取り、処理結果は戻り値として返す設計を意識することが大切です。</span></p><p><span>Python、JavaScript、Java、C言語では関数の書き方が異なりますが、入力を受け取り、処理を実行し、必要に応じて結果を返すという基本的な考え方は共通しています。まずは簡単な計算や文字列表示を関数にまとめるところから始め、条件分岐や繰り返し処理を含む関数へ少しずつ発展させていきましょう。</span></p></div></div>