05강) 함수

목차: 

          05_1) 함수 만들기

          05_2) 함수의 활용

          05_3) 함수 고급

 

05_1) 함수 만들기

  -함수의 기본 및 함수에 매개변수 만들기

  -가변 매개변수, 기본 매개변수, 키워드 매개변수

  -리턴 및 기본적인 함수의 활용 

 

 

  ▶함수의 기본 및 함수에 매개변수 만들기

    함수를 생성하는 기본 형태는 아래와 같다.

      syntax) def 함수이름(): 

                      문장          

     함수에 (일반)매개변수 만들기

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

                      문장                                       

     주의) (1) 함수를 호출할때 함수를 선언할 때와 같은 개수의 매개변수를 입력해야 한다.(그렇지 않으면 오류 발생)

             (2) 함수 내부에서 함수 외부에 있는 변수를 참조하지 못함

                  ( 해결 syntax-> global  변수이름 )

def new_fun():          # 함수 선언
	print("안녕하십니까")
    

new_fun()              # 함수 호출
안녕하십니까            # 함수실행하여 나오는 출력값


#-------매개변수-------#
def funn(value, n):       # 함수 선언     ,매개변수 2개(value,n)
	for i in range(n):
    	 print(value)

funn("Hello",3)      # 함수 호출
Hello
Hello
Hello

 

 

 

  ▶가변 매개변수, 기본 매개변수, 키워드 매개변수

 

      ● 가변 매개변수  

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

              ex) print() 에서 print("매개변수1", "매개변수2") 안에 매개변수를 원하는 만큼 받을 수 있다

 

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

                        문장                                                               

         주의) -제약이 존재함

                  1) 가변 매개변수 뒤에는 일반 매개변수가 올 수 없음

                  2) 가변 매개변수는 하나만 사용할 수 있음

 

def funn(n, *values):              # 가변 매개변수를 씀으로 여러개를 받음
    for i in range(n):
        for value in values:
            print(value)
        print()
            
funn(3,"Today","is","monday")     # 함수를 호출함    *value에 "Today" "is" "Monday" 라는 3개의 매개변수 받음

Today
is
monday

Today
is
monday

Today
is
monday

      ● 기본 매개변수

          -> '매개변수=값'

                syntax) 매개변수=값 

              주의) 기본 매개변수 뒤에는 일반 매개변수가 올 수 없음

 

              ex) print(value, . . . , sep=' ' ,end='\n', file=sys.stdout)

                    에서

                     sep=' '                          # 문자열 사이마다 추가 하고 싶은것

                     end='\n'                       # 문자열 마지막에 추가 하고 싶은것

                     file=sys.stdout

                    가 기본 매개변수이다.

               

def funn(value, n=2):     # 함수 선언
    for i in range(n):    # n=2 라고 자동으로 입력이 됨
        print(value)
        
funn("Hello")              # 함수 

Hello
Hello

 

 

      ● 키워드 매개변수

           -> 매개변수 이름을 직접적으로 지정해서 값을 입력한다.

                (n=3으로 직접 지정됨!)

def funn(*values, n=2):           # 함수 선언
    for _ in range(n):            # _ = i로 선언한것과 동일한 의미(range()만큼 돌겠다)
        for value in values:
            print(value)  
        print()
        
funn("Today","is","Monday",n=3)       # 함수 호출 // 
                                      # ★ 매개변수 이름을 직접적으로 지정해서 값을 입력함 n=3
              
              
Today             # n=3 임으로 3번 출력됨
is
Monday

Today
is
Monday

Today
is
Monday

def value(a,b=10,c=30):    # 함수 선언
    print(a+b+c)
    
value(10,20,30)            # 함수 호출
60

value(a=10,b=100,c=200)    # 함수 호출         
310

value(c=10,a=100,b=200)    # 함수 호출
310

value(10,c=200)             # 함수 호출
220

  ▶리턴 및 기본적인 함수의 활용 

        ● 리턴 

            (1) 자료 없이 리턴

                -> 함수를 실행했던 위치로 돌아가라는 의미+함수를 여기서 끝내라는 의미

            (2) 자료와 함께 리턴

                 -> 리턴뒤에 있던 자료를 입력하면 자료를 가지고 리턴(돌아감)함

            (3) 아무것도 리턴하지 않기

                 ->None이 출력됨

#--------자료 없이 리턴하기---------#
def test_1():    # 함수 선언
    print("A")
    return       # 리턴 함
    print("b")   #  print('b')코드가 실행이 안됨
    
test_1()         # 함수 호출
A

#-------자료와 함께 리턴하기-------#
def test_2():    # 함수 선언
    
    return 100 
    
value=test_2()         # 함수 호출 후 value에 리턴당한 100값을 할당함
print(value)
100

#------아무것도 리턴하지 않기-------#
def test_3():    # 함수 선언
    
    return       # 아무것도 리턴하지 않음 
    
value=test_3()         # 함수 호출 후 value에 return 값 할당함
print(value)   
None                   # 아무것도 할당하지 않아서 None(없다)가 출력됨

     ● 기본적인 함수의 활용

        syntax)  def 함수(매개변수):    

                        변수=초깃값       

                        # 여러 가지 처리 

                        # 여러 가지 처리 

                        return 변수         

def sum_all(start,end):     # 함수 선언
    output=0                # 변수를 선언
    for i in range(start,end+1):
        output=output+i
    return output

print(sum_all(0,100))     # 함수를 호출하고 출력함

 

 

05_2) 함수의 활용

             -재귀 함수

            -재귀함수의 문제

 

 

  ▶ 재귀 함수

           -> 재귀: 자기 자신을 호출하는 것

               주의)  함수 스스로 '재진입' 아니라 '복사복 만들'어서 들어가는 것이고,

                        사용하고 나면 복사본 사라짐

 

def factorial(n):     # 함수 선언
    if n==0:
        return 1
    else:
        return n*factorial(n-1)
    
    
print(factorial(5))             # factorial(5)
                                # = 5*factorial(4)
                                # = 5*4*factorial(3)
                                # = 5*4*3*factorial(2)
                                # = 5*4*3*2*factorial(1)
                                # = 5*4*3*2*1
120

 

 

#리스트 평탄화(재귀함수 사용)_중첩된 리스트의 중첩을 제거하고 1차원 리스트로 만드는 것


def flatten(data):                         # 함수 선언
    output=[]                              # 빈 리스트를 만들어줌
    for item in data:                      # 
        if type(item)==list:               # 내부 변수의 타입이 리스트 이면 
            output=output+flatten(item)    # 함수 호출(재귀함수)함//리스트를 합침
        else:
            output.append(item)            # 요소를 추가함
    return output

example=[[1,2,3,],[4,[5,6]],7,[8,9]]



print(example)
[[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print(flatten(example))                 # flatten 함수 호출
[1, 2, 3, 4, 5, 6, 7, 8, 9]

  ▶ 재귀함수의 문제

          ->기하 급수적으로 많이 반복하고, 필요한값을 사용후 저장하는것이아니라 삭제함으로 다시

              출력을 위해서는 다시 같은 과정을 거쳐감. 

 

          sol) 메모화  : 딕셔너리를 사용해서 한 번 계산한 값을 저장함.

dictionary_A={      # 메모변수를 만듬=딕셔너리 선언함
    1:1,
    2:1,
}

def fibonacci(n):     # 함수 선언
    if n in dictionary_A:
        return dictionary_A[n]   # 메모가 되있으면 key에 맞는 value를 가져와서 리턴함
    else:
       output=fibonacci(n-1)+fibonacci(n-2)
       dictionary_A[n]=output            # 딕셔너리에 새로운 key와 value를 선언해줌
       return output
        
a=fibonacci(20)      # 함수를 호출후 a에 할당해줌
print(a)
6765

                 

 05_3) 함수 고급

                 - 튜플

                 - 람다

                 - 파일 처리

 

  ▶ 튜플

        정의) 함수와 함께 많이 사용되는 리스트와 비슷한 자료형으로, 리스트와 다른 점은 한번 결정된

               요소는 바꿀 수 없음.

             syntax)  (데이터, 데이터, 데이터 ...)        ,괄호를 생략해도 튜플로 인식함

            주의) 요소를 하나만 갖일때 (273) 아니라(273,) 으로 표기해야함(쉼표 추가!)

            Tip) 함수의 리턴에 튜플을 사용하면 여러 개의 값이 리턴하고 할당할수 있어서, 튜플은 함수의

                   리턴에 많이 씀.

 

#-----------튜플---------#
tuple_example=(10,20,30)
tuple_example2=40,50,60            # 괄호가 없는 형태

print(tuple_example[0])
10
print(tuple_example2[1])
50
print(tuple_example[2])
30

#--------괄호 없는 튜플--------#

[a,b]=[30,40]
(c,d)=(10,20)

print(a)
30
print(b)
40
print(c)
10
print(d)
20

#--------변수의 값을 교환하는 튜플---------#

a,b=10,20
print(a)
10
print(b)
20

a,b= b,a     # 이런식으로 하면 코드값이 바뀜.(편리한 방법으로 값을 교환할수 있음

print(a)
20
print(b)
10

#----------여러개의 값 리턴하기----------#

def test():
    return(10,20)

a,b=test()

print(a)
10
print(b)
20

 

 

  ▶ 람다

     -함수의 매개변수로 함수 전달하기 

          ->함수의 매개변수에 함수를 대입하는 것 

def call_10(func):            # 매개변수로 받은 함수를 5번 호출하는 함수 선언
    for i in range(5):
        func()
         
def print_fun():              # Hello를 출력하는 함수 선언
    print("Hello")
    
call_10(print_fun)           # 함소호출 //매개변수로 함수를 

Hello
Hello
Hello
Hello
Hello

 

     -함수를 매개변수로 전달하는 대표적인 표준함수

       ●  filter()  함수                     

             syntax) map(함수,리스트) 

             -> 리스트의 요소를 함수에 넣고 리턴된 값이 true인 것으로, 새로운 리스트를 구성해 주는 함수

 

       ●  map()  함수                       

            syntax) filter(함수, 리스트)  

              -> 리스트의 요소를 함수에 넣고 리턴된 값으로 새로운 리스트를 구성해 주는 함수

 

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

def mul(item):            # 매개변수로 받은 함수를 5번 호출하는 함수 선언
    return item*item


output_a=map(mul,list_1)     # list_1 리스트가 mul함수를 거치고 새로운 값으로 리턴되어 리스트를 새로 구성함
print(list(output_a))        # 리스트이기 때문에 출력을 위해서 list를 해줘야함

def under_3(num):
    return num<3


output_b=filter(under_3,list_1)       # list_1 리스트가 under함수를 거치고 참인 값만 출력하여 리스트를 새로 구성함
print(list(output_b))                 # 리스트이기 때문에 출력을 위해서 list를 해줘야함

 

       ●람다의 개념

            람다의 정의) 매개변수로 함수를 전달하기 위해 함수 구문을 작성하는 것이 번거롭고,

                             코드 공간 낭비라는 생각이 들 때 함수를 간단하고 쉽게 선언하는 방법.

 

            syntax) (1) lambda 매개변수: 리턴값  

                      (2) 매개변수가 여러개인 람다 ->  lambda x,y : x*y 

 

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

mul=lambda item: item*item      # 람다를 이용해 함수 선언
output_a=map(mul,list_1)     # list_1 리스트가 mul함수를 거치고 새로운 값으로 리턴되어 리스트를 새로 구성함
print(list(output_a))        # 리스트이기 때문에 출력을 위해서 list를 해줘야함

[1, 4, 9, 16, 25]


#--------더 간단하게----#

list_1=[1,2,3,4,5]
output_a=map(lambda item: item*item,list_1)
print(list(output_a))

[1, 4, 9, 16, 25]

 

  ▶ 파일 처리

             -> 파일과 관련된 처리를 하는 함수는 표준 함수가 기본으로 제공이 됨.

           

             ● 파일 열고 닫기

                 

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

                 파일을 닫을 때   syntax) 파일 객체.clsoe()                                                

 

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

file=open("basic.txt","w")   # 파일을 연다.             # w는 읽기모드 임
file.write("Hello")          # 퍄일에 텍스트를 씀
file.close                   # 파일을 닫는다.


# 실행후 프로그램과 같은 폴더에 basic,txt라는 파일이 생성됨

 

               ● with 키워드

                  -> 파일을 열고 닫지 않는 실수 방지

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

                                          문장                                                            

with open("basic.txt","w") as file:
    file.write("다정히 내이름을 부루면")
    
# with 구문이 종료될 때 자동으로 파일이 닫힌다.

              

                ● 텍스트 쓰기, 읽기

                    syntax) 파일객체.write() 

                               파일객체.read()   

with open("basic.txt","r") as file:          # 파일을 연다. # r을 씀으로 읽기모드로 변경함
    contents =file.read()                    # 파일을 읽고 출력함

print(contents)
다정히 내이름을 부루면