혼공파 4주차

🔎 함수 만들기

함수 호출

• 함수를 사용하는 것
  
  

함수의 기본

• 함수는 한마디로 코드의 집합

  def 함수 이름():
  . . . . 문장

아래는 '코드의 집합'이라는 목적으로 활용한 코드이며 세 문장을 포함하는 print_3_times 함수를 만든 후 호출하여 실행하는 간단한 예제임

# 기본적인 함수.py

def print_3_times():
    print("안녕하세요")
    print("안녕하세요")
    print("안녕하세요")

print_3_times()

# 실행 결과
----------
안녕하세요
안녕하세요
안녕하세요

---

🔎 함수에 매개변수 만들기

예를 들어 print() 함수를 작성할 때 print(value, .... sep='', end=\n', file=sys.stdout, flush=False)와 같이 괄호 안에 많은 것들이 있으며 이러한 것들을 모두 매개변수라 부름

매개변수(prameter)

• 함수를 호출할 때 필요한 데이터를 외부로부터 받기 위해 사용하는 것
  
  

식별자

• 함수를 생성할 때 괄호 내부에 들어가는 것

  def 함수 이름(매개변수, 매개변수,...):
  문장

아래는 매개변수와 관련된 간단한 예제

# value, n식별자 입력 매개변수가 됨 
# 매개변수는 함수 호출 시 값 입력해 함수쪽으로 전달 가능
def print_n_times(value, n):   
    for i in range(n):
        print(value)

# 함수호출
# value: 안녕하세요, n: 5입력 ---> 안녕하세요 5번 출력
print_n_times("안녕하세요", 5)

# 실행 결과
----------
안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요

매개변수와 관련된 TypeError

def print_n_times(value, n):   # 매개변수 2개 지정   
    for i in range(n):
        print(value)

print_n_times("안녕하세요")     # 안녕하세요 1개만 입력

# 실행 결과
----------
TypeError: print_n_times() missing 1 required positional argument: 'n'

위의 코드는 매개변수가 적을 경우에 발생함
아래의 코드는 매개변수가 많을 경우에 발생함

def print_n_times(value, n):    
    for i in range(n):
        print(value)

print_n_times("안녕하세요", 10, 20)

# 실행 결과
----------
TypeError: print_n_times() takes 2 positional arguments but 3 were given

따라서 함수를 호출할 때는 함수를 선언할 때와 같은 개수의 매개변수를 입력해야 한다.

가변 매개변수

• 매개변수를 원하는 만큼 받을 수 있는 함수

  def 함수 이름(매개변수, 매개변수, ..., *가변 매개변수):
  . . . . 문장

• 가변매개변수는 2개의 제약이 존재함
  1. 가변매개변수 뒤에는 일반 매개변수가 올 수 없음
  2. 가변 매개변수는 하나만 사용할 수 있음

# 가변 매개변수 함수

def print_n_times(n, *values):
    # n번 반복    
    for i in range(n):
        # values는 리스트처럼 활용함
        for value in values:
            print(value)
        # 단순한 줄바꿈
        print()

# 함수 호출
print_n_times(3, "안녕하세요", "즐거운", "파이썬 프로그래밍")

# 실행 결과
----------
안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

• print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍", 3)으로 사용하면 어디까지가 가변매개변수이고, 어디까지가 매개변수 n인지 구분하기 힘듬
• 왜나하면 파이썬 프로그래밍 언어는 내부적으로 가변 매개변수 뒤에 일반 매개변수가 오지 못하게 막기 때문
• 그러므로 매개변수 n을 앞으로 옮기고 매개변수 values를 뒤로 민 것
  가변 매개변수values는 리스트처럼 사용하면 됨.
• 예제는 반복문을 2번 사용해서 쭉 출력하게 만든 거임
  
  

기본 매개변수

• 매개변수를 입력하지 않았을 경우 들어가는 기본값
• 기본 매개변수 뒤에는 일반 매개변수가 올 수 없음

def print_n_times(value, n=2):  # n을 입력하지 않으면 기본값을 2로 입력함
    # n번 반복    
    for i in range(n):
        print(value)

# 함수 호출
print_n_times("안녕하세요")

# 실행 결과
----------
안녕하세요
안녕하세요

기본 매개변수 뒤에 일반 매개변수가 올 수 없는 이유는, print_n_times(value, n=2)에서 print_n_times(n=2, value)로 사용할 경우 첫 번째 매개변수에 할당되어야 하는지, 두 번째 매개변수에 할당되어야 하는지 확실하게 알 수 없기 때문

---

🔎 키워드 매개변수(keyword parameter)

기본 매개변수가 가변 매개변수보다 앞에 올 때

• 아래의 코드는 기본 매개변수가 가변 매개변수보다 앞에 올 때의 코드이며, 기본 매개변수의 의미가 사라짐
• 매개변수가 순서대로 입력되므로 n에는 "안녕하세요"가 들어가고 values에는 ["즐거운", "파이썬 프로그래밍"]이 들어옴
• 그런데 range()함수의 매개변수에는 숫자만 들어올 수 있으므로 다음과 같은 오류가 발생함

def print_n_times(n=2, *values):
    # n번 반복    
    for i in range(n):
        #values는 리스트처럼 활용 가능
        for value in values:
            print(value)
        # 단순한 줄바꿈
        print()

# 함수 호출
print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍")

# 실행 결과
----------
TypeError: 'str' object cannot be interpreted as an integer

가변 매개변수가 기본 매개변수보다 앞에 올 때

• 아래의 코드는 가변 매개변수가 기본 매개변수보다 앞에 올 때임
• 출력 결과를 예상을 하면 아래와 같이 나올 수 있다고 생각을 할 수 있음
  1. ["안녕하세요", "즐거운", 파이썬 프로그래밍"]을 세 번 출력
  2. ["안녕하세요", "즐거운", 파이썬 프로그래밍", 3]을 두 번 출력
• 결과는 가변 매개변수가 우선되어 2번 결과값이 옴

def print_n_times(*values, n=2):
    # n번 반복    
    for i in range(n):
        #values는 리스트처럼 활용 가능
        for value in values:
            print(value)
        # 단순한 줄바꿈
        print()

# 함수 호출
print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍", 3)

# 실행 결과
----------
안녕하세요
즐거운
파이썬 프로그래밍
3

안녕하세요
즐거운
파이썬 프로그래밍
3

키워드 매개변수

매개변수와 가변 매개변수를 함께 쓰는 상황에서는 매개변수에 직접 변수명을 지정하여 값을 입력하여 사용함
즉, 매개변수 이름을 직접적으로 지정하여 값을 입력하는 매개변수

# while 반복문 사용
while True:
	# "."을 출력
    # 기본적으로 end가 "\n"이라 줄바꿈이 일어나는데
    # 빈 문자열 ""로 바꿔서 줄바꿈이 일어나지 않게 함
    print(".", end = "")  # 여기서 end="" 키워드 매개변수

이전 코드에서 ["안녕하세요", "즐거운", "파이썬 프로그래밍"]을 세 번 출력하도록 실행하려면 위와같이 매개변수 이름을 직접적으로 지정하여 값을 입력함

# 키워드 매개변수.py
def print_n_times(*values, n=2):
    # n번 반복함
    for i in range(n):
        # values는 리스트처럼 활용함
        for value in values:
            print(value)
        #단순한 줄바꿈
        print()

# 함수 호출
print_n_times("안녕하세요", "즐거운", "파이썬 프로그래밍", n=3)  # 여기서 n은 매개변수

# 실행 결과
----------
안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

안녕하세요
즐거운
파이썬 프로그래밍

이처럼 매개변수 이름을 지정해서 입력하는 매개변수를 키워드 매개변수라 함

기본 매개변수 중에서 필요한 값만 입력하기

키워드 매개변수는 기본 매개변수들로 구성된 함수에도 많이 사용됨

def test(a, b=10, c=100):
    print(a + b + c)

# 1) 기본 형태
test(10, 20, 30)

# 2) 키워드 매개변수로 모든 매개변수를 지정한 형태
test(a=10, b=100, c=200)

# 3) 키워드 매개변수로 모든 매개변수를 마구잡이로 지정한 형태
test(c=10, a=100, b=200)

# 4) 키워드 매개변수로 일부 매개변수만 지정한 형태
test(10, c=200)

# 실행 결과
----------
60
310
310
220

• 1번 형태: 첫 번째 매개변수 a는 일반 매개변수이므로 해당 위치에 반드시 입력해야 함
• 2번, 3번 형태: 일반 매개변수이지만 키워드 매개변수처럼 사용할 수 있음
• 3번 형태: 매개변수의 순서가 마구잡이로 쓰여 있는데, 키워드를 지정해서 매개변수를 입력하는 경우에는 이처럼 순서를 원하는대로 입력할 수 있음
• 4번 형태: b를 생략한 형태인데, 키워드 매개변수를 사용하면 필요한 매개변수에만 값을 전달할 수 있음
• 즉, 일반 매개변수는 필수로 입력하고 순서에 맞게 입력하면 됨
• 기본 매개변수는 필요한 것만 키워드를 지정해서 입력하는 경우가 많음
  
  

리턴(return)

• 함수를 실행했던 위치로 돌아가게 하는 것
• 리턴값을 가지는 함수는 반드시 리턴할 때 반환하는 값이 있어야 함
  
  

리턴값(return value)

• 함수의 실행 결과값
  
  

조기 리턴

• 함수 내의 필요한 위치에서 return 키워드를 사용하는 것
  
  

자료 없이 리턴하기

def return_test():
    print("A 위치입니다.")
    return                   # 리턴
    print("B 위치 입니다.")

# 함수 호출
return_test()

# 실행 결과
----------
A 위치입니다.

• 위의 코드는 함수 내부에서 출력을 두 번 했는데 중간에 return 키워드가 들어 있음
• return 키워드는 함수를 실행했던 위치로 돌아가는 의미와 함수를 여기서 끝내라는 의미를 가지고 있음
• 여기서 return 키워드를 만나는 순간 함수가 종료되어 결과적으로 "A 위치입니다."만 출력하고 프로그램 종료함
  
  

자료와 함께 리턴하기

• 리턴 뒤에 자료를 입력하면 자료를 가지고 리턴함(돌아감)
• 아래의 코드는 return 키워드 뒤에 100이라는 숫자를 입력한 코드임
• 함수의 실행결과로 100이 출력된느 것을 확인할 수 있음

# 함수 정의
def return_test():
    return 100

# 함수 호출
value = return_test()
print(value)

# 실행 결과
----------
100

아무것도 리턴하지 않기

• 아래의 코드는 None을 출력하는 코드임

# 함수 정의
def return_test():
    return

# 함수 호출
value = return_test()
print(value)

# 실행 결과
----------
None

기본적인 함수의 활용

• 함수는 아래와 같이 값을 만들어 리턴하는 형태로 많이 사용함

  def 함수(매개변수):
  . . . . 변수 = 초깃값
  . . . . # 여러 가지 처리
  . . . . # 여러 가지 처리
  . . . . # 여러 가지 처리
  . . . . return 변수

# 함수 선언
def sum_all(start, end):
    # 변수 선언
    output = 0
    # 반복문을 돌려 숫자를 더함
    for i in range(start, end + 1):
        output += i
    # 리턴
    return output

# 함수 호출
print("0 to 100:", sum_all(0, 100))
print("0 to 1000:", sum_all(0, 1000))
print("50 to 100:", sum_all(50, 100))
print("500 to 1000:", sum_all(500, 1000))

# 실행 결과
----------
0 to 100: 5050
0 to 1000: 500500
50 to 100: 3825
500 to 1000: 375750

• 일반적으로 초깃값을 설정할 때는 연산을 해도 값에 아무런 변화를 주지 않는 것을 사용함
• 덧셈식에서는 0임 어떤 값에 0을 더하면 아무런 변화가 없음. 그래서 output = 0으로 변수를 0으로 초기화한 뒤 사용함

# 기본 매개변수와 키워드 매개변수를 활용해 범위의 정수를 더하는 함수.py

# 함수 선언
def sum_all(start=0, end=100, step=1):
    # 변수 선언
    output = 0
    # 반복문을 돌려 숫자를 더함
    for i in range(start, end + 1, step):
        output += i
    # 리턴
    return output

# 함수 호출
print("A.", sum_all(0, 100, 10))
print("B.", sum_all(end=100))
print("C.", sum_all(end=100, step=2))

# 실행 결과
----------
A. 550
B. 5050
C. 2550

---

🔎 함수의 활용

팩토리얼(factorial)

n으로 표현
1부터 n까지의 숫자를 곱하는 연산

n! = n (n-1) (n-2) ... 1

반복문으로 팩토리얼 구하는 방법

# 반복문으로 팩토리얼 구하기.py
# 함수 선언
def factorial(n):

    # 변수 선언
    output = 1

    # 반복문 돌려 숫자 더하기
    for i in range(1, n + 1):
        output *= i

    # 리턴
    return output

# 함수 호출
print("1!:", factorial(1))
print("2!:", factorial(2))
print("3!:", factorial(3))
print("4!:", factorial(4))
print("5!:", factorial(5))

# 실행 결과
----------
1!: 1
2!: 2
3!: 6
4!: 24
5!: 120

재귀(recurison)

• 함수 내부에서 자기 자신을 호출하는 것
  
  

재귀함수로 팩토리얼 구하기

n! = n (n-1) (n-2) ... 1

factorial(n) = n * factorial(n -1) (n >= 1 일 때)
factorial(0) = 1

#재귀 함수를 사용해 팩토리얼 구하기
# 함수 선언
def factorial(n):
    # n이 0이라면 1을 리턴
    if n == 0:
        return 1
    
    # n이 0이 아니라면 n * (n-1)을 리턴

    else:
        return n * factorial(n - 1)
    
    # 함수 호출
print("1!:", factorial(1))
print("2!:", factorial(2))
print("3!:", factorial(3))
print("4!:", factorial(4))
print("5!:", factorial(5))

# 실행 결과
----------
1!: 1
2!: 2
3!: 6
4!: 24
5!: 120

팩토리얼의 경우는 어떤 형태로 만들어도 크게 상관 없음

재귀 함수의 문제

• 상황에 따라서 같은 것을 기하급수적으로 많이 반복하는 문제가 존재함
• 이를 해결하기 위하여 메모화(memoization)라는 기술을 사용함
  
  

피보나치 수열(fibonacci numbers)

• 첫 번째와 두 번째 항이 주어지며, 세 번째 항부터 앞의 두 항을 더한 값을 갖는 수열
  
  

재귀함수로 구현한 피보나치 수열

# 피보나치 수열_1

# 함수 선언
def fibonacci(n):
    if n == 1:
        return 1
    if n == 2:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)
    
# 함수 호출
print("fibonacci(1):", fibonacci(1))
print("fibonacci(2):", fibonacci(2))
print("fibonacci(3):", fibonacci(3))
print("fibonacci(4):", fibonacci(4))
print("fibonacci(5):", fibonacci(5))

# 실행 결과
----------
fibonacci(1): 1
fibonacci(2): 1
fibonacci(3): 2
fibonacci(4): 3
fibonacci(5): 5

• 피보나치 수열은 꽃들의 꽃잎 수를 계산할 때도 사용되는 수열임
• 잘 만들어진 함수라고 볼 수 있지만 fibonacci(35)를 입력하면 시간이 조금 오래 걸리게 됨
  아래 코드는 왜 시간이 오래 걸리는 것인지 코드를 변경해서 알아봄

# 피보나치 수열_2

# 변수 선언
counter = 0

# 함수 선언
def fibonacci(n):
    # 어떤 피보나치 수를 구하는지 출력
    print("fibonacci({})를 구합니다.".format(n))
    global counter
    counter += 1
    # 피보나치 수 구하기
    if n == 1:
        return 1
    if n == 2:
        return 1
    else:
        return fibonacci (n - 1) + fibonacci(n -2)
    
# 함수 호출
fibonacci(10)
print("---")
print("fibonacci(10) 계산에 활용된 덧셈 횟수는 {}번 입니다.".format(counter))

# 실행 결과
----------
fibonacci(10)를 구합니다.
fibonacci(9)를 구합니다.
...생략...
fibonacci(1)를 구합니다.
fibonacci(2)를 구합니다.
---
fibonacci(10) 계산에 활용된 덧셈 횟수는 109번 입니다.

• 이 코드를 실행해 보면 같은 것을 여러 번 연산한다는 것을 확인할 수 있음
• 이 정도면 아무리 컴퓨터라 하더라도 시간이 오래 걸릴 수 밖에 없음
• 이렇게 덧셈 횟수가 기하급수적으로 늘어나는 이유는 트리 내부에 있는 각각의 노드 값을 계산하려면 덧셈을 한 번씩 해야 함
• 그런데 노드가 한 번에 두 개씩 달려 있어서 한 번 구한 값은 그것으로 계산이 끝나면 좋겠지만, 현재 코드의 재귀함수는 한 번 구했더라도 다시 처음부터 계산을 해야 함
• 그래서 계산 횟수가 기하급수적으로 늘어남
  
  

Unbound LocalError에 대한 처리

• 파이썬은 함수 내부에서 함수 외부에 있는 변수를 참조하지 못 함(참조[reference]; 변수에 접근하는 것)
• 그러므로 'global 변수이름'을 사용하여 함수 내부에서 함수 외부에 있는 변수라는 것을 설명하도록 함
• global 키워드는 파이썬 프로그래밍 언어에만 있는 특이한 구조임
  
  

메모화(memoize)

• 재귀 호출에서 한 번 연산한 값을 중복해서 연산하지 않기 위해 새로운 값을 연산할 때마다 그 결과에 따른 값을 지정하는 것

# 메모 변수를 만듬
dictionary = {
	1: 1, 
    2: 1
}

# 함수 선언
def fibonacci(n):
	if n in dictionary:
    	# 메모가 되어 있으면 메모된 값 리턴
        return dictionary[n]
    else:
    	# 메모가 되어 있지 않으면 값을 구함
        output = fibonacci(n - 1) + fibonacci(n - 2)
        dictionary[n] = output
        return output
        
# 함수 호출
print("fibonacci(10):", fibonacci(10))
print("fibonacci(10):", fibonacci(20))
print("fibonacci(10):", fibonacci(30))
print("fibonacci(10):", fibonacci(40))
print("fibonacci(10):", fibonacci(50))

# 실행 결과
----------
fibonacci(10): 55
fibonacci(10): 6765
fibonacci(10): 832040
fibonacci(10): 102334155
fibonacci(10): 12586269025

• 위의 코드를 보면 딕셔너리를 이용하여 한 번 계산한 값을 저장하는데, 이를 메모한다고 표현함
• 값이 메모되어 있으면 처리를 수행하지 않고 곧바로 메모된 값을 돌려주면서 코드의 속도를 빠르게 만들어 줌
• 재귀함수와 함께 많이 사용되는 기술임
  
  

조기 리턴(early returns)

• 아래의 코드는 if else조건문을 만들고 각각의 마지막 부분에서 리턴하도록 하는 코드임

# 함수 선언
def fibonacci(n):
	if n in dictionary:
    	# 메모되어 있으면 메모된 값을 리턴
    	return dictionary[n]
    else:
    	# 메모되어 있지 않으면 값을 구함
        output = fibonacci(n - 1) + fibonacci(n - 2)
        dictionary[n] = output
        return output

• 이 코드를 변경하여 아래와 같이 표현하면 들여쓰기 단계가 줄기 때문에 코드를 더 쉽게 읽을 수 있음
• 이처럼 흐름 중간에 return 키워드를 사용하는 것을 조기 리턴이라고 부름

# 함수 선언
def fibonacci(n):
	if n in dictionary:
    	# 메모되어 있으면 값을 구함
        return dictionary[n]
    # 메모되어 있지 않으면 값을 구함
    output = fibonacci(n - 1) + fibonacci(n - 2)
    dictionary[n] = output
    return output        

---

🔎 함수 고급

튜플(tuple)

• 리스트와 비슷한 자료형이나 리스트와 다르게 한번 결정된 요소를 바꿀 수 없음
• 값을 변경하게 되면 TypeError가 나타남

(데이터, 데이터, 데이터, ...)

>>> tuple_test = (10, 20, 30)
>>> tuple_test[0]
10
>>> tuple_test[1]
20
>>> tuple_test[1] = 15
TypeError: 'tuple' object does not support item assignment

괄호 없는튜플

• 튜플은 아래와 같이 괄호가 없어도 동작함

(a, b) = (10, 20)     # 괄호가 있는 튜플
c, d = 30, 40         # 괄호가 없는 튜플

print("a:", a)
print("b:", b)
print("c:", c)
print("d:", d)

# 실행 결과
----------
a: 10
b: 20
c: 30
d: 40

튜플과 함수

• 튜플은 함수의 리턴에 많이 사용됨
• 함수의 리턴에 튜플을 사용하면 여러 개의 값을 리턴하고 할당할 수 있음

# 함수 선언
def test():
	return (10, 20)
    
# 여러 개의 값을 리턴받음
a, b = test()

# 출력
print("a:", a)
print("b:", b)

# 실행 결과
----------
a : 10
b: 20

람다(lamda)

• 코드를 효줄적으로 작성할 수 있도록 함수를 한 줄만으로 만들어줌
  
  

콜백함수(callback function)

# 매개변수로 받은 함수를 10번 호출한느 함수
def call_10_items(func):
	for i in range(10):
    	func()
        
# 간단히 출력하는 함수
def print_hello():
	print("안녕하세요")
    
# 조합하기
call_10_times(print_hello)

# 실행 결과
----------
안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요
안녕하세요

filter()함수와 map() 함수

• 함수를 매개변수로 사용하는 대표적인 표준 함수
• map() 함수는 리스트의 요소를 함수에 넣고 리턴된 값으로 새로운 리스트를 구성해줌

  map(함수, 리스트)

• filter() 함수는 리스트의 요소를 함수에 넣고 리턴된 값이 True인 것으로, 새로운 리스트를 구성해 줌

  filter(함수, 리스트)

# 함수 선언
def power(item):
    return item * item
def under_3(item):
    return item < 3

# 변수 선언
list_input_a = [1, 2, 3, 4, 5]

# map() 함수 사용
output_a = map(power, list_input_a)
print("# map() 함수의 실행 결과")
print("map(power, list_input_a):", output_a)
print("map(power, list_input_a):", list(output_a))
print()

# filter() 함수 사용
output_b = filter(under_3, list_input_a)

print("# filter() 함수의 실행 결과")
print("# filter(under_3, list_input_a):", output_b)
print("# filter(under_3, list_input_a):", list(output_b))

# 실행 결과
----------
# map() 함수의 실행 결과
map(power, list_input_a): <map object at 0x000002748491FDF0>
map(power, list_input_a): [1, 4, 9, 16, 25]

# filter() 함수의 실행 결과
# filter(under_3, list_input_a): <filter object at 0x000002748491FEB0>
# filter(under_3, list_input_a): [1, 2]

• map()함수와 filter() 함수는 모두 첫 번째 매개변수에 함수, 두 번째 매개변수에 리스트를 넣음
• 일단 map()함수는 첫 번째 매개변수에 값을 제곱해주는 power()함수를 넣었음
• 두 번째 매개변수에는 [1, 2, 3, 4, 5]라는 리스트를 넣고 결과로 [1, 2 3, 4, 5] 내부의 요소에 power()함수가 적용된 [1, 4, 9, 16, 25]를 얻음
• filter()함수에서는 item < 3을 판정하는 under_3()함수를 넣음
• 두 번째 매개변수에서는 [1, 2, 3, 4, 5]라는 리스트를 넣음
• 그 결과로 [1, 2, 3, 4, 5]내부의 요소 중에 item < 3이 True인 [1, 2]를 얻음
• 결과로 와 가 나오는데 이를 제너레이터(generator)라 부름

람다의 개념

• 간단한 함수를 쉽게 선언하는 방법

  lamda 매개변수: 리턴값

# 함수 선언
power = lambda x: x * x
under_3 = lambda x: x < 3

# 변수 선언
list_input_a = [1, 2, 3, 4, 5]

# map() 함수를 사용함
output_a = map(power, list_input_a)
print("#map() 함수의 실행 결과")
print("map(power, list_input_a):", output_a)
print("map(power, list_input_a):", list(output_a))
print()

# filter() 함수 사용
output_b = filter(under_3, list_input_a)
print("# filter()함수의 실행 결과")
print("filter(under_3, list_input_a):", output_b)
print("filter(under_3, list_input_a):", list(output_b))

# 실행 결과
----------
#map() 함수의 실행 결과
map(power, list_input_a): <map object at 0x00000274849A4790>
map(power, list_input_a): [1, 4, 9, 16, 25]

# filter()함수의 실행 결과
filter(under_3, list_input_a): <filter object at 0x00000274849A56F0>
filter(under_3, list_input_a): [1, 2]

• 위의 코드는 함수를 간단하게 사용하는 방법이라고 하고 복잡하다고 느껴짐
• 아래처럼 변경하면 람다는 다음과 같이 함수의 매개변수에 곧바로 넣을 수 있음

# 변수 선언
list_input_a = [1, 2, 3, 4, 5]

# map() 함수 사용
output_a = map(lambda x: x * x, list_input_a)
print(" map() 함수의 실행 결과")
print("# map(power, list_input_a):", output_a)
print("# map(power, list_input_a):", list(output_a))

# filter() 함수 사용
output_b = filter(lambda x: x < 3, list_input_a)
print("# filter() 함수의 실행 결과")
print("filter(under_3, list_input_a):", output_b)
print("filter(under_3, list_input_a):", list(output_b))

파일 처리

• 파이썬 표준 함수에서는 파일과 관련된 처리르 ㄹ하는 함수가 기본으로 제공됨
• 텍스트 파일과 바이너리 파일로 나뉨
• 파일을 처리하려면 파일열기(open)를 해야 함
• 파일을 열면 파일 읽기(read) 또는 파일 쓰기(write)를 할 수 있음
  
  

파일 열고 닫기

• 파일을 열 때 open()함수 사용함

  파일 객체 = open(문자열: 파일 경로, 문자열: 읽기 모드)

• open()함수의 첫 번째 매개변수에는 파일 경로(path)를 입력하고, 두 번째 매개변수에는 모드(mode)를 지정함

모드	설명
w	write 모드(새로 쓰기 모드)
a	append 모드(뒤에 이어스 쓰기 모드)
r	read 모드(읽기 모드)

• 파일을 닫을 때는 close()함수를 사용함

  파일 객체.close()

# 파일 열기
file = open("basic.txt", "w")

# 파일에 텍스트 작성
file.write("Hello Python Programming...!")

# 파일 닫기
file.close()

• 위의 함수를 확인해 보면 "basic.txt"라는 파일이 생성됨
  
  

with 키워드

• 파일을 열고 닫지 않는 실수를 방지하기 위해 with 키워드를 사용함

  with open(문자열: 파일 경로, 문자열: 모드) as 파일 객체:
  . . . . 문장

• with 구문이 종료될 때 자동으로 파일이 닫힘

# 파일 열기
with open("basic.txt", "w") as file:
	# 파일에 텍스트 씀
	file.write("Hello Python Programming...!")

텍스트 읽기

• 파일을 읽을 때 read()함수를 사용함
• read()함수를 호출하기만 하면 내부에 있는 데이터를 모두 읽어 출력함

  파일 객체.read()

# 파일 열기
with open("basic.txt", "r") as file:
	# 파일 읽고 출력
	contents = file.read()
print(contents)

# 실행 결과
----------
Hello Python Programming...!

---

🤔 기본 미션 ) p. 287 [직접 해보는 손코딩: 범위 내부의 정수를 모두 더하는 함수] 실행 후 코드가 입력된 화면 및 실행 결과 화면 캡처하기

---

😮 선택 미션 ) 매개변수, 기본 매개변수, 가변 매개변수에 대해 간략하게 정리하기

매개변수

• 함수를 호출할 때 필요한 데이터를 외부로부터 받기 위해 사용하는 것
  
  

기본 매개변수

• 매개변수를 원하는 만큼 받을 수 있는 함수
  
  

가변 매개변수

• 매개변수를 입력하지 않았을 경우 들어가는 기본값

---

👀 도전문제

1. 하노이 탑

원판 개수가 4개일 때 어덯게 원판을 옮겨야 하는지 출력하도록 프로그램 구현하기

원판의 개수를 입력하세요: 4
A 탑 -> C탑
A 탑 -> B탑
C탑 -> C탑
...생략...
A탑 -> C탑
A탑 -> B탑
C탑 -> B탑

🖥️

# 하노이 탑에서 필요한 요소를 모두 매개변수로 받음
def 하노이탑(원판, 시작기둥, 대상기둥, 보조기둥):
    if 원판 ==  1:
        print(시작기둥, "->", 대상기둥)
    else:
        # 아래의 원판을 제외하고, 시작 기둥에서 보조 기둥으로 이동
        하노이탑(원판 -1, 시작기둥, 보조기둥, 대상기둥)
        print(시작기둥, "->", 대상기둥)
        # 아래의 원판을 제외하고, 보조 기둥에서 대상 기둥으로 이동
        하노이탑(원판 - 1, 보조기둥, 대상기둥, 시작기둥)

n = int(input("원판의 개수를 입력하세요: "))
하노이탑(n, "A탑", "B탑", "C탑")

2. 하노이 탑 이동 횟수

하노이탑의 이동 횟수를 다음과 같이 출력하기

원판의 개수를 입력해주세요: 20
이동 횟수는 1048575회입니다.

🖥️

위의 코드에서 횟수만 추가하면 됨

횟수 = 0

def 하노이탑(원판, 시작기둥, 대상기둥, 보조기둥):
    global 횟수
    if 원판 ==  1:
        #print(시작기둥, "->", 대상기둥)
        횟수 += 1
    else:
        하노이탑(원판 -1, 시작기둥, 보조기둥, 대상기둥)
        #print(시작기둥, "->", 대상기둥)
        횟수 += 1
        하노이탑(원판 - 1, 보조기둥, 대상기둥, 시작기둥)

n = int(input("원판의 개수를 입력하세요: "))
하노이탑(n, "A탑", "B탑", "C탑")
print(f"이동 횟수는 {횟수}입니다.")

🖥️

아래의 코드는 수학코드로 작성했을 경우에 나타나는 방법

def 하노이탑이동횟수(n):
	return(2 ** n) -1

n = int(input("원판의 개수를 입력하세요: "))
print(f"이동 횟수는 {하노이탑이동횟수(n)}회 입니다."