PYTHON 함수이해하기VERSION 2.X

Moon Yong Joon

함수정의Moon Yong Joon

Function 정의

함수란 반복적인 파이썬 문장을 하나의 기능으로 묶고 반복해서 사용할 수 있는 하나의 기능 묶음을 만드는 것

함수입력( 파라미터 )

출력Return 결과

함수 정의함수는 키워드 (def) 와 함수명을 정의하고 입력을 파라미터를 제공해서 내부 기능을 처리하고 출력을 제공

함수 선언 키워드 (def) 함수명 파라미터 (‘( 인자명 ,)’)( 블럭구분자 (‘:’)문장문장함수처리결과 (‘return/yield’) [ 표현식 ]

함수 실행함수 정의된 것을 함수명과 함수 파라미터를 주고 실행함

함수명 ( 파라미터값 , 파라미터값 , ……)

함수 처리 예시함수명 : add파라미터 : x,y결과 : x+y

def add(x,y) : return x+y입력

( 파라미터 )x=5, y=5

출력Return 결과

x+y: 10add(5,5)

Function 구조

함수 구조 함수가 정의되면 바로 함수를 객체로 구조화

함수 코드 함수인자함수 명 참조

def add(x,y) : return x+y

add def add(x,y) : return x+y

{‘x’ : None, ‘y’:None}내부주소

전환

함수 내부 구조 조회 함수는 객체이므로 함수의 내부 구조를 속성으로 구성한 function type 과 code type 이 존재

function type 내부 속성

code type func_code.func_code 일 경우 : code type

함수명

.함수명

내부 속성.

function type함수 내부의 정보 조회

Attribute Description

__doc__ doc 에 대한 정보 조회__name__ 정의된 함수의 이름func_code byte code 형태 code 로 세분화

func_defaults arguments 내의 defult 조회func_doc __doc__ 동일

func_globals 정의된 함수의 글로벌 영역func_name __name__ 과 동일

function type : 예시Function type 에 대한 내부 예시

>>> def add(x,y) : … return x+y

>>>add.func_code <code object add at 10552E30, file "<ipython-input-105-308d5e309ac4>", line 1>

>>> add.func_name 'add'

Code type 실제 code 에 대한 조회

Attribute Descriptionco_argcount number of arguments (not including * or ** args)

co_code string of raw compiled bytecode

co_consts tuple of constants used in the bytecod

co_filename name of file in which this code object was created

co_firstlineno number of first line in Python source code

co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg

co_lnotab encoded mapping of line numbers to bytecode indicesco_name name with which this code object was definedco_names tuple of names of local variablesco_nlocals number of local variables

co_stacksize virtual machine stack space requiredco_varnames tuple of names of arguments and local variables

Code type : 예시func_code 가 code type 을 생성하므로 그 내부의 정보를 조회

>>> def add(x,y) :... return x+y... >>> # 함수정의에 대한 내부 구조>>> add.func_code.co_varnames('x', 'y')>>> >>> # 함수코드는 bytecode 로 나타남>>> add.func_code.co_code'|\x00\x00|\x01\x00\x17S'>>>

inspect 모듈 : 함수 구조 조회 Inspect 모듈을 이용한 함수 구조 조회

function Description

inspect.getdoc(object) object 내부의 doc 을 출력inspect.getsourcefile(object) object 에 대한 소스파일 ( 모듈이름 0 을 출력inspect.getmodule(object) object 에 대한 모듈 이름을 출력inspect.getsource(object) object 내부의 소스를 출력

inspect.getsourcelines(object) object 내부의 소스를 라인별로 분리해서 출력inspect.getargspec(func) 함수의 argument 에 대한 정보 출력

inspect.getcallargs(func[, *args][, **kwds]) 함수 실행을 정의할 경우 실제 argument 연결 정보를 출력

inspect 모듈 : 조회 예시Inspect 모듈을 이용해서 함수에 대한 정보 조회

def sum(x,y) : return x+y

print(" function sum variable ") print("tuple of names of arguments and local variables")print(sum.func_code.co_varnames)print("dict of names of arguments ")print(inspect.getcallargs(sum,5,5))print(" function sum code ") print(sum.func_code.co_code)print(inspect.getsource(sum))print(inspect.getsourcefile(sum))

# 처리결과function sum variable tuple of names of arguments and local variables('x', 'y')dict of names of arguments {'y': 5, 'x': 5} function sum code |def sum(x,y) : return x+y

C:/myPython/ispect/inspect_sor_test.py

Function 와 메소드 구분하기

함수 와 메소드 구별 파이썬은 메소드는 일반 함수와 차이점은 첫번째 인자가 context 를 받아야 한다 . 함수를 정의 후 클래스의 정의에 메소드로 할당해서 사용가능함

self : 인스턴스 메소드cls: 클래스 메소드

class Foo() : def __init__(self,name=None) : self.name = name bar = external_bar

def external_bar(self,lastname): self.lastname = lastname return self.name+ " " + self-.lastname

내부 인스턴스 메소드로 사용할 함수를 외부에 정의 함수로 인식클래스에서 외부함수를 메소드로 정의 인스턴스 메소드로 인식

Function 생성

함수 – 메모리 생성 규칙 함수 호출 시 마다 Stack 에 함수 영역을 구성하고 실행됨 함수를 재귀호출할 경우 각 호출된 함수 별로 stack영역을 구성하고 처리

함수정의함수호출 1

함수호출 2

함수호출 3

함수호출 4

Stack

제일 마지막 호출된 것을 처리가 끝나면 그 전 호출한 함수를 처리load

함수 – 메모리 생성 예시 정의된 함수에서 실제 함수를 실행시 함수 인스턴스를 만들어서 실행됨

funcs = []for i in range(4): def f(): print I

# 함수 인스턴스를 추가 funcs.append(f)

print funcs

i =0for f in funcs: i += 1 print id(f), f()

[<function f at 0x02C1CF30>, <function f at 0x02C29EF0>, <function f at 0x02C29FB0>, <function f at 0x02C37370>]

46255920 1None46309104 2None46309296 3None46363504 4None

함수 생성된 개수만큼 생성됨

레퍼런스를 정수로 변환처리

Function scope

함수 변수 Scoping함수에 실행하면 함수 내의 변수에 대한 검색을 처리 .검색 순은 Local > global > Built-in 순으로 호출Global/nonlocal 키워드를 변수에 정의해서 직접 상위 영역을 직접 참조할 수 있다

globalBuilt-in

함수 Scope

함수 Namespace

local 내부함수local

함수 -scope 관리 기준 함수내의 인자를 함수 이름공간으로 관리하므로 하나의 dictionary 로 관리 함수 인자는 이름공간에 하나의 키 / 값 체계로 관리 함수의 인자나 함수내의 로컬변수는 동일한 이름공간에서 관리 locals() 함수로 함수 내의 이름공간을 확인할 수 있음#

지역변수와 전역변수동적 데이터 타입 : 변수에 값이 할당될 경우 데이터 타입이 확정됨변수는 이름공간 내에서 관리되면 변수는 동적으로 할당이 가능하다 .변수 검색 기준은 Local > Global > Built-in 영역 순으로 찾는다Locals() 와 globals() 함수를 이용해서 검색

>>> p = 100>>> >>> def add(x,y) :… p =0… print(locals())>>> globals()>>>

함수내 파라미터와 그 내부에 정의된 변수

함수 외부 변수는 전역변수

locals()/globals() 함수의 이름공간 locals() 함수를 이용하여 확인하기함수명 .__globals__ 나 globals() 함수를 호출하여 글로벌 context 내의 이름공간을 확인

>>> def add(x,y) :... p="local variable"... print locals()... return x+ y... >>> >>> add(1,2){'y': 2, 'p': 'local variable', 'x': 1}3

>>> add.__globals__>>> globals()

함수별로 자신의 이름공간을 관리 (dict())

함수 외부 환경에 대한 변수들을 관리하는 이름공간

함수 내에서 global 변수 갱신함수의 내부에서 정의없이 변수를 처리할 경우 오류가 발생하므로 이를 확인하여 global 키워드를 이용해서 처리되어야 함

def f(x,y) : z = x+y+z return z

f(5,5)

#z 변수가 로컬에 정의되어 있지 않아 오래 처리UnboundLocalError: local variable 'z' refer-enced before assignment

z = 10

def f(x,y) : global z z = x + y + z return z

f(5,5)

#z 변수를 global 로 정의해서 처리20

Global 변수를 인자로 처리함수의 인자를 함수 외부와 내부에서 동시에 활용하려면 mutable( 변경가능 ) 한 객체로 전달처리

함수를 정의 변수에는 참조만 가지고 있으므로 전체를 카피해야 리스트 원소들이 변경됨

Mutable 인 리스트로 값을 전달하여 swap() 처리 Return 이 없어도 실제 값이 변경됨

# 함수정의def swap(a,b) : x = a[:] a[:] = b[:] b[:] = x[:]

# 함수 실행a = [1]b = [2]print(swap(a,b))print(a,b) //[2] ,[1]

Function 결과

함수 결과 처리 -None함수 처리한 후 Return 문을 사용하지 않음

• 파이썬은 처리결과 없을 때 None 을 보냄

함수 결과 처리 -return 함수 결과는 하나의 결과만 전달

• 여러 개를 전달 할 경우 Tuple 로 묶어서 하나로 처리한다 .

함수 결과 처리 -yieldreturn 를 yield 로 대체할 경우는 Generator 가 발생

• 함수가 메모리에 있다가 재호출 (next()) 하면 결과값을 처리

Function Parameter

함수 -Namespace : 인자관리 파이썬은 함수 인자와 함수 내의 로컬 변수를 동일하게 관리 .함수 인자와 함수 내의 로컬변수명이 같은 경우 동일한 것으로 처리

# 함수 정의def add(x, y) : return x+y

# 함수 실행 add(1,2) # 3 을 return

Add 함수 내의 로컬 영역에 인자를 관리하는 사전이 생기고 {‘x’: None, ‘y’:None}

Add 함수 내의 로컬 영역에 인자에 매핑 {‘x’: 1, ‘y’: 2}

함수 인자 – mutable/immutable 함수가 실행시 함수 실행을 위한 프레임을 하나를 가지고 실행 반복적으로 함수를 호출 시 인자의 값이 참조 객체일 경우는 지속적으로 연결 인자에 참조형을 기본 인자로 사용하면 원하지 않는 결과가 생기므로 None으로 처리한 후 함수 내부에 참조형을 추가 정의해야 함

def f(a, l=[]) : l.append(a) return l

f(1)f(2)f(3)

함수정의

함수실행

{ ‘a’:1, ‘l’ :[1]}

함수 내부이름공간

{ ‘a’:2, ‘l’ :[1,2]}

{ ‘a’:2, ‘l’ :[1,2,3]}

f(1) 실행f(2) 실행f(3) 실행

실제 List 객체

참조객체를 함수 인자에 초기값으로 받을 경우 함수 호출시에 연결된게 남아있는다 .

def f(a, l=None) : l = [] l.append(a) return l

함수정의

인자에 변경가능한 값을 할당하지 않음

함수 인자 - 인자 정의함수 정의시 인자에 대한 변수 정의

# 함수정의add 함수 내의 로컬 영역에 인자를 관리하는 사전이 생기고 {‘x’: None , ‘y’:None}

# 함수 실행add 함수 내의 로컬 영역에 인자에 매핑 {‘x’: 1, ‘y’: 20}

# 함수 정의def add(x, y) : return x+y

# 함수 실행 add(1,20)

함수 인자 - 초기값 할당 함수 내의 인자를 별도의 이름공간에 관리하므로 고정인자일 경우에도 이름에 값을 할당 가능

add 함수 내의 로컬 영역에 인자를 관리하는 사전이 생기고 {‘x’: 10, ‘y’:None}

# 초기값을 무시하고 입력값을 사용add 함수 내의 로컬 영역에 인자에 매핑 {‘x’: 1, ‘y’: 20}

# 함수 정의def add(y, x=10) : return x+y

# 함수 실행 add(20,1)

# 함수 실행 add(y=20)

# 초기값과 입력값을 사용add 함수 내의 로컬 영역에 인자에 매핑 {‘x’: 10, ‘y’: 20}

함수 - 가변인자 - 값 (*args) 함수 인자의 개수가 미정일 경우 사용

add 함수 내의 로컬 영역에 인자를 관리하는 사전이 생기고 {‘arg’: None}

add 함수 내의 로컬 영역에 인자에 튜플 값으로 매핑 {‘arg’: (1,2) }

# 함수 정의def add(*arg) : x =0 for y in arg : x=x+y return x

# 함수 실행 add(1,2) # 3 을 return

함수 - 가변인자 - 키 / 값 (**args) 함수 인자의 개수가 미정이고 인자 변수를 정의할 경우

add 함수 내의 로컬 영역에 인자를 관리하는 사전이 생기고 {‘arg’: None}

add 함수 내의 로컬 영역에 인자에 사전으로 매핑 {‘arg’: { ‘x’:1,’y’:2} }

# 함수 정의def add(**arg) : return arg[‘x’] + arg[‘y’]

# 함수 실행 add(x=1,y=2) # 3 을 return

함수 - 가변인자 통합*args, **kargs 를 통합하여 파라미터를 지정시 항상 *args 가 먼저 정의되고 **kargs 나 뒤에 정의되면 가변인자가 처리가 가능

# 함수 내부 로컬변수 관리기준{'sum': 0, 'kagrs': {'y': 1, 'x': 1}, 'args': (1,)}3

# 함수 처리결과3

# 함수정의def add_ar(*args, **kagrs) : sum = 0 print(locals()) for i in args : sum += i for k,v in kagrs.items(): sum += v return sum # 함수실행 print(add_ar(1,x=1,y=1))

가변인자 확인하기*args: 튜플타입으로 값만 가진 가변인자**kargs : 키 / 값인 dict 타입의 가변인자Inspect.getcallargs( 함수명 ,*args,**kagrs) 로 함수 로컬변수를 가져옴

import inspect

def func(*args,**kargs) : # 함수의 파라미터를 가져오기 print "locals() ", locals() func_args = inspect.getcallargs(func,*args,**kargs) print " func_args ", func_args print " inspect get call args ", inspect.getcallargs(func,*args,**kargs) func(1,2,3,x=1)

# 가변인자에 대한 처리locals() {'args': (1, 2, 3), 'kargs': {'x': 1}} func_args {'args': (1, 2, 3), 'kargs': {'x': 1}} inspect get call args {'args': (1, 2, 3), 'kargs': {'x': 1}}

가변인자 처리하기튜플과 맵처리는 sequence 이므로 여러 개를 처리해야 하므로 for 문을 이용해서 처리

import inspect

def func(*args,**kargs) : print "locals() ", locals() func_args = inspect.getcallargs(func,*args,**kargs) print " func_args ", func_args print " inspect get call args ", inspect.getcallargs(func,*args,**kargs) value = 0 for i in func_args['args'] : value += i items = func_args['kargs'] for k,v in items.items() : value += v return value print func(1,2,3,x=1)

# 가변인자에 대한 처리locals() {'args': (1, 2, 3), 'kargs': {'x': 1}} func_args {'args': (1, 2, 3), 'kargs': {'x': 1}} inspect get call args {'args': (1, 2, 3), 'kargs': {'x': 1}}

# 함수 처리결과7

First Class Object

First Class Object(1)일반적으로 First Class 의 조건을 다음과 같이 정의한다 . 변수 (variable) 에 담을 수 있다 인자 (parameter) 로 전달할 수 있다 반환값 (return value) 으로 전달할 수 있다 1급 객체 (first class object)

# 함수를 변수에 할당func = addprint func

# 함수를 함수의 인자로 전달def addplus(func,x,y) : return func(x,y) print addplus(add,5,5)

# 함수를 함수의 리턴 결과로 전달def addpass(func) : return func

print addpass(add)(5,5)

# 결과<function add at 0x041F7FB0>1010

First Class Object(2) 1 급 함수 (first class object)

런타임 (runtime) 생성이 가능 익명 (anonymous) 으로 생성이 가능

# 함수를 함수의 리턴 결과로 전달def addpass(func) : return func

print addpass(add)(5,5)

#lambda 함수를 이용하여 익명으로 # 사용하지만 함수가 객체이므로 처리가됨print addpass(lambda x,y: x+y)(5,5)

함수를 변수에 할당함수도 객체이므로 변수에 할당이 가능

함수 객체 함수인자객체함수명

( 참조주소 )

함수 정의변수

변수에 할당def swap(a,b) :x = a[:]a[:] = b[:]b[:] = x[:]

func_var = swap # 함수를 변수에 할당a = [1]b = [2]#print(swap(a,b))print(func_var(a,b))print(a,b)

변수는 참조를 저장하므로 함수의 참조도 변수에 저장되고 실행연산자( () ) 를 이용하여 처리 가능

함수를 파라미터로 전달함수도 하나의 객체이며 데이터 타입이므로 파라미터인자로 전달이 가능외부에 함수를 정의하고 실행함수에 파라미터로 전달 후 실행함수 내부에서 실행

# 파라미터 전달 함수 정의def greet(name): return "Hello " + name # 실행 함수 정의def call_func(func): other_name = “Dahl“ # 파라미터 전달된 함수 실행 return func(other_name)

# 함수 실행print call_func(greet)

함수 결과값을 함수로 전달함수 결과값을 함수정의된 참조를 전달해서 외부에서 전달받은 함수를 실행하여 처리

# 실행함수 정의def compose_greet_func(): # 내부함수 정의 def get_message(): return "Hello there!“ # 내부함수를 함수처리결과값으로 전달 return get_message

# 함수실행 : 결과값은 함수의 참조 전달# 함수를 변수에 할당greet = compose_greet_func()# 함수 실행 : 변수에 할당된 내부함수가 실행됨print greet()

함수 실행Moon Yong Joon

Function Call 방법

함수 반복 호출함수도 호출 방법에 따라 다양한 구현 및 처리가 가능

연속 ( 재귀 ) 호출

특정 시점 호출

부분 호출

함수를 인자값을 바꿔가면 처리가 완료 될때까지 연속해서 호출하여 처리함수를 구동시켜 필요한 시점에 호출하여 결과 처리 (iteration, generation)

함수를 인자별로 분리하여 호출하면서 연결해서 결과를 처리

함수 재귀호출함수 정의시 함수가 여러 번 호출될 것을 기준으로 로직을 작성해서 동일한 함수를 지속적으로 처리할 도록 호출

def factorial(n): print("factorial has been called with n = " + str(n)) if n == 1: return 1 else: result = n * factorial(n-1) print("intermediate result for ", n, " * factorial(" ,n-1, "): ",re-sult) return result

print(factorial(5))

자신의 함수를 계속 호출하면 stack 에 새로운 함수 영역이 생겨서 처리한다

함수 시점 호출 iteration sequence 객체 등을 반복해서 사용할 수 있도록 지원하는 객체처리 방식

>>> l= [1,2,3,4]>>> iter(l)<listiterator object at 0x06585090>>>> li = iter(l)>>> li.next()1>>> li.next()2>>> li.next()3>>> li.next()4>>> li.next()Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration>>>

함수 시점 호출 :Generation 함수를 호출해도 계속 저장 함수를 호출 처리가 종료되면 exception 발생

>>> v = (i for i in l)>>> v<generator object <genexpr> at 0x06521E90>>>> v.next()0>>> v.next()1>>> v.next()2>>> v.next()3>>> v.next()4>>> v.next()Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration>>>

>>> def returnfunc(x) :... for i in x :... yield i... >>> p = returnfunc([1,2,3])>>> p<generator object returnfunc at 0x06480918>>>> p.next()1>>> p.next()2>>> p.next()3>>> p.next()Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration>>>

Generation Expression Generation Function

함수 시점호출 : Generation 함수 Return 대신 Yield 대체 함수를 호출 (next()) 해도 계속 저장 함수를 호출 처리가 종료되면 exception 발생

>>> def list_c(l) :... for i in l :... yield i... >>> list_c(l)<generator object list_c at 0x06521A08>>>> v = list_c(l)>>> v.next()0>>> v.next()1>>> v.next()2>>> v.next()3>>> v.next()4>>> v.next()Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration>>>

함수부분호출 : Curry함수의 인자를 점진적으로 증가하면서 처리하는 법으로 외부함수에서 내부함수로 처리를 위임해서 점진적으로 실행하도록 처리하는 함수

def f(a): print "function class object ",id(f) def g(b, c, d, e): print(a, b, c, d, e) return g

print " function instance ", id(f(1))f1 = f(1)f1(2,3,4,5)

def f1(a): def g1(b): def h1(c, d, e): print(a, b, c, d, e) return h1 return g1

f1(1)(2)(3,4,5)

f1(1) 함수 실행하면 g1(2) 함수가 실행되고 h1 (3,4,5) 가 최종적으로 실행되여 결과는 (1,2,3,4,5) 출력

함수부분 호출 : partial파이썬에서는 partial 함수를 제공해서 함수를 분할하여 처리함

from functools import partialdef f2(a, b, c, d): print(a, b, c, d)

#<functools.partial object at 0x029CE210>

print partial(f2, 1, 2, 3)

g2 = partial(f2, 1, 2, 3)g2(4)

Partial 함수 객체를 생성하고 추가 인자를 받으면 처리(1,2,3,4) 출력

LAMBDA 함수VERSION 2.X

Moon Yong Joon

익명함수 정의

Lambda 함수Lambda 는 익명의 함수를 정의

Lambda 파라미터 : 표현식

Lambda 함수 구조Lambda 함수는 함수명이 존재하지 않지만 구조는 함수와 동일

함수 코드 함수인자함수명 미존재

( 참조주소 )

익명함수 정의변수 필요시 변수에 할당

익명함수 실행

Lambda 함수 실행Lambda 는 변수에 할당 및 즉시 실행으로 처리

변수명 = Lambda 파라미터 : 표현식변수명 ( 파라미터 )

(Lambda 파라미터 : 표현식 )( 파라미터 )

변수할당실행

즉시실행

Lambda 함수 실행 : 변수Lambda 는 변수에 할당한 후 변수에 실행연산자를 연결하여 실행

add = lambda x,y : x+yadd(5,5) # 결과값

10

Lambda 함수 실행 : 즉시 실행Lambda 함수와 () 실행연산자를 사용해서 즉시 실행

(lambda x,y : x+y )(5,5) # 결과값10

Lambda 함수 주의할 점Lambda 는 표현식에서 2 개의 리턴 값이 생기면 에러표현식에서 2 개 이상 결과를 나타내려면 tuple 처리해야 함

>>> x = lambda x,y : y,xTraceback (most recent call last): File "<stdin>", line 1, in <module>NameError: name 'x' is not defined>>>>>> x = lambda x,y : (y,x)>>> x(1,2)(2, 1)

내포함수 호출연계Moon Yong Joon

Nested Function

함수를 내부함수 정의함수는 사용하기 전에 정의해서 사용 .함수 내에 다시 함수를 정의하여 사용

# 외부 함수 정의def outer() : # 내부 함수정의 def inner() : pass

# 내부함수 실행 후 결과 전달 # 결과값은 아무것도 없음 return inner()

함수를 내부함수 처리 함수 내부에 함수를 정의하고 함수 내부에서 실행하여 처리

def greet(name): # 내부 함수 정의 def get_message(): return "Hello “ # 내부함수 실행 result = get_message()+name return result

# 외부함수 실행print greet("Dahl")

함수 내부에 기능이 필요한 경우 내부 함수를 정의하여 호출하여 처리

내외부 함수에 대한 변수 scope외부함수에 정의된 자유변수를 내부함수에서 활용하여 처리 가능단 , 내부함수에서 갱신할 경우 mutable 타입이 사용 해야 함

# 자유변수에 대한 스코핑def compose_greet_func(name): # 내부 함수 정의 # 외부 함수 자유변수 name 을 사용 def get_message(): return "Hello there "+name+"!“ # 내부함수를 함수 결과값으로 전달 return get_message# 함수실행greet = compose_greet_func(“Dahl")print greet()

Closure

함수 – Closure : context외부함수 내의 자유변수를 내부함수에서 사용하면 기존 외부함수도 내부함수가 종료시까지 같이 지속된다 .함수 단위의 variable scope 위반이지만 현재 함수형 언어에서는 함수 내의 변수를 공유하여 처리할 수 있도록 구성하여 처리할 수 있도록 구성이 가능하다 .

외부함수

내부함수

외부함수이름공간

내부함수이름공간

Closure context 구성

내부함수 변수 검색 순서는 내부함수 이름공간 -> 외부함수 이름공간

함수 – Closure : __closure__파이썬은 클로저 환경에 대해서도 별도의 객체로 제공하며 이 환경에 대해서도 접근이 가능함

def generate_power_func(n): out_v = 10.0 def nth_power(x): return x**n + out_v return nth_power

print clo.__closure__print clo.__closure__[0]print type(clo.__closure__[0])print clo.__closure__[0].cell_contentsprint type(clo.__closure__[1])print clo.__closure__[1].cell_contents

(<cell at 0x02940ED0: int object at 0x01DAABC4>, <cell at 0x02B6FEF0: float object at 0x02766600>)

<cell at 0x02940ED0: int object at 0x01DAABC4><type 'cell'>4<cell at 0x02B6FEF0: float object at 0x02766600>10.0

__closure__ 는 튜플로 구성되어 자유변수에 대해 객체로 구성됨

함수 – Closure : 자유변수 (1)외부함수 내의 자유변수를 내부함수에서 사용하면 기존 외부함수도 내부함수가 종료시까지 같이 지속된다 .

def generate_power_func(n): print "id(n): %X" % id(n) print ' outer ', locals() def nth_power(x): print ' inner ', locals() #return x**n v = x**n # n = v + n #UnboundLocalError: local variable 'n' referenced #before assignment return v print "id(nth_power): %X" % id(nth_power) return nth_power

clo = generate_power_func(4)print clo(5)

자유변수가 im-mutable 일 경우 내부함수에 생기지만 변경할 수 없으므로 에러처리

Locals() 함수를 이용하여 함수에서 관리하는 변수를 출력outer {'n': 4}inner {'x': 5, 'n': 4}

함수 – Closure : 자유변수 (2)변수는 Mutable 값과 Immutable 값이 binding 되면서 정의되므로 내부함수에서 외부함수의 변수 (immutable) 에 재할당 시 unboundlocalerror 발생시 해결 방안

내부함수에 키워드 nonlocal 를 변수에 사용 외부함수에 mutable 값을 할당한 변수를 사용 ( 리스트 , 사전으로 정의 )

외부함수Context

내부함수Context

Local Local

IntFloat string

Immutable 객체외부함수의 변수를 변경하려면 외부함수 context 에서 처리 되어야 함 함수의 인자 전달시 동일한 원칙이 발생

외부함수 호출연계Moon Yong Joon

Function Chaining

함수 연속 실행함수 chian 은 함수를 결과값으로 받고 실행연산자(parameter) 를 연속하면 함수들을 계속 실행함

def chain(obj) : return obj def cc(obj): print obj chain(cc)('str')

함수 1 실행 하고 함수2 실행# 결과값str

Function Decorator

Decorator 문법반드시 미리 정의된 함수명을 사용해야 하고 전달함수 이외의 함수파라미터가 있을 경우 함수 파라미터를 추가해야 함

@ 함수명 [( 함수파라미터 )]

Decorator 사용 기법 함수 Chain : 함수를 결과 값 처리 고차함수 클로저 functools 모듈의 wraps 함수 사용

Decorator : functools 사용이유 functools 모듈의 wraps 함수 사용을 할 경우 __doc__/__name__ 이 삭제되지 않고 함수의 것을 유지

Decorator 처리 흐름 Decorator 함수 내부에 내부함수를 정의해서 파라미터로 받은 함수를 wrapping 하여 리턴 처리하고 최종으로 전달함수를 실행 함수 Chain 처리 ( 버블링 )

함수 1 함수 2함수 3( 전달함수 )

함수 2( 함수3)

함수 3실행함수 1( 함수 2( 함수3))

@f1 @f2

Decorator 순서

함수 1( 함수 2( 함수 3))(전달변수 ) 함수호출 순서

Decorator 단순 예시 Decorator 는 함수의 실행을 전달함수만 정의해도 외부함수까지 같이 실행된 결과를 보여준다 .

def func_return(func) : return func

def x_print() : print(" x print ")

x = func_return(x_print)x()

def func_return(func) : return func

@func_returndef r_print() : print (" r print ")

r_print()

외부함수

전달함수함수 실행

Decorator : 단순 wrapping 예시 Decorator 되는 함수에 파라미터에 실행될 함수를 전달되고

내부함수인 wrapping 함수를 리턴 Wrapping 함수 내부에 전달함수를 실행하도록 정의 데코레이터와 전달함수 정의 전달함수를 실행하면 데코레이터 함수와 연계해서 실행 후 결과값 출력

def common_func(func) : def wrap_func() : return func() return wrap_func

@common_funcdef r_func() : print " r func "

데코레이터 함수 정의 전달 함수 및 데코레이션 정의 함수 할당 및 실행

r_func()

# 처리결과 r func

Decorator: 전달함수 ( 파라미터 ) Decorator 할 함수를 정의하여 기존 함수 처리말고 추가 처리할 부분을 정의 실제 실행할 함수 즉 전달함수를 정의 실행할 함수를 실행하면 decorator 함수까지 연계되어 처리됨

def outer_f(func) :

def inner_f(*arg, **kargs) : result = func(*arg, **kargs) print(' result ', result) return result return inner_f

@outer_fdef add_1(x,y): return x+y

데코레이터 함수 정의 전달 함수 및 데코레이션 정의 함수 할당 및 실행

# 데코레이터 호출 x = add_1(5,5)print(' decorator ', x)

# 함수 처리 순서v = outer_f(add)v(5,5)

Function decorator : 파라미터 데코레이터 함수에서 사용할 파라미터 전달 내부함수에 전달함수를 파라미터로 전달 ( 클로저 구성 ) wrapping 함수 정의 및 내부함수 파라미터 전달

def tags(tag_name): def tags_decorator(func): def func_wrapper(name): return "<{0}>{1}</{0}>".format(tag_name, func(name)) return func_wrapper return tags_decorator

@tags("p")def get_text(name): return "Hello "+name

# 함수 실행print get_text("Dahl")

Functools Modulefunctools.wraps(wrapped[, assigned][, up-dated]) 을 이용하여 데코레이션 처리

from functools import wrapsdef my_decorator(f): @wraps(f) def wrapper(*args, **kwds): print 'Calling decorated function' return f(*args, **kwds) return wrapper

@my_decoratordef example(): """Docstring""" print 'Called example function'

example()

1. Functool 를 import 처리2. @wraps( 전달함수 )3. Wrapper 로 함수에 파라미터 전달 4. 데코레이션 정의5. 전달함수 작성6. 전달함수 실행

Functools Module: 파라미터데코레이터 파라미터를 처리하기 위해 파라미터 처리하는 함수를 하나 더 처리

from functools import wrapsdef my_decorator0(x) : print x def my_decorator1(f): @wraps(f) def wrapper(*args, **kwds): print 'Calling decorated function' return f(*args, **kwds) return wrapper return my_decorator1

@my_decorator0('xxx')def example1(): """Docstring""" print 'Called example function' example1()

1. 데코레이터 파라미터 처리함수 정의 2. Functool 를 import 처리3. @wraps( 전달함수 )4. Wrapper 로 함수에 파라미터 전달 5. 데코레이션 정의6. 전달함수 작성7. 전달함수 실행

복수 Function decorator 순서실행 func 을 호출시 실행 순서는decorate1(decorate2(decorat3(func))) 로 자동으로 연결하여 처리됨

#decorate1 def decorate1 : pass#decorate2 def decorate2 : pass#decorate3 def decorate3 : pass

@decorate1@decorate2@decorate3def func : pass

복수 Function decorator 예시함수 호출 순서는 f1(f2(add))(5,5) 로 자동으로 연결하여 처리됨

#decorator 함수 1def f1(func) : def wrap_1(*args) : return func(*args) print " f1 call" return wrap_1

#decorator 함수 2 def f2(func) : def wrap_2(*args) : return func(*args) print "f2 call" return wrap_2

#decorator 처리 @f1@f2def add(x,y) : print " add call " return x +y print add(5,5)

# 함수연결 호출print f1(f2(add))(5,5)

#decorator 처리 결과f2 call f1 call add call 10# 함수 연결 처리결과f2 call f1 call add call 10

Decorator 함수 정의 함수 실행

함수로 클래스 생성Moon Yong Joon

사용자 정의 함수 사용

클래스 생성 함수 정의클래스와 메소드 함수를 정의

# 클래스에 등록할 메소드 정의def say_foo(self): print('foo')

# 클래스 생성 메소드 정의def class_with_method(func):

class klass: pass

# setattr(obj, name, value, /) # setattr(x, 'y', v) is equivalent to ``x.y = v'' setattr(klass, func.__name__, func)

return klass

클래스내의 속성을 등록 : Setattr( 클래스명 , 속성명 , 속성값 )

클래스 생성 함수 실행클래스 생성함수 파라미터에 메소드를 전달 한 후 실행

# 클래스 생성 Foo = class_with_method(say_foo)

print('Foo dict ', Foo.__dict__)

# 인스턴스 생성 및 메소드 호출foo = Foo()foo.say_foo()

# 클래스 __dict__ 출력 결과('Foo dict ', {'__module__': '__main__', 'say_foo': <function say_foo at 0x107071B0>, '__doc__': None})foo

#Foo.say_foo() 호출 처리 결과foo

Type 함수 사용 ( 변수 )

Type 함수 : 클래스 만들기 파이썬은 실제 리터럴 즉 값이 객체이므로 기본 객체의 구성을 이해해야

a =type('A',(object,),dict(a=1))

a.a # 1

Class A(object) : a = 1

과 동일한 표현

Type 함수 사용

클래스 생성 함수 정의클래스와 메소드 함수를 정의

# 생성자 및 세팅 메소드 추가def __init__(self, x=None): self._x = x

def set_x(self, value): self.x = value

#type 함수를 이용하여 클래스 정의SubClass = type('SubClass', (object,), { '__init__':__init__,'set_x': set_x})

Type( 클래스명 , 상속 ( 튜플 ),dict에 속성 추가 )

클래스 생성 함수 실행인스턴스를 생성해서 속성 세팅 실행

print(SubClass.__dict__)# 인스턴스 생성obj = SubClass()

# 속성세팅obj.set_x(42)

print( obj.x ) # Prints 42print (isinstance(obj, object) )

# 클래스 __dict__ 출력 결과{'set_x': <function set_x at 0x10577830>, '__module__': '__main__', '__dict__': <at-tribute '__dict__' of 'SubClass' objects>, '__weakref__': <attribute '__weakref__' of 'SubClass' objects>, '__doc__': None, '__init__': <function __init__ at 0x10707030>}

#obj.x 호출 처리 결과42#isinstance() 함수 처리결과True

Type 함수 사용 ( 상속 )

상속 클래스 정의 상속할 클래스 정의

# 상속될 클래스 정의class BaseClass(object) :

def __init__(self,x) : self.x = x

# 속성 ( 메소드 ) 정의def set_x(self, value): self.x = value

클래스 생성 실행클래스 생성 및 인스턴스 생성 후 실행

SubClass1 = type('SubClass', (BaseClass,), { 'set_x': set_x})

obj1 = SubClass1(5)

print(obj1.x)

obj1.set_x(50)

print(obj1.x)

# 처리결과#obj.x before5#obj.x after50

내장함수Moon Yong Joon

Built-in function list

2.X built-in Functions

Built-in Functions

abs() divmod() input() open() staticmethod()

all() enumerate() int() ord() str()

any() eval() isinstance() pow() sum()basestring() execfile() issubclass() print() super()

bin() file() iter() property() tuple()

bool() filter() len() range() type()bytearray() float() list() raw_input() unichr()callable() format() locals() reduce() unicode()

chr() frozenset() long() reload() vars()

classmethod() getattr() map() repr() xrange()cmp() globals() max() reversed() zip()

compile() hasattr() memoryview() round() __import__()

complex() hash() min() set()delattr() help() next() setattr()

dict() hex() object() slice()

dir() id() oct() sorted()

3.X built-in FunctionsBuilt-in Functions

abs() dict() help() min() setattr()

all() dir() hex() next() slice()

any() divmod() id() object() sorted()

ascii() enumerate() input() oct() staticmethod()

bin() eval() int() open() str()

bool() exec() isinstance() ord() sum()

bytearray() filter() issubclass() pow() super()

bytes() float() iter() print() tuple()

callable() format() len() property() type()

chr() frozenset() list() range() vars()

classmethod() getattr() locals() repr() zip()

compile() globals() map() reversed() __import__()

complex() hasattr() max() round()  

delattr() hash() memoryview() set()  

도움말 보기 함수

help 함수함수 , 클래스 , 메소드 등에 대한 내부 정보를 확인할 때 사용

>>>help(vars) vars(...) vars([object]) -> dictionary Without arguments, equivalent to locals(). With an argument, equivalent to object.__dict__.

내장 타입 생성 및 변환 함수

Type 처리 함수파라미터를 하나 받아 객체를 실행하면 타입전환 처리함

>>> int<type 'int'>>>> float<type 'float'>>>> str<type 'str'>>>> list<type 'list'>>>> dict<type 'dict'>>>> tuple<type 'tuple'>>>> set<type 'set'>>>> complex<type ‘complex’)

int() float() str() list() dict() tuple() set() complex()

타입처리 함수

함수 설명bytearray() 갱신가능한 문자열 처리 타입

bytes() Str 가 같은 처리

frozenset() 갱신불가한 set 처리

object() Object 타입을 생성하기

Type 함수 파이썬은 실제 리터럴 즉 값이 객체이므로 기본 객체의 구성을 이해해야

>>> type(1.1) <class ‘float'>>>> >>> type(17) <class 'int'>

값을 type() 함수를 이용해 데이터 타입을 확인

referencetypevalue

float 주소

1.1

referencetypevalue

int 주소

17

데이터 관리 방안 ( 예시 )

slice 함수 Slice(start,stop,step) 으로 인스턴스를 만들어서 squence 객체에 slice 에 사용

>>> odds = slice(1,None,2)>>> evens = slice(0,None,2)>>> r=range(10)>>> r[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> r[odds][1, 3, 5, 7, 9]>>> r[evens][0, 2, 4, 6, 8]

클래스 내부 정의 함수

Class MemberClass Object 는 클래스 메소드 , 정적메소드 , 클래스 내부 변수 등을 관리한다 .

class Class_Member : cls_var = 0 @classmethod def cls_method(cls) : cls.cls_var = 1 print("call cls_method ", cls.cls_var)

@staticmethod def sta_method() : cls_var = 100 print("call sta_method ", cls_var)

def ins_method(self) : self.ins_var = 1 print('call ins method ', self.ins_var)

c = Class_Member()c.ins_method()print(c.__dict__)

클래스 변수클래스 객체 메소드클래스 정적 메소드

# 처리결과('call cls_method ', 1)('call sta_method ', 100)#Class_Member 내부 관리 영역{'sta_method': <staticmethod object at 0x0215A650>, '__module__': '__main__', 'ins_method': <function ins_method at 0x029D2270>, 'cls_method': <classmethod object at 0x01D92070>, 'cls_var': 1, '__doc__': None}

인스턴스 메소드

Super() 함수 (2.x)Super( 클래스 , 서브클래스 또는 인스턴스 )Class 변수를 호출하였지만 mro() 순성 따라 A.bar 가 호출되어 처리됨

class A(object) : bar = 100 def foo(self) : pass class B(object) : bar = 0 class C(A,B) : xyz = 'abc' print " super function ", super(C,C())

print C.mro()print super(C,C()).__self__print super(C,C()).barprint super(B,B()).__self__print super(B,B()).__self__.bar

# 실행 결과super function <super: <class 'C'>, <C object>>[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>]<__main__.C object at 0x0F01BA10>100 A.bar 의 값<__main__.B object at 0x0F01B6B0>0 B.bar 의 값

Super() 함수의 binding(2.x)Super( 클래스 , 인스턴스 ). 메소드 () 은 클래스 .메소드 ( 인스턴스 ) 로 연결되는 구조이므로 파라미터가 빠지면 binding 이 되지 않는다 .

print super(C) # 실행 결과<super: <class 'C'>, NULL>

print super(C).fooFoo 는 인스턴스 함수이라서 binding 에러# 실행 결과AttributeError: 'super' object has no attribute 'foo'

Super() 을 이용한 접근 (2.x)Super( 클래스 , 인스턴스 ) 객체에 __get__ 메소드가 구현되어 있어 재상속 후에 처리시 에러없이 상위 클래스를 접근 가능

class A(object) : bar = 100 def foo(self) : pass class B(object) : bar = 0 class C(A,B) : xyz = 'abc‘

class D(C) : sup = super(C) print D().supprint D().sup.fooprint super(C,D()).fooprint D().sup.bar

# 실행 결과<super: <class 'C'>, <D object>><bound method D.foo of <__main__.D object at 0x0F01BF90>><bound method D.foo of <__main__.D object at 0x0F01BF90>>100

D().sup 일때 상위 클래스 C 와 하위 인스턴스 D() 가 있어 매핑되어 처리 가능D().sup.foo == Super(C,D()).foo 로 바인딩한 것과 같다

Super(C).__get__(D(), ‘foo’) 처럼 인식

Property 함수 - 객체 직접 정의 (1)

인스턴스 객체의 변수 접근을 메소드로 제약하기 위해서는 Property 객체로 인스턴스 객체의 변수를 Wrapping 해야 함property(fget=None, fset=None, fdel=None, doc=None)

class P:

def __init__(self,x): self.x = x def getx(self) : return self.x def setx(self, x) : self.x = x def delx(self) : del self.x

x = property(getx,setx,delx," property test ")

Getter, setter, deleter 메소드를 정의

인스턴스 객체의 변수명과 동일하게 Property 객체 생성 ( 내부에 _x 생김 )

Property 함수–객체 직접 정의 (2)

실제 인스턴스 객체의 변수에 접근하면 Property 객체의 메소드를 호출하여 처리되고 인스턴스 객체의 변수값이 변경됨

p1 = P(1001)print id(p1.x)print P.__dict__['x']print id(p1.__dict__['x'])print p1.xp1.x = -12print p1.xprint p1.__dict__

# 처리결과값44625868<property object at 0x02C1D4E0>446258681001-12{'x': -12}

Iterable 처리 함수

all()/ any() all(iterable) 함수는 iterable 내부에 연속적인 원소들을 모두 가지고 있을 경우 :TrueAny(iterable) 함수는 iterabe 내부에 연속적인 원소가 없어도 true 처리

i=[1,2,3]

all(i) # True

any(i) # True

j=[[],[],[]]

all(j) # False

any(i) # True

Iterable 처리 함수 – 시점 호출 sequence 객체 등을 반복해서 사용할 수 있도록 지원하는 객체처리 방식

>>> l= [1,2,3,4]>>> iter(l)<listiterator object at 0x06585090>>>> li = iter(l)>>> li.next()1>>> li.next()2>>> li.next()3>>> li.next()4>>> li.next()Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration>>>

Iterable 처리 함수 – range range( 첫번째 , 마지막번째 , 간격 ) 함수는 범위에 대해 리스트 객체로 리턴

range(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range(1,10) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

range(1,10,2) #[1, 3, 5, 7, 9]

인스턴스 / 클래스 점검 함수

issubclass/isinstance 함수

>>> issubclass(list,object)True>>> list.__bases__(<type 'object'>,)>>> issubclass(list, type)False>>>

issubclass() : __bases__ 기준으로 상속관계 isinstance() : __ class__ 기준으로 인스턴스 객체 관계

>>> isinstance(list, type)True>>> list.__class__<type 'type'>>>> >>> isinstance(list, object)True>>>

issubclass 처리 isinstance 처리

id/hash 함수

>>>id(b)275969936

>>>id(B)275931744

>>>hash(bb) 17292299

>>>cc = bb

>>>hash(cc)17292299

>>>hash(bb) == hash(cc)True

id() 는 객체에 대한 주소를 확인하는 함수hash() 는 객체에 대한 hash 값을 integer 로 표시

객체접근 함수

객체접근 함수내장함수를 이용하여 객체의 속성에 대한 접근

object.x getattr()object.x = value setattr()del(object.x) delattr()

함수 구조getattr(object, name[, default])setattr(object, name, value)delattr(object, name)hasattr(object, name) # 객체내의 속성 ( 변수나 메소드 )callable(object) # 메소드 및 함수 여부 점검

객체접근 함수 : 예시 1객체의 속성을 접근하고변경

class A(): def __init__(self, name,age) : self.name = name self.age = age a = A('dahl',50)

if hasattr(a,"name") : print getattr(a,"name") setattr(a,"name","Moon") print getattr(a,"name")else : pass

if hasattr(a,"age") : print getattr(a,"age")else : pass

# 처리결과값dahlMoon50

객체접근 함수 : 예시 2메소드 및 함수여부 확인 후 실행

class A(): def __init__(self, name,age) : self.name = name self.age = age def in_set(self,name,default) : self.__dict__[name] = default print self.__dict__[name]

a = A('dahl',50)

def add(x,y) : return x+y if callable(add) : add(5,6)else : pass

if callable(a.in_set) : a.in_set('age',20)else: pass

# 처리결과값dahlMoon5020

함수 변수 스코프

지역변수와 전역변수동적 데이터 타입 : 변수에 값이 할당될 경우 데이터 타입이 확정됨변수는 이름공간 내에서 관리되면 변수는 동적으로 할당이 가능하다 .변수 검색 기준은 Local > Global > Built-in 영역 순으로 찾는다Locals() 와 globals() 함수를 이용해서 검색

>>> p = 100>>> >>> def add(x,y) :… p =0… print(locals())>>> globals()>>>

함수내 파라미터와 그 내부에 정의된 변수

함수 외부 변수는 전역변수

Namespace

__import__ 함수Import 한 원 파일에 대한 위치를 확인

>>>__import__('inspect') <module 'inspect' from 'C:\Python27\lib\inspect.pyc'>

Vars() 함수Var(object) 를 넣으면 현재 관리되는 속성들을 표시

vars(...) vars([object]) -> dictionary Without arguments, equivalent to locals(). With an argument, equivalent to object.__dict__.

def add(x,y) : print(" vars : ",vars()) print(" locals : ", locals()) return x + y add(5,5)

vars : {'y': 5, 'x': 5} locals : {'y': 5, 'x': 5}

dir 함수클래스 , 모듈 등의 관리하는 내부 정보를 확인할 때 사용

>>>dir(B) ['__doc__', '__init__', '__module__', 'name']

정렬함수

Sequence 타입 정렬Sequence 객체에 대한 정렬 처리 (sorted, re-versed) 별도의 sequence 객체 생성

>>> for i in reversed(xrange(1,10,2)): ... print i ... 9 7 5 3 1

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana'] >>> for f in sorted(set(basket)): ... print f... apple banana orange pear

reversed() sorted()

직접 실행 함수들

Compile 함수String 으로 받은 결과을 compile 하여 eval()/exec() 함수로 처리

#compile(string, '', 'eval') 

>>> sl = "10 * 10">>> sll =compile(sl,'','eval')>>> eval(sll) 100

#compile(string, '', 'exec')

>>> sc = "print('Hello World')">>> scc = compile(sc,'','exec')>>> exec(scc)Hello World

eval : Expression 실행Eval 함수는 컴파일 및 표현식을 평가하고 실행 처리

>>> eval("1+2")3>>>

exec : Statement 실행Exec 함수는 컴파일하여 문장을 평가하고 실행하기

>>> exec('print "hello world"')hello world>>>

Run-time function 처리Exec 함수는 컴파일한 문장을 평가하고 실행하기

# 함수를 문자열에 정의code_str = '''def add(x=1,y=1) : """ add x, y """ print(" vars : ",vars()) print(" locals : ", locals())

return x + y a = add(5,5)print(a)''‘#컴파일 처리code_obj = compile(code_str, '<string>', 'exec')print(type(code_obj))# 실행exec(code_obj)

# 처리 결과<type 'code'> vars : {'y': 5, 'x': 5} locals : {'y': 5, 'x': 5}10

reload/execfile함수

함수 설명

reload()

reload(...) reload(module) -> module Reload the module. The module must have been successfully imported before.

reload(inspect_sor_test) : import inspect_sor_test 한 모듈을 reload

execfile()

execfile(...) execfile(filename[, globals[, locals]])

execfile(“xxxx.py”) : filenam 에 스트링으로 모듈명을 입력하여 실행

High Order Function

High Order Function 고차함수 (high order function) 는 2 가지 중에 하나를 수행

하나 이상의 함수를 파라미터로 받거나 , 함수를 리턴 결과로 보내는 함수

# 고차 함수 정의def addList8(list): return reduce(add8, list)# 일반함수 정의def add8(*arg): v = [] for i in arg: v = v +i return v

# 고차함수 실행print addList8([[1, 2, 3],[4, 5],[6],[]])

print reduce(add8, [[1, 2, 3],[4, 5],[6],[]])

# 결과값[1, 2, 3, 4, 5, 6][1, 2, 3, 4, 5, 6]

map 함수map(f, iterable) 은 함수 (f) 와 반복가능한 자료형(iterable) 을 입력으로 받아 입력 자료형의 각각의 요소가 함수 f 에 의해 수행된 결과를 묶어서 리턴하는 함수

# 파이썬 2 및 파이썬 3# 5 개 원소를 가진 리스트의 제곱하여 변환list(map(lambda x: x ** 2, range(5)))

# 결과값 : [0, 1, 4, 9, 16]

reduce 함수reduce(f, iterable) 은 함수 (f) 와 반복가능한 자료형(iterable) 을 입력으로 받아 입력 자료형의 각각의 요소가 함수 f 에 의해 수행된 결과를 리턴하는 함수

def addList7(list): return reduce(add, list) def add(*arg): x = 0 for i in arg : x = x + i return x print "addlist", addList7([1, 2, 3])

print "reduce ", reduce(add, [1, 2, 3])

# 결과값addlist 6reduce 6

filter 함수

# 파이썬 2 및 파이썬 3#10 개 원소중에 5 보다 작은 5 개만 추출 list(filter(lambda x: x < 5, range(10)))

# 결과값 : [0, 1, 2, 3, 4]

filter(f, iterable) 은 함수 (f) 와 반복가능한 자료형(iterable) 을 입력으로 받아 함수 f 에 의해 수행된 결과 즉 filter 된 결과를 리턴하는 함수

enumerate 함수Sequence 타입을 받아 index 와 value 를 처리하는 함수

>>> for i, v in enumerate(['tic', 'tac', 'toe']):... print i, v ... 0 tic1 tac 2 toe

enumerate()

zip 함수Sequence 2 개를 받아 쌍을 만들어주는 함수

>>> l1 = [1,2,3,4]>>> la = ['a','b','c','d']>>> for k,v in zip(l1,la) :... print k, v... 1 a2 b3 c4 d>>>

zip()

포맷 함수

Input/format/print 함수

>>>format("12345678","8.4s") # '1234’‘1234’>>>print(“Hello World “)Hello World>>>len([1,2,3,4]) 4>>> # >"Hello World"Hello World

Format/print/input 처리

a = input(">")print(a)

Input 으로 값을 받고 출력

Repr 함수개체의 표준적인 캐릭터 라인 표현을 처리

repr(...) repr(object) -> string For most object types, eval(repr(object)) == object.

>>> # str 처리시 다른 결과가 발생 . 객체를 str 로 처리하기 >>> repr('123')"'123'">>> str(123)'123‘

>>>repr(123) '123'>>> str(123)'123'

변환 함수

bin/oct/hex/ord/chr/unichar숫자를 base 로 변환하거나 문자를 변환

b=bin(10) # '0b1010int(b,2) # 10

o = oct(10) # '012'int(o,8) # 10

h = hex(10) # '0xa‘int(h,16) # 10

ord('1') # 49chr(49) # '1‘unichr(49) # u'1'

수학 관련 함수

수학 함수 수학관련 함수

함수 설명abs() 절대값cmp() cmp(x, y) -> integer

Return negative if x<y, zero if x==y, positive if x>y.

divmod() divmod(10,2) : Out[333]: (5, 0)divmod(11,2) : Out[334]: (5, 1)

max() 최대값 max([1,2,3,4]) : 4

min() 최소값 min([1,2,3,4]) : 1

pow() 제곱 구하기 pow(x, y[, z]) -> number : (x**y) % z

sum() 시퀀스의 합 구하기

File 처리 함수

파일 관리 함수 Open()/file() 은 파일을 오픈

함수 설명

file()

파일 생성 file('test.txt','w') <open file 'test.txt', mode 'w' at 0x107EDC80>파일 존재시 첨가 모드로 file('test.txt','a') <open file 'test.txt', mode 'a' at 0x107EDE90>

open() f = open(" 새파일 .txt", 'w') f.close()