In [1]:
def myfn1():
    result=1+2
In [2]:
myfn1()
In [3]:
print(myfn1())
None

return 이 없으면 none 이 반환됨

In [4]:
def myfn2():
    return 10
In [5]:
myfn2()
Out[5]:
10

지역변수, 전역변수

전역변수는 가능하면 쓰지말자!!

위치에 기반한 함수

In [7]:
def fn_with_positional_argument(name,age):
    print("당신의 이름은 {}이며, 나이는 {}이다.".format(name,age))
In [8]:
fn_with_positional_argument("철수","23")
당신의 이름은 철수이며, 나이는 23이다.
In [9]:
fn_with_positional_argument("재인",2)
당신의 이름은 재인이며, 나이는 2이다.

인자의 이름에 기반한 함수

In [10]:
def fn_with_keyword_argument(name="",age=1):
     print("당신의 이름은 {}이며, 나이는 {}이다.".format(name,age))
In [12]:
fn_with_keyword_argument("재명",6)
당신의 이름은 재명이며, 나이는 6이다.

positional Argument로도 적용가능함!

In [13]:
fn_with_keyword_argument(age=5,name="준표")
당신의 이름은 준표이며, 나이는 5이다.
In [14]:
fn_with_keyword_argument(name="승민")
당신의 이름은 승민이며, 나이는 1이다.

함수 Packing

In [15]:
def fn_packing(*colors):
    print(colors)
    for i in colors:
        print(i)
In [16]:
fn_packing()
()
In [17]:
fn_packing('yellow','red')
('yellow', 'red')
yellow
red
In [18]:
fn_packing(('a','b'))
(('a', 'b'),)
('a', 'b')

함수뒤에 곧바로 튜플로 사용가능함 -> 인자의 개수를 설정하지 않고 바로 사용가능

In [21]:
def fn3(color1,color2,*other_colors):
    print(color1)
    print(color2)
    print(other_colors)
In [23]:
fn3("red","blue",'yellow','black')
red
blue
('yellow', 'black')

Unpacking - 넣을때 리스트나 튜플에 *로 표시하여 나누어 넣는것처럼 인식

In [24]:
color=['red','blue','white','black','white']
In [25]:
fn_packing(*color)
('red', 'blue', 'white', 'black', 'white')
red
blue
white
black
white
In [27]:
fn_packing('purple',*color)
('purple', 'red', 'blue', 'white', 'black', 'white')
purple
red
blue
white
black
white
In [28]:
fn3('purple',*color)
purple
red
('blue', 'white', 'black', 'white')
In [29]:
fn3('purple',*('red','blue','yellow'))
purple
red
('blue', 'yellow')
In [31]:
fn3('purple',*['black','white','red'])
purple
black
('white', 'red')

위에서 보듯 리스트나 튜플을 모두 튜플 형식으로 바꿔버림

가변인자의 경우 *를 반드시 써주는게 나중에 가독성을 위해서도 좋음

keyword_argument 의 경우에도 가변인자를 생각할 수 있음(**arg)

단, 다수의 keyword_argument 를 사전으로 받음.

In [32]:
def ke_ar(**scores):
    print(scores)
In [33]:
ke_ar(name="명박",age="23")
{'name': '명박', 'age': '23'}
In [36]:
def ke_ar3(apple=0,**scores):
    print(apple)
    print(scores)
    for key,value in scores.items():
        print(key,value)
In [37]:
ke_ar3(apple=4,orange=7,banana=10)
4
{'orange': 7, 'banana': 10}
orange 7
banana 10
In [38]:
ke_ar3(orange=5,water=100)
0
{'orange': 5, 'water': 100}
orange 5
water 100

클래스 상속에서 부모의 멤버함수를 재정의할 때 좋음

In [39]:
class People(object):
    def say_hello(self,name,age,region1=None,region2=None):
        pass
In [40]:
class Developer(People):
    def say_hello(self,*args,**kwargs): #받은 그대로
        super().say_hello(*args,**kwargs) #부모에게 패스
        print("부모의 인자구성은 모르겠고, 나는 받은 그대로 부모에게 줬다.")
In [41]:
ab=Developer()
In [43]:
ab.say_hello
Out[43]:
<bound method Developer.say_hello of <__main__.Developer object at 0x10ce36438>>
In [45]:
ab.say_hello(name="연습",age=3)
부모의 인자구성은 모르겠고, 나는 받은 그대로 부모에게 줬다.

인자를 구성할 때, 사전을 unpacking하여 넘길 수 있다.

In [46]:
colors=['red','blue','white']
In [47]:
scores={'apple':10,'orange':4}
In [48]:
fn_packing(*colors)
('red', 'blue', 'white')
red
blue
white
In [49]:
ke_ar3(**scores)
10
{'orange': 4}
orange 4

익명함수

In [50]:
(lambda x,y : x+y)(1,2)
Out[50]:
3

마지막값을 리턴값으로 함

In [51]:
mysum2=lambda x,y : x*y
In [52]:
mysum2(2,4)
Out[52]:
8
In [53]:
 mysum3=lambda *args:sum(args)
In [54]:
mysum3(1,2,3,4,5)
Out[54]:
15
In [55]:
mynumber=[1,2,3,4,5]
In [56]:
mysum3(*mynumber)
Out[56]:
15
In [57]:
mysum3(mynumber)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-57-b55c9d78707d> in <module>()
----> 1 mysum3(mynumber)

<ipython-input-53-6e6ff1b8d1f8> in <lambda>(*args)
----> 1 mysum3=lambda *args:sum(args)

TypeError: unsupported operand type(s) for +: 'int' and 'list'

1급함수 지원!!

In [58]:
 mysum4=lambda x,y : x+y
In [59]:
mysum5= mysum4
In [60]:
mysum5(3,4)
Out[60]:
7
In [63]:
def myfn(fn,x,y):
    return fn(x,y)
In [64]:
myfn(mysum5,5,7)
Out[64]:
12
In [65]:
myfn(lambda x,y :x*y, 2,3)
Out[65]:
6

askDjango EP6,함수편