파이썬 기초 - 함수 기초

함수 기초

함수란?

함수는 특정 작업을 수행하는 코드 블록으로, 코드를 재사용하고 프로그램을 구조화하는 데 도움이 된다.

함수 정의하기

def 함수이름(매개변수1, 매개변수2, ...):
    """함수 설명 (독스트링)"""
    # 함수 본문
    # 코드 블록
    return 결과값  # 선택적

함수 호출하기

# 함수 정의
def greet(name):
    """인사말을 출력하는 함수"""
    return f"안녕하세요, {name}님!"

# 함수 호출
message = greet("철수")
print(message)  # 출력: 안녕하세요, 철수님!

독스트링 (Docstring)

함수의 목적과 사용법을 설명하는 문서 문자열이다. 주로 세 개의 따옴표(""")로 감싸서 작성한다.

def calculate_area(radius):
    """
    원의 넓이를 계산하는 함수
    
    매개변수:
    radius (float): 원의 반지름
    
    반환값:
    float: 원의 넓이
    """
    return 3.14 * radius * radius

함수의 매개변수

Positional Parameters

함수 호출 시 순서대로 전달되는 매개변수다.

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

result = add(3, 5)  # a=3, b=5

Keyword Parameters

매개변수 이름을 명시적으로 지정해서 전달하는 매개변수다.

def greet(first_name, last_name):
    return f"안녕하세요, {last_name}{first_name}님!"

# 키워드 매개변수 사용
message = greet(last_name="김", first_name="철수")
print(message)  # 출력: 안녕하세요, 김철수님!

Default Parameters

매개변수에 기본값을 지정하면 함수 호출 시 해당 매개변수를 생략할 수 있다.

def greet(name, greeting="안녕하세요"):
    return f"{greeting}, {name}님!"

print(greet("철수"))  # 출력: 안녕하세요, 철수님!
print(greet("영희", "반갑습니다"))  # 출력: 반갑습니다, 영희님!

가변 위치 매개변수 (*args)

임의 개수의 위치 매개변수를 튜플로 받는다.

def sum_all(*numbers):
    """여러 숫자의 합을 계산한다"""
    result = 0
    for num in numbers:
        result += num
    return result

print(sum_all(1, 2, 3, 4, 5))  # 출력: 15
print(sum_all(10, 20))  # 출력: 30

가변 키워드 매개변수 (**kwargs)

임의 개수의 키워드 매개변수를 딕셔너리로 받는다.

def print_info(**info):
    """인물 정보를 출력한다"""
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="김철수", age=25, job="개발자")
# 출력:
# name: 김철수
# age: 25
# job: 개발자

매개변수 조합 사용하기

def complex_function(pos1, pos2, *args, default1="기본값", **kwargs):
    print(f"위치 매개변수: {pos1}, {pos2}")
    print(f"추가 위치 매개변수: {args}")
    print(f"기본값 매개변수: {default1}")
    print(f"키워드 매개변수: {kwargs}")

complex_function(1, 2, 3, 4, 5, default1="새값", key1="값1", key2="값2")
# 출력:
# 위치 매개변수: 1, 2
# 추가 위치 매개변수: (3, 4, 5)
# 기본값 매개변수: 새값
# 키워드 매개변수: {'key1': '값1', 'key2': '값2'}

함수의 반환값

단일 값 반환

def square(n):
    return n * n

result = square(4)  # 결과: 16

여러 값 반환 (튜플로 자동 패킹됨)

def get_min_max(numbers):
    return min(numbers), max(numbers)

min_val, max_val = get_min_max([1, 2, 3, 4, 5])
print(min_val, max_val)  # 출력: 1 5

조건부 반환

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

grade = get_grade(85)  # 결과: "B"

반환값 없음 (None)

def print_greeting(name):
    print(f"안녕하세요, {name}님!")
    # return 문이 없으면 자동으로 None 반환

result = print_greeting("철수")  # 화면에 "안녕하세요, 철수님!" 출력
print(result)  # 출력: None

변수의 범위 (Scope)

지역 변수 (Local Variables)

함수 내부에서 정의된 변수로, 해당 함수 내에서만 접근 가능하다.

def my_function():
    local_var = "지역 변수"
    print(local_var)  # 접근 가능

my_function()
# print(local_var)  # 오류 발생: local_var는 함수 밖에서 접근 불가

전역 변수 (Global Variables)

함수 외부에서 정의된 변수로, 모든 코드에서 접근 가능하다.

global_var = "전역 변수"

def my_function():
    print(global_var)  # 전역 변수에 접근 가능

my_function()  # 출력: 전역 변수

global 키워드

함수 내에서 전역 변수를 수정하려면 global 키워드를 사용해야 한다.

counter = 0

def increment():
    global counter  # 전역 변수 counter를 사용하겠다고 선언
    counter += 1
    print(f"카운터: {counter}")

increment()  # 출력: 카운터: 1
increment()  # 출력: 카운터: 2

nonlocal 키워드

중첩 함수에서 외부 함수의 변수를 수정하려면 nonlocal 키워드를 사용한다.

def outer_function():
    outer_var = "외부 함수 변수"
    
    def inner_function():
        nonlocal outer_var  # 외부 함수의 변수 사용 선언
        outer_var = "수정된 외부 함수 변수"
        print(f"내부 함수: {outer_var}")
    
    print(f"수정 전: {outer_var}")
    inner_function()
    print(f"수정 후: {outer_var}")

outer_function()
# 출력:
# 수정 전: 외부 함수 변수
# 내부 함수: 수정된 외부 함수 변수
# 수정 후: 수정된 외부 함수 변수

변수 범위의 우선순위

변수 이름이 중복될 경우, 지역 변수가 전역 변수보다 우선한다.

x = 10  # 전역 변수

def print_x():
    x = 20  # 지역 변수
    print(f"함수 내부 x: {x}")

print_x()  # 출력: 함수 내부 x: 20
print(f"함수 외부 x: {x}")  # 출력: 함수 외부 x: 10

람다 함수 (Lambda)

람다 함수란?

람다 함수는 이름 없이 간단하게 정의할 수 있는 한 줄짜리 함수다. 주로 함수를 인자로 받는 다른 함수에 전달할 때 사용한다.

기본 문법

lambda 매개변수: 표현식

람다 함수 사용 예시

# 일반 함수
def square(x):
    return x * x

# 동일한 기능의 람다 함수
square_lambda = lambda x: x * x

print(square(5))       # 출력: 25
print(square_lambda(5))  # 출력: 25

여러 매개변수 사용

add = lambda x, y: x + y
print(add(3, 5))  # 출력: 8

조건부 표현식 사용

is_even = lambda x: "짝수" if x % 2 == 0 else "홀수"
print(is_even(4))  # 출력: 짝수
print(is_even(5))  # 출력: 홀수

정렬에 람다 함수 활용

students = [
    {"name": "김철수", "score": 85},
    {"name": "이영희", "score": 92},
    {"name": "박민수", "score": 78}
]

# 점수 기준으로 정렬
sorted_by_score = sorted(students, key=lambda student: student["score"])
print(sorted_by_score)
# 출력: [{'name': '박민수', 'score': 78}, {'name': '김철수', 'score': 85}, {'name': '이영희', 'score': 92}]

# 이름 기준으로 정렬
sorted_by_name = sorted(students, key=lambda student: student["name"])
print(sorted_by_name)
# 출력: [{'name': '김철수', 'score': 85}, {'name': '박민수', 'score': 78}, {'name': '이영희', 'score': 92}]

함수형 프로그래밍에 활용

numbers = [1, 2, 3, 4, 5]

# map: 모든 요소에 함수 적용
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # 출력: [1, 4, 9, 16, 25]

# filter: 조건에 맞는 요소만 선택
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 출력: [2, 4]

# reduce: 요소들을 하나로 합침
from functools import reduce
sum_all = reduce(lambda x, y: x + y, numbers)
print(sum_all)  # 출력: 15

유용한 내장 함수

자주 사용하는 내장 함수

1. print()

콘솔에 텍스트나 변수 값을 출력한다.

print("Hello, World!")
print("값:", 42, "입니다", sep="-")  # 출력: 값-42-입니다

2. len()

시퀀스(문자열, 리스트, 튜플 등)의 길이를 반환한다.

print(len("Python"))  # 출력: 6
print(len([1, 2, 3, 4]))  # 출력: 4

3. type()

객체의 데이터 타입을 반환한다.

print(type(42))  # 출력: <class 'int'>
print(type("Hello"))  # 출력: <class 'str'>
print(type([1, 2, 3]))  # 출력: <class 'list'>

4. input()

사용자로부터 입력을 받는다.

name = input("이름을 입력하세요: ")
print(f"안녕하세요, {name}님!")

5. range()

연속된 숫자 시퀀스를 생성한다.

for i in range(5):  # 0부터 4까지
    print(i, end=" ")  # 출력: 0 1 2 3 4

6. sum()

이터러블(리스트, 튜플 등)의 모든 요소의 합을 계산한다.

print(sum([1, 2, 3, 4, 5]))  # 출력: 15

7. max(), min()

이터러블의 최대/최소 값을 찾는다.

numbers = [5, 2, 8, 1, 9]
print(max(numbers))  # 출력: 9
print(min(numbers))  # 출력: 1

8. sorted()

이터러블을 정렬한 새 리스트를 반환한다.

print(sorted([5, 2, 8, 1, 9]))  # 출력: [1, 2, 5, 8, 9]
print(sorted([5, 2, 8, 1, 9], reverse=True))  # 출력: [9, 8, 5, 2, 1]

9. round()

숫자를 반올림한다.

print(round(3.14159, 2))  # 출력: 3.14

10. enumerate()

이터러블의 각 요소와 인덱스를 튜플로 반환한다.

for idx, value in enumerate(["a", "b", "c"]):
    print(f"인덱스 {idx}: {value}")
# 출력:
# 인덱스 0: a
# 인덱스 1: b
# 인덱스 2: c

11. zip()

여러 이터러블의 요소를 짝지어 튜플로 반환한다.

names = ["Kim", "Lee", "Park"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}점")
# 출력:
# Kim: 85점
# Lee: 92점
# Park: 78점

12. map()

이터러블의 모든 요소에 함수를 적용한 결과를 반환한다.

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # 출력: [1, 4, 9, 16, 25]

13. filter()

이터러블에서 함수가 True를 반환하는 요소만 선택한다.

numbers = [1, 2, 3, 4, 5, 6]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # 출력: [2, 4, 6]

14. all(), any()

이터러블의 모든/어떤 요소가 True인지 확인한다.

print(all([True, True, False]))  # 출력: False (모든 요소가 True여야 True 반환)
print(any([True, False, False]))  # 출력: True (하나라도 True면 True 반환)