Python Programming: Function

PythonIntermediateProgramming
임찬식(chanshik@gmail.com)
1

PythonIntermediateProgramming
타입과 객체
함수와함수형프로그래밍
클래스와객체지향프로그래밍
데이터구조
튜닝과 최적화
2

함수와함수형프로그래밍
함수
유효범위규칙
클로저
장식자
생성기
코루틴
리스트내포(list comprehension)
생성기 표현식
3

함수
함수는def문으로정의
>>> def add(x, y):
... return x + y
...
>>> add(10, 20)
30
함수의이름을적고 바로이어서함수인자들의튜플을나열해호출
인수의순서와개수는함수에서정의한것과 일치해야함
인수가 일치하지않을경우TypeError
4

함수
함수매개변수에기본인수지정
>>> def power(x, y=2):
... return x ** y
...
>>> power(2)
4
>>> power(3, 3)
27
5

함수
기본매개변수값은함수를정의할때지정한객체로설정
>>> a = 10
>>> def foo(x=a):
... return x
...
>>> a = 5
>>> foo()
10
위에서'a' 를재할당하더라도기본값이변경되지않음
6

함수
변경 가능한객체를기본값으로지정할경우의도하지않은결과 발생가능
>>> def foo(x, items=[]):
... items.append(x)
... return items
...
>>> foo(1)
[1]
>>> foo(2)
[1, 2]
>>> foo(3)
[1, 2, 3]
7

함수
기본인수가 이전호출때의변경 사항을담고 있음
이러한문제를피하기 위해기본값으로None을지정하는것을권장
>>> def foo(x, items=None):
... if items is None:
... items = []
...
... items.append(x)
... return items
...
>>> foo(1)
[1]
>>> foo(2)
[2]
>>> foo(3)
[3]
8

함수
마지막매개변수이름앞에별표(*)를추가해여러개의매개변수받는것 가능
남아있는모든인수가 튜플로써args 변수에저장
튜플args 를매개변수인것처럼함수에전달하려면*args 를사용
>>> def fprintf(file, fmt, *args):
... file.write(fmt % args)
...
>>> import sys
>>>
>>> fprintf(sys.stdout, "%d %s %fn", 42, 'Hello, World',
42 Hello, World 3.140000
9

함수
남아있는모든인수를저장한변수를다른함수에인자로전달
>>> def printf(fmt, *args):
... fprintf(sys.stdout, fmt, *args)
...
>>> printf("%d %s %fn", 42, 'Hello, World', 3.14)
42 Hello, World 3.140000
10

함수
함수인수를매개변수이름과 값을이용해지정
키워드인수(keywordargument)
>>> def foo(w, x, y, z):
... print(w, x, y, z)
...
>>>
>>> foo(x=3, y=10, w='Hello', z=[1, 2, 3, 4])
Hello 3 10 [1, 2, 3, 4]
키워드인수를사용할때는매개변수순서가 중요하지않음
기본값이지정된것을제외하고 모든매개변수를직접지정해주어야함
11

함수
위치인수와키워드인수를섞어사용하는것도가능
모든위치인수를먼저지정해야함
모든생략가능한인수의값을지정해야함
인수값을두번이상설정하면TypeError
>>> foo('Hello', 3, z=[1, 2, 3, 4], y=42)
Hello 3 42 [1, 2, 3, 4]
>>> foo(3, 42, w='Hello', z=[1, 2, 3, 4])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'w'
12

함수
마지막인수이름이**로시작할경우어떤매개변수이름과도일치하지않는
모든추가 키워드인수들이사전으로구성되어전달
>>> def make_table(data, **params):
... fgcolor = params.pop("fgcolor", "black")
... bgcolor = params.pop("bgcolor", "white")
... width = params.pop("width", None)
... height = params.pop("height", None)
... if params:
... raise TypeError(
"Unsupported %s" % list(params))
... print(data, fgcolor, bgcolor, width, height)
...
>>>
>>> make_table([1, 2, 3, 4], width=640, height=480)
[1, 2, 3, 4] black white 640 480
>>> make_table([1, 2, 3, 4], font='Arial')
File "<stdin>", line 8, in make_table
TypeError: Unsupported options ['font']
13

함수
** 매개변수가 가장나중에나오는경우에한해서추가 키워드인수들이
가변길이인수목록과 함께나타날수있음
키워드인수는**kwargs 문법을사용해다른함수로전달가능
>>> def foo(*args, **kwargs):
... print(args, kwargs)
...
>>>
>>> def call_foo(*args, **kwargs):
... foo(*args, **kwargs)
...
>>> call_foo(10, 20, x=3.14, y=42)
(10, 20) {'x': 3.14, 'y': 42}
14

매개변수전달과 반환값
함수매개변수는단순히전달된입력객체를참조하는이름일뿐
변경 불가능한값: 값에의한전달
변경 가능한객체: 참조에의한전달
변경 가능한객체가 함수에전달되어그 값이변경되면원래객체값에영향
>>> a = [1, 2, 3, 4, 5]
>>> def square(items):
... for i, x in enumerate(items):
... items[i] = x * x
...
>>> square(a)
>>> a
[1, 4, 9, 16, 25]
15

입력으로넘어온값을변경하거나프로그램의다른부분을변경하는함수는
부작용(sideeffect) 을가진다고 하고 이는프로그램이커질거나
복잡해질수록까다로운문제를발생시키는원인이될수있음
함수호출이어떤형태로든외부에변경을가할경우에는함수이름이나
주석을통해어디에영향을주는지명시하는것을권장
쓰레드나병행프로그래밍이필요한곳에서부작용을가지는함수를
사용하는것은매우까다롭고 주의를필요로함
16

반환할값을지정하지않거나return문을생략하면None객체가 반환
여러값을반환하려면튜플에넣어서반환
>>> def factor(a):
... d = 2
... while d <= (a / 2):
... if int(a / d) * d == a:
... return a / d, d
... d += 1
... return a, 1
...
>>> factor(16)
(8.0, 2)
>>> factor(37)
(37, 1)
>>> x, y = factor(39)
>>> x, y
(13.0, 3)
17

유효범위규칙
함수가 실행될때마다새로운지역네임스페이스생성
매개변수이름과 함수에서할당된변수이름을담은내부실행환경
변수이름을해석할때순서
지역네임스페이스검색(함수)
전역네임스페이스검색(함수가 정의된모듈)
내장네임스페이스검색
아무곳에서도찾을수없으면NameError
18

유효범위규칙
함수에서전역네임스페이스접근
>>> a = 42
>>> def foo():
... a = 13
...
>>>
... foo()
>>> print(a)
42
위코드에서foo() 함수는전역변수a를변경할수없음
19

유효범위규칙
global선언을이용한전역네임스페이스접근
>>> a = 42
>>> b = 37
>>> def foo():
... global a
... a = 13
... b = 0
...
>>>
>>> foo()
>>> print(a, b)
13 37
foo() 함수에서함수밖에서선언된a변수값을변경
20

유효범위규칙
중첩함수선언가능
>>> def countdown(start):
... n = start
... def display():
... print("T-minus %d" % n)
...
... while n > 0:
... display()
... n -= 1
...
>>>
>>> countdown(5)
T-minus 5
T-minus 4
T-minus 3
T-minus 2
T-minus 1
21

유효범위규칙
중첩함수에서값을재할당할수있는범위는중첩함수내부와전역만가능
중첩함수내부지역변수
global을이용한전역변수
... n = start
... def display():
... def decrement():
... n -= 1 # 바깥 함수에 정의된 n 재정의 불가
... while n > 0:
... display()
... decrement()
...
>>> countdown(5)
T-minus 5
...
UnboundLocalError: local variable 'n' referenced before assignm
22

유효범위규칙
Python2 에서는변경하고자하는값을리스트나사전에넣어서사용가능
Python3 에서는nonlocal선언을이용해사용가능
... n = start
... def display():
... def decrement():
... nonlocal n
... n -= 1
... while n > 0:
... display()
... decrement()
...
>>> countdown(5)
T-minus 5
T-minus 4
T-minus 3
T-minus 2
T-minus 1
23

유효범위규칙
지역변수에값을할당하기 전에사용하면UnboundLocalError
foo() 함수안에서변수i는지역변수로선언되었음
하지만i= i+ 1 에서i에값이할당되기 전에읽으려시도
변수는함수를정의하는순간에지역또는전역인지여부가 결정되고
중간에유효범위가 변경되는일은없음
>>> i = 0
>>> def foo():
... i = i + 1
... print(i)
...
>>> foo()
File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'i' referenced before assignm
24

객체와클로저로서함수
함수는1급 객체이므로함수자체를다른함수인자로전달하거나
자료구조안에저장하는것, 함수결과로서반환하는것도모두가능
# foo.py
def callf(func):
return func()
함수를인자로받아호출하는예
>>> import foo
>>>
>>> def helloworld():
... return 'Hello, World!'
...
>>> foo.callf(helloworld)
'Hello, World!'
25

함수를데이터로취급할때는함수가 정의된곳 주변환경 정보를같이저장
# foo.py
x = 42
def callf(func):
return func()
주변변수를참조하도록변경
>>> import foo
>>> foo.x
42
>>> x = 37
>>> def helloworld():
... return 'Hello, World!. x is %d' % x
...
>>> foo.callf(helloworld)
'Hello, World!. x is 37'
26

앞의예에서변수x 는foo.py 에정의되어있고, helloworld() 함수가
호출된곳도foo.py 이지만출력된값은그 안에정의된값(foo.x)이아님
함수를구성하는문장과 실행환경을함께묶은것이클로저(closure)
함수는자신이정의된전역네임스페이스를가리키는globals 속성을가짐
>>> helloworld.__globals__
{'__name__': '__main__', '__doc__': None,
'__package__': None,
...
'x': 37, 'helloworld': <function helloworld at 0x10230cf28
27

클로저와중첩함수는
게으른평가(Lazy evaluation) 또는지연평가(Delayedevaluation) 라는
개념에기초하여코드를작성할때유용
>>> from urllib.request import urlopen
>>> # from urllib import urlopen # Python 2
...
>>> def page(url):
... def get():
... return urlopen(url).read()
... return get
...
위에코드에서page() 함수는웹페이지내용을가져오는get() 함수를
생성해반환하는일외에는아무런일도수행하지않음
get() 함수실행은나중에get() 이평가되는순간까지미뤄짐
28

두변수python과 jython은실제로get() 함수의서로다른버전
page() 함수는더이상실행되지않지만get() 함수가 실행할때
정의된바깥쪽변수의값을가져와사용
get() 함수가 실제로실행할때원래page() 함수에제공된url값으로
urlopen(url) 을호출
>>> python = page("http://www.python.org")
>>> jython = page("http://www.jython.org")
>>> python
<function page.<locals>.get at 0x102b842f0>
>>> jython
<function page.<locals>.get at 0x102b84378>
>>> py_data = python() # http://www.python.org 를 얻어옴
>>> jy_data = jython() # http://www.jython.org 를 얻어옴
29

클로저를살펴보면어떤변수가 함께묶여있는지확인가능
>>> python.__closure__
(<cell at 0x102309528: str object at 0x102b7adf8>,)
>>> python.__closure__[0].cell_contents
'http://www.python.org'
>>> jython.__closure__[0].cell_contents
'http://www.jython.org'
30

클로저는일련의함수호출사이에상태정보를보존하는데효율적
>>> def countdown(n):
... def next():
... nonlocal n
... r = n
... n -= 1
... return r
... return next
...
>>> next = countdown(3)
>>> while True:
... v = next()
... print(v)
... if not v:
... break
...
3
2
1
0
31

클래스를이용한countdown구현
>>> class Countdown(object):
... def __init__(self, n):
... self.n = n
... def next(self):
... r = self.n
... self.n -= 1
... return r
...
>>>
>>> c = Countdown(3)
>>> while True:
... v = c.next()
... print(v)
... if not v:
... break
...
3
2
1
0 32

장식자
장식자(decorator)는다른함수나클래스를포장하는것이주목적
포장하려는객체의작동방식을변경하거나향상시키는작업수행
특수문자@ 를사용하여표시
def square(x):
return x * x
square = trace(square)
위의코드는장식자를이용해간단히작성가능
@trace
def square(x):
return x * x
33

장식자
장식자는반드시함수나클래스정의바로앞에별개의줄로적어야함
@foo
@bar
@something
def func(x):
pass
이경우장식자는나열된순서대로적용
def func(x):
pass
func = foo(bar(something(func)))
34

장식자
장식자에인수를넘기는것도가능
@eventhandler("BUTTON")
def handle_button(msg):
...
@eventhandler("RESET")
def handle_reset(msg):
...
이경우에는아래코드처럼동작
def handle_button(msg):
...
t = eventhandler("BUTTON") # 제공된 인자로 장식자 호출
handle_button = t(handle_button) # 호출 결과 장식자로 원래 함수 호출
35

장식자
장식자함수는@ 지정자로제공한인수만을받아주어진함수를
인수로하여호출될새로운함수반환
event_handler = {}
def eventhandler(event):
def register_function(f):
event_handler[event] = f
return f
return register_function
36

생성기와yield
함수에서yield키워드를사용해생성기(generator) 객체를정의
생성기는반복에서사용할값들을생성하는함수
... print("Counting down from %d" % n)
... while n > 0:
... yield n
... n -= 1
... return
...
>>> c = countdown(3)
>>>
위함수를호출하면아무코드도실행되지않고 생성기 객체를반환
37

생성기와yield
생성기를반환하는함수에서return문을사용하는경우
3.3 이전버전에서는문법오류
3.3 버전부터는무시되지않고 return값을반환하고 종료
return문뒤에있는yield는무시
참고할링크
https://www.python.org/dev/peps/pep‑0380/
http://stackoverflow.com/questions/16780002/return‑in‑generator‑
together‑with‑yield‑in‑python‑3‑3
38

생성기와yield
>>> type(c)
<class 'generator'>
반환된생성기 객체를이용해실제함수실행
Python3 에서는__next__(), Python2 에서는next() 호출
>>> c.__next__()
Counting down from 3
3
>>> c.__next__()
2
>>> c.__next__()
1
>>> c.__next__()
StopIteration
39

생성기와yield
생성기 실행순서
__next()__ 를호출하면생성기 함수는yield문까지실행
yield문은결과를생성해반환하고 __next()__ 호출전까지실행중단
함수실행은yield바로다음문장에서재개
보통은생성기를직접호출하기보다는순서열을소비하는for, sum() 혹은
기타연산에서__next()__ 호출이사용됨
>>> for n in countdown(3):
... print(n)
...
3
2
1
>>> sum(countdown(3))
6
40

생성기와yield
생성기 함수를부분적으로만실행하는경우에는close() 메서드를호출해
명시적으로생성기 객체에종료를알려주는것이가능
>>> c.__next__()
10
>>> c.__next__()
9
>>> c.close()
>>> c.__next__()
StopIteration
41

생성기와yield
생성기 함수안에서는yield문에서GeneratorExit 예외가 발생하는것으로
외부에서close() 함수호출한것을알수있음
... print("Counting down from %d" % n)
... try:
... while n > 0:
... yield n
... n -= 1
... except GeneratorExit:
... print("Only made it to %d" % n)
...
>>> c.__next__()
10
>>> c.__next__()
9
>>> c.close()
Only made it to 9
42

코루틴과 yield표현식
함수안에서yield문을대입연산자오른쪽에두고 값을받아오도록하는것이
가능
>>> def receiver():
... print("Ready to receive")
... while True:
... n = yield
... print("Got %s" % n)
...
위의코드처럼yield를사용하는함수를코루틴(coroutine) 이라고 함
함수외부에서보내준값에답하여실행
동작방식은생성기와매우유사
43

>>> r = receiver()
>>> r.__next__() # Python 2 에서는 r.next()
Ready to receive
>>> r.send(1)
Got 1
>>> r.send(2)
Got 2
>>> r.send("Hello, World!")
Got Hello, World!
44

1. 제일처음__next()__ 호출을통해코루틴첫번째yield표현식까지실행
2. yield문을만나면실행을중단하고 연관된생성기 객체r 의
send() 메서드를통해값이보내지기를기다림
3. send() 를통해전달된값은코루틴안의yield표현식에의해반환
4. 값을받아코루틴은다음yield문까지실행
45

코루틴에대해서__next()__ (Python2: next())를먼저호출해야한다는점을
잊는실수를방지하기 위해장식자로코루틴을감싸는방법을권장
>>> def coroutine(func):
... def start(*args, **kwargs):
... g = func(*args, **kwargs)
... g.__next__()
... return g
... return start
...
46

앞에서만든장식자를이용해코루틴작성및실행
>>> @coroutine
... def receiver():
... while True:
... n = yield
...
>>> r = receiver()
Ready to receive
Got Hello, World!
>>> r.send(1)
Got 1
47

코루틴은직접종료시키거나스스로종료하는경우가 아니라면보통계속실행
입력값 스트림을닫기 위해서는close() 메서드호출
>>> r.send(1)
Got 1
>>> r.close()
>>> r.send(2)
StopIteration
코루틴이닫히면코루틴에추가 값을보낼경우
StopIteration예외발생
48

코루틴생성기 객체에close() 를호출하면코루틴안에서는
GeneratorExit 예외발생
>>> @coroutine
... def receiver():
... try:
... while True:
... n = yield
... except GeneratorExit:
... print("Receiver done")
...
>>> r = receiver()
Ready to receive
Got Hello, World!
>>> r.close()
Receiver done
49

yield표현식에값을줄경우코루틴은값을받는동시에반환하는것이가능
>>> @coroutine
... def line_splitter(delimiter=None):
... print("Ready to split")
... result = None
... while True:
... line = yield result
... result = line.split(delimiter)
...
앞서사용한것과 같은방식으로코루틴을호출해사용
50

코루틴에send() 를통해값을넘기고 결과 값을받는것이가능
>>> s = line_splitter(",")
Ready to split
>>> s.send("A,B,C")
['A', 'B', 'C']
>>> s.send("100,200,300")
['100', '200', '300']
1. 첫번째__next()__ 호출을하면코루틴이yieldresult 까지진행
이때result 기본값인None을반환
2. 이어지는send() 호출에서는받은값을line에저장하고
분할해서result 에저장
3. send() 의반환값은send() 에전달된값을받는역할을수행한
yield표현식이아닌그 다음yield표현식의값
51

생성기와코루틴사용
생성기와코루틴은시스템, 네트워크, 분산처리시스템등특정한종류의
프로그래밍을수행할때대단히효과적으로사용가능
예를들어생성기 함수는유닉스셸에서파이프를사용하는것과
유사한처리파이프라인을만들고자할때유용하게 사용할수있음
코루틴은데이터흐름에따라처리하는프로그램을작성할때
효율적으로사용가능
52

import os
import fnmatch
def find_files(topdir, pattern):
for path, dirname, filelist in os.walk(topdir):
for name in filelist:
if fnmatch.fnmatch(name, pattern):
yield os.path.join(path, name)
def opener(filenames):
for name in filenames:
f = open(name)
yield f
def cat(filelist):
for f in filelist:
for line in f:
yield line
def grep(pattern, lines):
for line in lines:
if pattern in line:
yield line
53

생성기를이용한함수를조합해처리파이프라인생성예제
>>> py_files = find_files(".", "*.py")
>>> files = opener(py_files)
>>> lines = cat(files)
>>> print_lines = grep("print", lines)
>>> for line in print_lines
...
print('Wrote setup.py')
...
print(HELP_TEXT)
....
print('aborted!')
....
54

1. 현재디렉토리부터시작해하위디렉토리안에있는"*.py" 파일탐색
2. 발견한파일을열어파일객체생성
3. 파일에서모든줄을가져와부분문자열을찾는필터에전달
4. 필터에서는"print" 문자열을검색해전달
5. 마지막for 문에의해모든전체과정이실제로진행
6. for 루프는각 반복마다파이프라인을통해새로운값을가져와소비
이러한구현방식은임시리스트나기타대규모자료구조를생성하지않고
모든처리를진행하므로메모리사용측면에서매우효율적
55

@coroutine
def find_files(target):
while True:
topdir, pattern = yield
for path, dirname, filelist in os.walk(topdir):
for name in filelist:
if fnmatch.fnmatch(name, pattern):
target.send(os.path.join(path, name))
@coroutine @coroutine
def opener(target): def cat(target):
while True: while True:
name = yield f = yield
f = open(name) for line in f:
target.send(f) target.send(line)
@coroutine @coroutine
def grep(pattern, target): def printer():
while True: while True:
line = yield line = yield
if pattern in line: sys.stdout.write(line)
target.send(line)
56

>>> finder = find_files(opener(cat(
grep("print", printer()))))
>>> finder.send((".", "*.py"))
...
print(sum_for_list([12, 15]))
...
1. 첫번째코루틴find_files() 에데이터를밀어넣으면서시작
2. 각 코루틴은인수target 으로지정된다른코루틴으로데이터를전송
3. 필요할때마다send() 를호출해파이프라인사용
4. 파이프라인이close() 를직접호출하기 전까지는계속사용가능
데이터가 코루틴에전달되기 때문에프로그램구성요소사이에
통신을하기 위해서필요한메시지큐등의메시지전달기능을구현하기 편함
57

리스트내포
리스트각 아이템에함수를적용하고 그 결과로새로운리스트를
생성하는연산을자주사용함
>>> nums = [1, 2, 3, 4, 5]
>>> squares = []
>>> for n in nums:
... squares.append(n * n)
...
>>> squares
[1, 4, 9, 16, 25]
이러한방식을이용한연산을매우자주하기 때문에
리스트내포(list comprehension)라고 부르는연산자로사용
58

리스트내포
리스트내포를이용한새로운리스트생성예
>>> nums = [1, 2, 3, 4, 5]
>>> squares = [n * n for n in nums]
>>> squares
[1, 4, 9, 16, 25]
59

리스트내포
리스트내포의일반적인문법
[표현식 for 항목1 in 반복가능객체1 if 조건1
for 항목2 in 반복가능객체2 if 조건2
...
for 항목n in 반복가능객체n if 조건n ]
이문법은대략다음코드로변환가능
s = []
for 항목1 in 반복가능객체1:
if 조건1:
for 항목2 in 반복가능객체2:
if 조건2:
...
for 항목n in 반복가능객체n:
if 조건n:
s.append(표현식)
60

리스트내포
>>> a = [-3, 5, 2, -7, 10, 4]
>>> b = 'abcd'
>>> c = [2 * i for i in a]
>>> c
[-6, 10, 4, -14, 20, 8]
>>> d = [i for i in a if i >= 0]
>>> d
[5, 2, 10, 4]
>>> e = [(x, y) for x in a
... for y in b
... if x > 0 ]
>>> e
[(5, 'a'), (5, 'b'), ... , (4, 'b'), (4, 'c'), (4, 'd')]
61

리스트내포
>>> f = [(1, 2), (3, 4), (5, 6)]
>>> g = [math.sqrt(x * x + y * y) for x, y in f]
>>> g
[2.23606797749979, 5.0, 7.810249675906654]
리스트내포안에서정의한반복변수유효범위
Python2 에서는리스트생성연산수행후에도남아있음
Python3 에서는내부변수로만사용됨
62

생성기 표현식
생성기 표현식(generator expression)은리스트내포와동일한계산수행
결과를반복적으로생성하는객체
문법은괄호사용
실제로리스트를생성하거나표현식을바로평가하지않음
반복을통해필요할때값을생성하는생성기 객체반환
생성기 표현식문법
(표현식 for 항목1 in 반복가능객체1 if 조건1
for 항목2 in 반복가능객체2 if 조건2
...
for 항목n in 반복가능객체n if 조건n )
63

생성기 표현식
>>> a = [1, 2, 3, 4]
>>> b = (i * i for i in a)
>>> b
<generator object <genexpr> at 0x10f235678>
>>> b.__next__()
1
>>> b.__next__()
4
>>> b.__next__()
9
생성기 표현식와리스트내포에대한연산결과는큰차이가 없지만,
특정응용프로그램상황에따라성능과 메모리효율을증가시킬수있음
64

생성기 표현식
파일에서줄을추출해공백을제거하고 주석을추출하는부분은
실제로전체파일을읽지않음
실제파일내용은for 루프에서반복을시작할때줄단위로읽어
사용할뿐전체파일내용을메모리에올리는일은없음
>>> f = open('python_sample.py')
>>> lines = (t.strip() for t in f)
>>> comments = (t for t in lines if len(t) > 0 and t[0] ==
>>> for c in comments:
... print(c)
...
# db.app = flask_app
# db.init_app(flask_app)
# db.create_all()
...
65

선언형프로그래밍
데이터에대해직접반복을수행하는프로그램을작성하는대신에,
모든데이터에한번에적용되는계산으로프로그램을구조화
예를들어다음파일을읽어서두번째열과 세번째열을곱하고
전부더하는계산프로그램을작성할경우
AA 100 32.20
IBM 50 91.10
CAT 150 83.44
MSFT 200 51.23
GE 95 40.37
66

선언형프로그래밍
파일을읽어한줄씩반복하는프로그래밍적요소에대해서는신경 쓰지않고
모든데이터를어떻게 계산할지에대한선언적인요소만고민하여코드작성
>>> lines = open("portfolio.txt")
>>> fields = (line.split() for line in lines)
>>> print(sum(float(f[1]) * float(f[2]) for f in fields))
34372.15
67

lambda연산자
lambda문을사용해표현식형태로된익명함수작성가능
lambda args : expression
args: 콤마로분리된인수목록
expression: 인수와관련된표현식
68

lambda연산자
lambda를이용한예
>>> a = lambda x, y: x + y
>>> r = a(2, 3)
>>> r
5
콜백함수로사용하는예
>>> names = ["Keith Athens", "Ilana Weidenbach",
... "Caron Tseng", "Thad Hamill"]
>>> names.sort(key=lambda n: n.lower())
>>> names
['Caron Tseng', 'Ilana Weidenbach', 'Keith Athens', 'Thad Hamil
69

재귀
재귀 함수는호출깊이제한을가지며기본값은1000
>>> import sys
>>> sys.getrecursionlimit()
1000
값을변경할수있지만운영체제에서설정된
스택크기 제한을넘는것은불가능
고리재귀(tail‑recursion) 최적화를수행하지않음
70

재귀
재귀를이용한factorial() 함수구현예
>>> def factorial(n):
... if n <= 1:
... return 1
... else:
... return n * factorial(n - 1)
...
>>> factorial(10)
3628800
71

문서화문자열
함수의첫번째문장은주로함수를설명하는문서화문자열인경우가 많음
문서화문자열은함수의__doc__ 속성에저장
IDE 에서이를활용해도움말표시
>>> def factorial(n):
... """Computes n factorial. For example:
... >>> factorial(6)
... 120
... >>>
... """
... if n <= 1:
... return 1
... else:
... return n * factorial(n - 1)
...
>>> factorial.__doc__
'Computes n factorial. For example:nn >>> factorial(6)n
72

문서화문자열
>>> help(factorial)
Help on function factorial in module __main__:
factorial(n)
Computes n factorial. For example:
>>> factorial(6)
120
>>>
(END)
73

문서화문자열
장식자를사용할경우에는장식자래퍼로인해문서화문자열을
제대로가져오지못하는문제점발생
>>> def wrap(func):
... def call(*args, **kwargs):
... return func(*args, **kwargs)
... return call
...
>>> @wrap
... def factorial(n):
... """Computes n factorial. For example:
... """
...
>>> help(factorial)
Help on function call in module __main__:
call(*args, **kwargs)
(END)
74

문서화문자열
장식자함수에서함수이름과 문서화문자열을가져오도록구현하는것 필요
>>> def wrap(func):
... return func(*args, **kwargs)
... call.__doc__ = func.__doc__
... call.__name__ = func.__name__
... return call
...
>>> help(factorial)
>>>
Help on function factorial in module __main__:
factorial(*args, **kwargs)
Computes n factorial. For example:
>>> factorial(6)
120
>>>
(END)
75

문서화문자열
장식자함수에서함수이름과 문서화문자열을복사하는패턴이반복되므로
이를위해functools 모듈로wraps 함수제공
>>> from functools import wraps
>>> def wrap(func):
... @wraps(func)
... return call(*args, **kwargs)
... return call
76

함수속성
함수는그 자체가 임의의속성을가지는것이가능
함수속성은함수의__dict__ 속성을통해접근 가능
함수객체에추가 정보를저장하려는프레임워크등특수한경우에사용
>>> def foo():
... pass
...
>>> foo.secure = 1
>>> foo.private = 1
>>> foo.__dict__
{'secure': 1, 'private': 1}
77

eval(), exec(), compile()
eval(str [,globals [,locals]])
함수는표현식을담은문자열을실행하고 결과를반환
>>> a = eval("2 * math.pi * 8")
>>> a
50.26548245743669
exec(str [, globals [, locals]])
함수는임의의파이썬코드를담은문자열을실행
>>> a = [3, 5, 7, 9]
>>> exec("for i in a: print(i)")
3
5
7
9
78

eval(), exec() 두함수모두호출자의네임스페이스안에서코드를실행
함수에전역, 지역네임스페이스역할을하는매핑객체를넘겨 실행가능
>>> globals = {
... 'x': 37,
... 'y': 42,
... 'birds': ['Parrot', 'Swallow', 'Alabatross']
... }
>>> locals = {}
>>> a = eval("x + 2 * y", globals, locals)
>>> a
121
>>> exec("for i in birds: print(i)", globals, locals)
Parrot
Swallow
Alabatross
79

문자열을eval(), exec() 함수로전달하면파서는바이트코드로컴파일
컴파일하는시간을줄이기 위해서미리생성해둔바이트코드를재사용
compile(str, filename, kind)
str: 컴파일할코드
filename: 문자열이정의된파일
kind: 컴파일될코드종류
single: 단일문장
exec: 여러문장
eval: 표현식
>>> c = compile("x + 2 * y", "", "eval")
>>> eval(c, globals, locals)
121
80

Python Programming: Function

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Python Programming: Function (20)

More from Chan Shik Lim (6)

Python Programming: Function