조건문,반복문,컴프리헨션,함수

조건문  : if , elif ,else 

 

반복문 : while 

 > 중단 하고 싶을땐 ?   break

 > 건너 뛰고 싶을땐 ?  continue

while True:
    value = input("Integer , please [q to quit]:")
    if value == 'q':
        break
        
    number = int(value)
    if number % 2 == 0: 
        continue 
    print(number , "squared is", number**2)

break 확인하기 : else

break는 어던 것을 체크하여 그것을 발견했을 경우 종료하는 while문을 작성할 때 쓰인다. 

while 문이 모두 실행되었지만 발견하지 못했을 경우에는 else가 실행된다. 

numbers = [1,3,5]
position = 0
while position < len(numbers):
    number = numbers[position]
    if number % 2 ==0:
        print("Found even number")
        break
    position +=1
    
else : # break가 호출되지 않았을때
    print("no found even number")

순회하기 : for 

파이썬에서는 iterator를 자주 유용하게 쓴다. 

모두 while 문과 동일하게 쓰인다. 

 > 중단 하고 싶을땐 ?   break

 > 건너 뛰고 싶을땐 ?  continue

> break 확인하기 : else 

 

for, while 문에서의 else 의 의미?

 > 모든 항목을 순회했는지 확인하는 옵션.

cheeses = []
for cheese in cheeses:
    print("This shop has some lovely")
    break
 
    #cheeses 에 아무것도 없다면 ? break 실행 한될것.
else:
    print("This shop no have cheeses")
    
    
    This shop no have cheeses

 

여러 시퀀스 순회하기 : zip()

 

day = ["Monday","Tuesday","Wednesday"]
drink = ["coffe","tea","beer","cola"]
list(zip(day , drink))

[('Monday', 'coffe'), ('Tuesday', 'tea'), ('Wednesday', 'beer')]

 

range()를 이용해 숫자 시퀀스를 만들 수 있습니다. 

for i in range(10):
    print(i)

 

Comprehension(함축)은 간편한 구문으로 반복문과 조건 테스트를 결합할 수 있도록 해줍니다.

 

number_list = []
for number in range(10):
    number_list.append(number)
    
    
number_list
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

리스트 컴프리헨션 

[표현식 for 항목 in 순회가능한 객체]

number_list2 = [number for number in range(10)]
number_list2

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

좀더 나아가서 조건문을 결합해 보자.

[ 표현식 for 항목 in 순회가능한 객체 if 조건]

a_list = [number for number in range(10) if number % 2 ==1  ]
a_list
[1, 3, 5, 7, 9]

튜플과 결합해 보겠습니다.

rows = range(1,3)
cols = range(1,4)
for row in rows:
    for col in cols:
        print(row ,col)
        
1 1
1 2
1 3
2 1
2 2
2 3        

이중 for문을 좀더 파이써닉 하게 짜보면.

rows = range(1,3)
cols = range(1,4)
cells = [(row ,col) for row in rows for col in cols]
for cell in cells:
    print(cell)
    
(1, 1)
(1, 2)
(1, 3)
(2, 1)
(2, 2)
(2, 3)    

이제 딕셔너리도 컴프리헨션 해보겠습니다. 

 

{키_표현식 : 값_표현식 for 표현식 in 순회 가능한 객체}

word = "letters"
letter_counts = {letter : word.count(letter) for letter in word}
letter_counts

{'l': 1, 'e': 2, 't': 2, 'r': 1, 's': 1}

 

함수

함수는 입력 매개변수로 모든 타입을 여러 개 취할 수 있다. 그리고 return 값으로 모든 타입을 여러 개 반환할 수 있다. 

 

함수로 전달한 값을 인자(argument)라 부른다. 인자와 함수를 호출하면 인자의 값은 함수 내에서 해당하는 매개변수(parameter)에 복사된다. 

 

위치 인자. 

 > 인자의 가장 익숙한 타입은 값을 순서대로 상응하는 매개변수에 복사하는 위치인자이다.

def menu(wine , entree , dessert):
    return{'wine':wine,'entree':entree,'dessert':dessert}
   
   
menu("chardonnay",'chicken','cake')

{'wine': 'chardonnay', 'entree': 'chicken', 'dessert': 'cake'}

키워드 인자

 > 위치인자의 혼동을 피하기 위해 매개변수에 상응하는 이름을 인자에 지정할 수 있다.

menu(entree='beef',dessert = 'bagel',wine='bordeaux')

{'wine': 'bordeaux', 'entree': 'beef', 'dessert': 'bagel'}

기본 매개변수 값 지정하기 .

 > 매개변수에 기본값을 지정할 수 있습니다. 

 

def menu(wine ,entree ,dessert ='pudding'):
    return{'wine':wine,'entree':entree,'dessert':dessert}

menu('chardonnay','chicken')
{'wine': 'chardonnay', 'entree': 'chicken', 'dessert': 'pudding'}

여기서 dessert 인자를 입력하면 기본값 대신 입력한 인자가 사용됩니다.

 

위치 인자 모으기 : *

함수의 매개변수에 애스터리스크를 사용할 때 , 애스터리스크는 매개변수에서 위치 인자 변수들을 튜플로 묶는다. 

def print_args(*args):
    print("Positional argument tuple:",args)
    
print_args()
Positional argument tuple: ()

print_args(3,2,1,"wait!","uh..")
Positional argument tuple: (3, 2, 1, 'wait!', 'uh..')


def print_more(required1,required2,*args):
    print("Need this one:",required1)
    print("Need this one too:",required2)
    print("All the rest:",args)
    
print_more("cap","moncle","pen","dog")
Need this one: cap
Need this one too: moncle
All the rest: ('pen', 'dog')

 

키워드 인자 모으기 : ** 

키워드 인자를 딕셔너리로 묶기 위해 두개의 애스터리스크를 사용한다. 인자의 이름은 키고 값은 이 키에 대응하는 딕셔너리 값이다. 

def print_kwargs(**kwargs):
    print("Keyword arguments:",kwargs)
    
print_kwargs(wine='merlot',entree='mutton',dessert='macaroon')
Keyword arguments: {'wine': 'merlot', 'entree': 'mutton', 'dessert': 'macaroon'}

docstring 

함수 시작 부분에 문자열을 포함시켜 함수 정의에 문서를 붙일 수 있습니다. """ """ 사용 

 

내부함수

> 함수 안데 또 다른 함수를 정의할 수 있다. 

내부함수는 루프나 코드 중복을 피하기 위해 또 다른 함수 내에 어떤 복잡한 작업을 한번 이상 수행할 대 유용하게 사용된다.

def outer(a,b):
    def inner(c,d):
        return c+d
    return inner(a,b)
outer(4,7)
11

def knights(saying):
    def inner(quote):
        return "We are the knights who say: '%s'" %quote
    return inner(saying)

knights('Ni')
"We are the knights who say: 'Ni'"

클로져 

 > 내부 함수는 클러져(closure)처럼 행동할 수 있다. 클로져는 다른 함수에 의해 동적으로 생성된다. 

그리고 바깥 함수로부터 생성된 변수 값을 변경하고, 저장할 수 있는 함수이다.

def knights2(saying):
    def inner2():
        return "We are the knights who say: '%s'" %saying
    return inner2

inner() 함수는 knights2() 함수가 전달받은 saying 변수를 알고 있다. 코드에서 return inner2라인은 inner2함수의 특별한 복사본을 반환한다. 이것이 외부함수에 의해 동적으로 생성되고 , 그 함수의 변수값을 알고 있는 함수인 클로져이다.

def knights2(saying):
    def inner2():
        return "We are the knights who say: '%s'" %saying
    return inner2
    
a = knights2("Duck")
b = knights2("Hasenpfeffer")

a
<function __main__.knights2.<locals>.inner2()>

b
<function __main__.knights2.<locals>.inner2()>

a,b를 호출하면 knights2()함수에 전달되어 사용된 saying을 기억한다. 

a()
"We are the knights who say: 'Duck'"

b()
"We are the knights who say: 'Hasenpfeffer'"

type(a)
function

type(b)
function

익명 함수 : lambda()

 > 람다 함수는 단일문으로 표현되는 익명 함수입니다. 

def edit_story(words , func):
    for word in words:
        print(func(word))
        
def enliven(word):
    return word.capitalize() +'!'

stairs = ['thud','meow','thud','hiss']
edit_story(stairs,enliven)

Thud!
Meow!
Thud!
Hiss!

enliven() 함수를 람다함수로 만들어 보자.

edit_story(stairs,lambda word: word.capitalize() + '!')

Thud!
Meow!
Thud!
Hiss!

 

제너레이터

 

> 제너레이터는 파이썬의 시퀀스를 생성하는 객체다.

def my_range(frist = 0,last = 10,step = 1):
    number = frist
    while number < last :
        yield number
        number+=step
        
ranger = my_range(1,5)
ranger

for x in ranger:
    print(x)
    
1
2
3
4    

데커레이터

 > 소스코드를 바꾸지 않고, 사용하고 있는 함수를 수정하고 싶을 때 사용. 일반적인 예는 함수에 전달된 인자를 보기 위해 디버깅 문을 추가하는 것.

 

데커레이터는 하나의 함수를 취해서 또 다른 함수를 반환하는 함수. 

 *args와 **kwargs

 내부 함수 

 함수 인자 를 사용.

 

#document_it()함수는 다음과 같이 데커레이터를 정의한다.

 함수 이름과 인자값을 출력한다.

 인자로 함수를 실행한다.

 결과를 출력한다.

 수정된 함수를 사용할 수 있도록 반환한다.

def document_it(func):
    def new_function(*args,**kwargs):
        print("Running function:",func.__name__)
        print("Positional arguments:",args)
        print("Keyword arguments:",kwargs)
        result = func(*args,**kwargs)
        print("Result:",result)
        return result
    return new_function

document_it()함수에 어떤 func 함수 이름을 전달하든지 간에 document_it()함수에 추가 선언문이 포함된 새 함수를 얻는다. 데커레이터는 실제로 func 함수로부터 코드를 실행하지 않는다. 하지만 document_it() 함수로부터 func를 호출하여 결과뿐만 아니라 새로운 함수를 얻느다.

 

데커레이터 사용법  (수동)

def add_ints(a,b):
    return a+ b
add_ints(3,5)
8

cooler_add_ints = document_it(add_ints)
cooler_add_ints(3,5)

=============================
Running function: add_ints
Positional arguments: (3, 5)
Keyword arguments: {}
Result:  

위와 같이 수동으로 데커레이터를 할당하는 대신  @데커레이터_이름을 추가한다. 

@document_it
def add_ints(a,b):
    return a+b
add_ints(3,5)

함수는 여러 개의 데커레이터를 가질 수 있습니다. 

def square_it(func):
    def new_function(*args,**kwargs):
        result = func(*args,**kwargs)
        return result**2
    return new_function
    
@document_it
@square_it
def add_ints(a,b):
    return a+b
add_ints(3,5)

=======
64

 

네임스페이스와 스코프