[Python] 인프런 - 프로그래밍 시작하기 - 파이썬 입문 - Se06. 파이썬 함수 및 입력

목록

1. 개요
2. 본론
     2-1. 함수 기초
     2-2. 다중 반환값과 가변 인수 (*args, **kwargs)
     2-3. 중첩 함수와 람다 (Lambda)
     2-4. 사용자 입력 (input)과 타입 변환
     2-5. input 예외처리
3. 요약

1. 개요

해당 포스팅은 인프런 - 프로그래밍 시작하기 : 파이썬 입문 (Inflearn Original)을 학습하고 정리한 포스팅이다.

이번 챕터에서는 파이썬 함수 및 입력에 대해 정리한다.
함수의 개념과 정의 방법, 다양한 반환 방식과 가변 인수(*args, **kwargs), 람다(Lambda) 함수, 그리고 input() 함수를 활용한 사용자 입력 처리와 예외처리까지 파이썬 함수의 전반적인 개념을 학습한다.

2. 본론

2-1. 함수 기초

함수(function)란 이름을 붙여 정의한 뒤, 필요할 때마다 호출해서 재사용할 수 있는 코드의 집합이다. 반복되는 로직을 한 번만 구현하고 여러 곳에서 호출할 수 있으므로 코드의 재사용성과 유지보수성이 높아진다.

함수 정의 기본 형식

def function_name(parameter):
    code

파이썬 함수는 매개변수 유무와 반환값 유무에 따라 네 가지 형태로 나눌 수 있다.

형태	매개변수	반환값
형태 1	없음	없음
형태 2	있음	없음
형태 3	있음	없음 (print만)
형태 4	있음	있음 (return)

# 형태 1: 매개변수 없음, 반환값 없음
def function1():
    print('예제1 호출')

# 형태 2: 매개변수 있음, 반환값 없음
def function2(a, b):
    print('예제2 호출', a, b)

# 형태 3: 매개변수 있음, print만 (반환값 없음)
def function3(x, y):
    print('예제3 호출', x, y)

# 형태 4: 매개변수 있음, return으로 반환값 있음
def function4(x, y):
    return x * y

# 실행
function1()           # 예제1 호출
function2(10, 20)     # 예제2 호출 10 20
function3(100, 200)   # 예제3 호출 100 200

r = function4(50, 50)
print('예제4 호출', r)  # 예제4 호출 2500

return이 없는 함수는 암묵적으로 None을 반환한다. 반환값을 활용하려면 반드시 return을 명시해야 한다.

2-2. 다중 반환값과 가변 인수 (args, *kwargs)

다중 반환값

파이썬 함수는 여러 값을 동시에 반환할 수 있다. 쉼표로 구분하면 자동으로 튜플로 묶여 반환된다.

# 다중 반환 (자동으로 튜플)
def func_mul(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return y1, y2, y3

x, y, z = func_mul(10)   # 언패킹으로 각 변수에 할당
print(x, y, z)           # 100 200 300

# 명시적 튜플 반환
def func_mul2(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return (y1, y2, y3)

q = func_mul2(20)
print(type(q), q)   # <class 'tuple'> (200, 400, 600)

딕셔너리를 반환하면 키를 통해 각 값에 접근할 수 있어 더 명확한 인터페이스를 제공한다.

def func_mul3(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return {'v1': y1, 'v2': y2, 'v3': y3}

d = func_mul3(30)
print(type(d), d)           # <class 'dict'> {'v1': 300, 'v2': 600, 'v3': 900}
print(d.get('v2'))          # 600
print(d.items(), d.keys())  # 아이템, 키 목록 확인

*args (가변 위치 인수)

*args는 개수가 정해지지 않은 위치 인수를 튜플로 받는다. 매개변수 이름은 관례적으로 args를 사용하지만 자유롭게 지을 수 있다.

def args_func(*args):
    for i, v in enumerate(args):
        print('Result : {}'.format(i), v)
    print('-----')

args_func('Lee')                    # Result : 0 Lee
args_func('Lee', 'Park')            # Result : 0 Lee / Result : 1 Park
args_func('Lee', 'Park', 'Kim')     # Result : 0 Lee / 1 Park / 2 Kim

**kwargs (가변 키워드 인수)

**kwargs는 키=값 형태로 전달된 인수를 딕셔너리로 받는다.

def kwargs_func(**kwargs):
    for v in kwargs.keys():
        print("{}".format(v), kwargs[v])
    print('-----')

kwargs_func(name1='Lee')
kwargs_func(name1='Lee', name2='Park')
kwargs_func(name1='Lee', name2='Park', name='Cho')

전체 혼합

일반 인수, *args, **kwargs를 함께 사용할 때는 반드시 이 순서를 지켜야 한다.

def example(args_1, args_2, *args, **kwargs):
    print(args_1, args_2, args, kwargs)

example(10, 20, 'Lee', 'Kim', 'Park', age1=20, age2=30, age3=40)
# 10 20 ('Lee', 'Kim', 'Park') {'age1': 20, 'age2': 30, 'age3': 40}

인수 종류	받는 형태	설명
일반 인수	값	순서대로 매핑
*args	튜플	추가 위치 인수를 튜플로 수집
**kwargs	딕셔너리	키워드 인수를 딕셔너리로 수집

2-3. 중첩 함수와 람다 (Lambda)

중첩 함수 (Nested Function)

함수 안에 또 다른 함수를 정의할 수 있다. 내부 함수는 외부에서 직접 호출할 수 없고, 해당 함수가 정의된 스코프(scope) 안에서만 유효하다.

def nested_func(num):
    def func_in_func(num):  # 내부 함수 정의
        print(num)
    print("In Func")
    func_in_func(num + 100) # 내부 함수 호출

nested_func(100)   # "In Func" 출력 후 200 출력

# func_in_func(1000)  # 오류! 외부에서는 호출 불가

람다 함수 (Lambda)

람다는 def 없이 한 줄로 정의하는 익명(이름 없는) 함수다. 함수 객체를 생성하는 def와 달리 람다는 즉시 실행 후 Heap 메모리를 초기화하므로 메모리 효율이 높다.

# 형식
lambda 매개변수: 표현식

# 일반 함수로 정의
def mul_func(x, y):
    return x * y

print(mul_func(10, 50))      # 500

# 함수를 변수에 할당
mul_func_var = mul_func
print(mul_func_var(20, 50))  # 1000

# 람다 함수로 동일 기능 구현
lambda_mul_func = lambda x, y: x * y
print(lambda_mul_func(50, 50))  # 2500

람다는 함수를 인수로 전달하는 고차 함수(higher-order function)와 함께 자주 사용된다.

def func_final(x, y, func):
    print('>>>>', x * y * func(100, 100))

func_final(10, 20, mul_func_var)  # >>>> 200000000

람다를 남발하면 오히려 가독성이 떨어질 수 있다. 간단한 단일 표현식에만 사용하고, 복잡한 로직은 def로 정의하는 것이 좋다.

2-4. 사용자 입력 (input)과 타입 변환

input() 함수는 사용자가 키보드로 입력한 값을 읽어온다. 반환 타입은 항상 문자열(str)이다.

기본 사용법

name = input("Enter Your Name : ")
grade = input("Enter Your Grade : ")
company = input("Enter Your Company name : ")

print(name, grade, company)

number = input("Enter number : ")
name = input("Enter name : ")

print("type of number", type(number))  # type of number <class 'str'>
print("type of name", type(name))      # type of name <class 'str'>

입력값은 항상 문자열이므로, 수치 계산이 필요하면 명시적 타입 변환이 필요하다.

타입 변환

변환 함수	설명	예시
int(input(...))	정수로 변환	int("10") → 10
float(input(...))	실수로 변환	float("3.14") → 3.14

# 정수 변환 후 덧셈 계산
first_number = int(input("Enter number1 : "))
second_number = int(input("Enter number2 : "))

total = first_number + second_number
print("first_number + second_number : ", total)  # 숫자 합산 결과 출력

# 실수 변환
float_number = float(input("Enter a float number : "))
print("input float : ", float_number)
print("input type : ", type(float_number))  # <class 'float'>

format과 함께 활용

input()을 format() 내부에 인수로 바로 전달할 수 있다.

print("FirstName - {0}, LastName - {1}".format(
    input("Enter first name : "),
    input("Enter second name : ")
))

2-5. input 예외처리

input()으로 정수를 받을 때 사용자가 문자열을 입력하면 int() 변환 시 ValueError가 발생한다. 이를 try/except로 처리할 수 있다.

기본 예외처리

try:
    n = int(input('Enter a number : '))
    print('OK. Your number is : ', n)
except ValueError:
    print('This is not a number.')  # 숫자가 아닌 입력 시 실행

while True + 예외처리 패턴

올바른 값을 입력할 때까지 반복해서 요청하는 패턴이다. 입력이 성공하면 break로 루프를 탈출한다.

while True:
    try:
        n = int(input('Enter a number : '))
        break                          # 정수 변환 성공 시 루프 탈출
    except ValueError:
        print('This is not a number.') # 실패 시 다시 요청

print('OK. Your number is : ', n)

이 패턴(while True + try/except + break)은 사용자 입력 유효성 검사에서 가장 자주 사용되는 관용 표현이다.

3. 요약

개념	핵심 키워드	설명
함수 정의	def	이름을 붙여 재사용 가능한 코드 블록 정의
반환값	return	결과값을 호출부로 돌려줌, 없으면 None
다중 반환	, 또는 (tuple)	여러 값을 튜플/딕셔너리로 반환
가변 위치 인수	*args	추가 위치 인수를 튜플로 수집
가변 키워드 인수	**kwargs	키=값 인수를 딕셔너리로 수집
중첩 함수	함수 내 def	내부 함수는 외부에서 호출 불가
람다	lambda x: 표현식	단일 표현식의 익명 함수, 메모리 효율적
사용자 입력	input()	반환 타입은 항상 str
타입 변환	int(), float()	input 결과를 수치 타입으로 변환
예외처리	try/except ValueError	잘못된 타입 변환 시 오류 처리

• 함수 인수 순서: 일반 인수 → *args → **kwargs
• input() 반환값은 항상 문자열(str) — 수치 계산 전 반드시 타입 변환 필요
• while True + try/except + break : 유효한 입력값을 받을 때까지 재요청하는 관용 패턴
• 람다 남발 주의 — 단순한 단일 표현식에만 사용, 복잡한 로직은 def 사용