[Python] 함수 / 중첩함수 / lambda함수 / 실행(main) 파일

 

이 글은 24.01.08에 본인 벨로그에 작성했던 글을 옮겨 온 것이다.

 

함수 내에서 또 다른 함수 호출

말 그대로, 하나의 함수 안에서 또 다른 함수를 호출하는 것을 말한다.
간단한 예시로, 구구단 2단부터 9단까지를 연속으로 출력하는 프로그램을 작성해보자.

# input

def gugu2():
    for i in range(1,10):
        print(f'2*{i} = {2*i}')
    print('='*30)
    gugu3()

def gugu3():
    for i in range(1,10):
        print(f'3*{i} = {3*i}')
    print('=' * 30)
    gugu4()

def gugu4():
    for i in range(1,10):
        print(f'4*{i} = {4*i}')
    print('=' * 30)
    gugu5()

def gugu5():
    for i in range(1, 10):
        print(f'5*{i} = {5 * i}')
    print('=' * 30)
    gugu6()

def gugu6():
    for i in range(1, 10):
        print(f'6*{i} = {6 * i}')
    print('=' * 30)
    gugu7()

def gugu7():
    for i in range(1, 10):
        print(f'7*{i} = {7 * i}')
    print('=' * 30)
    gugu8()

def gugu8():
    for i in range(1, 10):
        print(f'8*{i} = {8 * i}')
    print('=' * 30)
    gugu9()

def gugu9():
    for i in range(1, 10):
        print(f'9*{i} = {9 * i}')

gugu2()
=======================================
# output

2*1 = 2
2*2 = 4
2*3 = 6
2*4 = 8
2*5 = 10
2*6 = 12
2*7 = 14
2*8 = 16
2*9 = 18
==============================
3*1 = 3
3*2 = 6
3*3 = 9
3*4 = 12
3*5 = 15
3*6 = 18
3*7 = 21
3*8 = 24
3*9 = 27
.
.
.
9*1 = 9
9*2 = 18
9*3 = 27
9*4 = 36
9*5 = 45
9*6 = 54
9*7 = 63
9*8 = 72
9*9 = 81

 

데이터 반환

• 함수는 return을 만나면 실행을 종료한다
  => 즉, 함수 내에서 return 아래의 구문은 실행되지 않는다.

# input(1)

def fun1(x,y):
    print('x+y는?')
    return x+y		# 함수 종료

print(fun1(1,2))
----------------------
# output(1)

x+y는?
3

=======================
# input(2)

def fun2(x,y):
    return x+y			# 함수 종료.
    print('x+y는?')		# 즉, 이 print문은 실행되지 않는다.

print(fun2(1,2))
-----------------------
# output(2)

3

 

중첩함수

• 함수 내에 또 다른 함수가 선언된 것.

사용자로부터 수 2개와 수행할 사칙연산을 입력받으면 해당 연산을 수행하는 프로그램을 만들어 보자.

# input

def calculator(n1, n2, operator):
    if operator == 1:
        def add():
            print(f'{n1}+{n2} = {n1+n2}')
        add()
    elif operator == 2:
        def sub():
            print(f'{n1}-{n2} = {n1-n2}')
        sub()
    elif operator == 3:
        def mul():
            print(f'{n1}*{n2} = {n1*n2}')
        mul()
    elif operator == 4:
        def div():
            print(f'{n1}/{n2} = {n1/n2}')
        div()

while True:
    n1 = float(input('n1 : '))
    n2 = float(input('n2 : '))
    
    operator = int(input('1:덧셈\t2:뺄셈\t3:곱셈\t4:나눗셈\t5:종료  =>  '))
    
    if operator == 5:
        print('종료합니다')
        break
    calculator(n1, n2, operator)
    print('-'*30)
=========================================================================
# output

n1 : 1
n2 : 2
1:덧셈	2:뺄셈	3:곱셈	4:나눗셈	5:종료  =>  3
1.0*2.0 = 2.0
------------------------------
n1 : 3
n2 : 4
1:덧셈	2:뺄셈	3:곱셈	4:나눗셈	5:종료  =>  5
종료합니다

 

lambda 함수

• 함수 선언 없이 사용할 수 있는 함수.
  lambda 변수부 : 함수부

# input

t_area = lambda n1,n2:(n1*n2)/2		# t_area : (n1*n2)/2를 수행하는 함수.
s_area = lambda n1,n2:n1*n2			# s_area : n1*n2를 수행하는 함수
c_area = lambda r:(r**2)*3.14		# c_area : (r**2)*3.14를 수행하는 함수.

width = int(input('가로 : '))
height = int(input('세로 : '))
rad = int(input('반지름 : '))

area_t = t_area(width, height)		
	# t_area라는 lambda함수에 n1(width), n2(height) 입력 후, 결과값을 area_t에 할당
area_s = s_area(width, height)		
	# s_area라는 lambda함수에 n1(width), n2(height) 입력 후, 결과값을 area_s에 할당
area_c = c_area(rad)				
	# c_area라는 lambda함수에 r(rad) 입력 후, 결과값을 area_c에 할당

print(f'삼각형 넓이 : {area_t}')
print(f'사각형 넓이 : {area_s}')
print(f'원 넓이 : {area_c}')
==============================
# output

가로 : 20
세로 : 30
반지름 : 6
삼각형 넓이 : 300.0
사각형 넓이 : 600
원 넓이 : 113.04

 

실행(메인) 파일

• __name__ 전역변수에는 모듈 이름 혹은 __main__이 저장된다(실행파일인 경우).

add_module.py  =>  __name__ : 'add_module'이 저장됨. 
sub_module.py  =>  __name__ : 'sub_module'이 저장됨. 
mul_module.py  =>  __name__ : 'mul_module'이 저장됨. 
div_module.py  =>  __name__ : 'div_module'이 저장됨.
module.py  =>  __name__ : '__main__'이 저장됨. 


# 예시(1)
# 아래와 같은 코드가 작성된 calculator.py파일이 있다.

def add(n1,n2):
    return n1+n2

print(f'__name__ = {__name__}')
--------------------------------------------------
# 실행해보면 아래와 같은 결과가 출력된다.

__name__ = __main__		# calculator.py는 실행파일이기 때문.
==========================================================
# 예시(2)
# 아래와 같이 calculator.py 파일을 import해서 사용하는 test.py 파일이 있다고 하자.

import calculator

print(f'1. {calculator.add(4,5)}')
print(f'2. __name__ : {__name__}')
-----------------------------------------------------------
# 실행해보면 아래와 같은 결과가 출력된다.

__name__ = calculator
1. 9
2. __name__ : __main__

# 1, 2번은 test.py 파일의 코드가 실행된 결과인데 그 위의 __name__ = calculator는 무엇인가?
  => calculator.py 파일의 print문이 실행된 결과이다.
  => 해당 print문이 calculator.py 파일이 아닌 다른 파일에서 실행되었기에 모듈의 이름이 출력된 것. 

 

• 그럼, 이 기능은 어따 써먹는가?
  => 어떤 모듈에 있는 코드가, 해당 모듈을 직접 실행할 때에만 실행되게끔 하고 싶을 때에 조건으로 __name__ == '__main__'을 걸어준다.
  => 왜 이렇게 하고 싶은데?
  => 해당 모듈이 제대로 작동하는지 테스트를 해 보고 싶을 때, 해당 모듈을 바로 실행해보면 알 수 있으니까!

예시(1)

# 아래와 같은 코드가 작성된 length.py파일이 있다고 하자.

def cm_to_mm(n):
    return round(n*10, 3)

def cm_to_inch(n):
    return round(n*0.393, 3)

def cm_to_m(n):
    return round(n*0.01, 3)

def cm_to_ft(n):
    return round(n*0.032, 3)

if __name__ == '__main__':
    print(f'10cm : {cm_to_mm(10)}mm')
    print(f'10cm : {cm_to_inch(10)}inch')
    print(f'10cm : {cm_to_m(10)}m')
    print(f'10cm : {cm_to_ft(10)}ft')
--------------------------------------------------
# 위 파일을 실행하면, 아래와 같은 결과가 출력된다. 제대로 작동함을 알 수 있다.
# 조건으로 __name__ == '__main__'을 걸어 주었기 때문에
# 해당 파일(length.py)를 직접 실행하는 게 아니라
# 외부 파일에서 import해서 사용할 때에는 조건절의 코드는 실행되지 않는다.

10cm : 100mm
10cm : 3.93inch
10cm : 0.1m
10cm : 0.32ft

===================================================
 예시(2)

# 아래와 같은 코드가 작성된 test.py파일이 있다.

import length

leng = int(input('길이 입력 : '))

print(f'{leng}cm : {length.cm_to_mm(leng)}mm')
print(f'{leng}cm : {length.cm_to_inch(leng)}inch')
print(f'{leng}cm : {length.cm_to_m(leng)}m')
print(f'{leng}cm : {length.cm_to_ft(leng)}ft')
---------------------------------------------------
# 위 파일을 실행하면, 아래와 같은 결과가 출력된다.

길이 입력 : 4
4cm : 40mm
4cm : 1.572inch
4cm : 0.04m
4cm : 0.128ft

**
test.py 파일 또한 타 파일의 모듈로써 사용되는 경우에 대비해 이 파일의 코드에도
__name__ == '__main__' 조건을 걸어주는 것이 좋다.
**