#파이썬 기초 7일차_1

6일차에 람다 함수부터  이어서 진행

1. 람다 함수(Lambda Function)

런타임에 생성해서 사용할 수 있는 익명 함수

• 필요성
  • 상황에 따라 직접 정의해서 바로 사용하는 것이 필요할 때가 있음
  • 1회성으로 한 번 쓰고 버리는 용도로 많이 사용함
  • 변수에다 할당해서 하는 것이므로 메모리에 할당해 처리하는 다른 함수와 호출, 실행 시점이 조금 다르고 나머지는 거희 비슷하다.

• 사용 방식
  • 함수 정의문이 없으므로 lambda라는 키워드를 사용함
  • 하나의 라인에 정의할 수 있음
  • 콜론(:)을 경계로 앞에는 매개변수를 정의하고 뒤에는 표현식을 정의함
  • 표현식 대신 문장으로 표현하면 예외가 발생하므로(람다는 한줄로 처리하게 만들어진 것이기 때문) 반환값을 처리하는 return문이 필요없고 표현식을 실행한 결과가 자동으로 반환됨
  • 함수를 정의문으로 정의한 것과 내부적으로 거의 동일하게 처리됨

1.1 람다함수 정의하기

 

기본 함수

def add(x,y) :

    return x+y\

 

람다함수

add = lambda x,y : x+y

둘이 같은 식이다.

 

• 람다 함수도 function class 객체 여부 확인

lam = set(dir(lambda x,y : x+y))

print(type(lambda x,y : x+y))

obj = set(dir(object))

for i in (lam-obj) :

    print(i)

<class 'function'>
__module__
__closure__
__call__
__name__
__builtins__
__qualname__
__defaults__
__annotations__
__code__
__kwdefaults__
__get__
__dict__
__globals__

 

a = lambda x,y : x+y

print(a)

print(a.__name__)

print(a.__qualname__)

<function <lambda> at 0x7a0b3d8172e0>
<lambda>
<lambda>

a = lambda x=100,*,y=100 : x+y

print(a)

print(a.__annotations__)

print(a.__defaults__)

print(a.__kwdefaults__)

<function <lambda> at 0x7a0b0f9dc040>
{}
(100,)
{'y': 100}

 

• 람다 함수 표현식 부분에 함수 호출 처리
• 별도에 함수를 만들고 이를 람다식에서 호출해서 사용(람다 자체가 가지는 익명함수의 의미는 적어짐)
• 함수를 중간중간에 호출하기 어려울때 람다식을 사용해서 변수를 만들어 이를 호출해서 사용하면 유의미할 때가 있음

def add(x,y) :

    return x+y

a = lambda x,y : add(x,y)

print(a(50,10))

60

1.2 즉시 실행 함수(Immediately - invoked function express)

• lambda 정의하고 즉시 실행 처리

lambda x : x (1)  #1이 별다른 사용이 되지 않고 있음

<function __main__.<lambda>(x)>

(lambda x : x )(1)   #변수처럼 호출됨

1

• lambda 함수 재사용하기
  • lambda 함수는 한 번 쓰고 버리는 1회성으로 많이 사용함
  • 재사용하고자 할 경우
    • 이름없는 함수라서 네임스페이스에 할당되지 않으므로 다른 변수에 할당해서 재사용 할 수 있음
  • lambda 함수도 함수 클래스의 인스턴스이므로 객체의 인스턴스로 사용이 가능하며 객체 네임스페이스로 관리할 수도 있음(함수가 할당된 변수의 네임스페이스의 영향을 받는다는말)

add = lambda x,y : x+y

print(add) # add의 형태

print(add.__name__) # 이름 지정을 안해서 없다.

print(add.__call__(7,5)) #함수의 호출(내부의 __call__을 실행하는 방식으로 호출하는것, 실제 함수를 부르는것이 아님)

print(add(17,10))

<function <lambda> at 0x7a0b0f983520>
<lambda>
12
27

 

어디의 제어를 받는지에 대해 학습코드

add = lambda x,y : add.count

print(add)

add.count= 0

print(add.__dict__)

print(add(5,5))

add.count +=1

print(add.__dict__)

<function <lambda> at 0x7a0b0f983400>
{'count': 0}
0
{'count': 1}

 

1.3 지능형 리스트(List Comprehension)에서 람다 함수 사용하기

 

• 지능형 리스트 내의 익명함수 처리
  • 리스트를 작성할 때 람다함수가 원소로 만들어지도록 구성함

l = [ x  for x in range(3)]

print(l)

[0, 1, 2]

 

각각을 별개의 변수처럼 사용할 수 있다(각 결과들을 람다함수로 정의되게 만듬, 각 하나하나를 for문으로 가져올 수 있음)

람다함수 자체를 그대로 넣음

l = [ lambda  : x  for x in range(3)]

print(l)

[<function <listcomp>.<lambda> at 0x7a0b3c8fbac0>, <function <listcomp>.<lambda> at 0x7a0b3c8fb9a0>, <function <listcomp>.<lambda> at 0x7a0b0f983eb0>]

for i in l :

    print(i, i())

<function <listcomp>.<lambda> at 0x7a0b3c8fbac0> 2
<function <listcomp>.<lambda> at 0x7a0b3c8fb9a0> 2
<function <listcomp>.<lambda> at 0x7a0b0f983eb0> 2

 

람다함수를 실행해서 결과물을 리스트에 넣는것

l = [ (lambda  : x)()  for x in range(3)]

print(l)

[0, 1, 2]

 

람다함수 자체가 나오는데, 전달돼어온  x를 하나씩 받아들여서 값 자체가 반영됨

l = [ lambda  x=x : x  for x in range(3)]

for i in l :

    print(i, i())

<function <listcomp>.<lambda> at 0x7a0b0f982d40> 0
<function <listcomp>.<lambda> at 0x7a0b0f983640> 1
<function <listcomp>.<lambda> at 0x7a0b0f981ea0> 2

 

l = [ lambda  x=n : x  for n in range(3)]

for i in l :

    print(i, i())

<function <listcomp>.<lambda> at 0x7a0b0f9832e0> 0
<function <listcomp>.<lambda> at 0x7a0b0f981cf0> 1
<function <listcomp>.<lambda> at 0x7a0b0f982ef0> 2

2. 내부 함수(Nested Function)

 

• 내부 함수(Nested Function)
  • 함수 안에 정의해서 실행할 수 있는 함수 (일반적인 함수는 외부 함수(Outer Function))
  • 함수를 함수 내부에 정의해서 사용하므로 함수 간의 네임스페이스를 처리하는 스코프도 내부적으로 생성됨

 

2.1 내부 함수 정의하기

 

• 함수 내에 함수 정의 및 내부 실행처리
  • 외부 함수 내의 기능을 나누고 내부 함수로 정의해서 외부 함수의 보조 기능을 처리하는 방식

def math_func1(x,y,op) :

    def add_() :

        return x+y

    def sub_() :

        return x-y

    def mul_() :

        return x*y

    def div_() :

        return x/y

    op_func = {'+': add_, "-":sub_, "*":mul_, "/":div_}[op] # op는 키

    return op_func()

print(math_func1(7,5,'+'))

print(math_func1(9,5,'-'))

print(math_func1(4,5,'*'))

print(math_func1(10,5,'/'))

12
4
20
2.0

• 내부 함수 호출을 반환에서 사용하기

def math_func2(x,op) :

    def add_(y) :

        return x+y

    def sub_(y) :

        return x-y

    def mul_(y) :

        return x*y

    def div_(y) :

        return x/y

    op_func = {'+': add_, "-":sub_, "*":mul_, "/":div_}[op]

    return op_func

add = math_func2(5,'+')

print(add(10))

sub = math_func2(10,'-')

print(sub(5))

mul = math_func2(5,'*')

print(mul(3))

div = math_func2(20,'/')

print(div(5))

15

5

15

4.0

1.2 내부 함수가 외부로 전달된 환경 이해하기

 

• 외부함수의 반환값으로 내부 함수에 대한 정보 확인

def outer(x) :

    def inner(y) :

        return x+y

    return inner

inner1 = outer(5)

print(inner1)

<function outer.<locals>.inner at 0x7a0b0f983370>

print(inner1.__name__)

print(inner1(6))

inner

11

• 타 모듈의 함수를 내부 함수에 지정 (다른 곳에서 들고와서 쓸 수 있다)

outer_ 함수가 op_code에 해당하는 연산자 함수를 직접 반환 한다.

import operator as op

def outer_(op_code) :

    inner_ = {'+':op.add,

             '-':op.sub,

             '*':op.mul,

             '/':op.truediv}[op_code]

    return inner_

inner = outer_('/')

print(inner)

print(inner(10,5))

<built-in function truediv>

2.0

 

outer_ 함수가 두 숫자를 연산하는 내부 함수 inner_를 정의하고 반환 하며. 이 inner_ 함수는 실행 시에 매번 딕셔너리에서 연산자 함수를 선택하여 연산을 수행하는 것이다.

매번 연산자 함수를 선택하는 추가 단계가 있어서 다소 더 복잡하지만 연산자 함수를 직접 반환하는 코드와 기능적으로는 동일한 것이다.

import operator as op

def outer_(op_code) :

    def inner_(x,y) :

        return  {'+':op.add,

             '-':op.sub,

             '*':op.mul,

             '/':op.truediv}[op_code](x,y)

    return inner_

inner = outer_('/')

print(inner)

print(inner(10,5))

<function outer_.<locals>.inner_ at 0x7a0b0f9dc3a0>

2.0

• 내부 함수로 외부 함수의 매개변수 자료형 검증

def outer_check(type_code) :

    def type_check(a) :

        return isinstance(a,type_code)

    def inner_outer_check(x,y) :

        if not type_check(x) :

            x = type_code(x)

        if not type_check(y) :

            y = type_code(y)

        return x+y

    return inner_outer_check

inner = outer_check(int)

print(inner(1.1,2.2))

3  # 위 값을 인티저로 바꿔서, 반올림하지 않고 버림(대부분 남는 부분을 버림 처리한다)

inner = outer_check(float)

print(inner(1.3,2))

3.3 

 

스트링 상태로 바꾸니까 이어서 스트링으로 바뀌어서 나타남

inner = outer_check(str)

print(inner(1.1,2.2))

1.12.2

1.3 내부 함수 안에서 nonlocal 변수 사용하기

 

• 함수별 Namespace 생성 확인하기

import pprint

def outer_local(x,y) :

    def inner_local(a,b) :

        return locals()

 

    print("outer_local")

    pprint.pprint(locals())

   

    return inner_local

inner = outer_local(10,20)

 

print("inner_local")

print(inner(30,40))

outer_local
{'inner_local': <function outer_local.<locals>.inner_local at 0x7a0b0f9dde10>,
 'x': 10,
 'y': 20}
inner_local
{'a': 30, 'b': 40}

• 외부 함수 Namespace 사용하기

import pprint

def outer_local2(x) :

    def inner_local2(y) :

        nonlocal x # 로컬보다 상위의 것이라 접근 못할때, nonlocal써서 접근 가능하게 변경한것

        x = x + 1

        return x

    return inner_local2

inner = outer_local2(10)

print("inner_local2")

print(inner(40))

inner_local2

11

 

• 내부함수 내에 내부함수를 내포하기

def out_(x) :

    def inn_1(y) :

        def inn_2(z) :

            nonlocal y

            y = y+1

            return x+y+z

        return inn_2

    return inn_1

inn_1 = out_(10)

inn_2 = inn_1(20)

print(inn_2(30))

61

 

위 코드에서 nonlocal y를 주석처리하면 UnboundLocalError: local variable 'y' referenced before assignment 오류가 발생

 

위 오류가 발생하는 원인은 inn_2 함수 내부에서 y 변수를 수정하려고 할 때, 파이썬은 이를 함수의 지역 변수로 간주하기 때문입니다. 따라서 y 변수는 아직 할당되지 않은 상태로 간주되어 UnboundLocalError가 발생합니다.

이 문제를 해결하려면 nonlocal 키워드를 사용하여 y 변수가 inn_2 함수의 외부 범위(즉, inn_1 함수)의 변수임을 명시해야 합니다.

• nonlocal 키워드는 중첩 함수에서 상위 범위의 변수를 수정할 때 사용됩니다.

def out_(x):

    def inn_1(y):

        def inn_2(z):

            return x + (y + 1) + z

        return inn_2

    return inn_1

inn_1 = out_(10)

inn_2 = inn_1(20)

print(inn_2(30))

61

위와같이 return 쪽에서 묶으면 정상 동작을 하는데 이는

y 변수의 값을 inn_2 함수 내에서 직접 수정하지 않고, 대신 (y + 1)로 계산하여 반환하기 때문에 UnboundLocalError가 발생하지 않습니다. 수정된 코드의 의도는 y의 값을 직접 변경하지 않고, 단지 계산에 사용할 때 1을 더하는 것이기 때문에 그런 것이다.

전체 코드 흐름을 보면

 

• out_(10)을 호출하면 x가 10인 inn_1 함수를 반환합니다.
• inn_1(20)을 호출하면 y가 20인 inn_2 함수를 반환합니다.
• inn_2(30)을 호출하면 x는 10, y는 20, z는 30입니다. 따라서, x + (y + 1) + z는 10 + (20 + 1) + 30이 되어 61을 반환합니다.

이므로 출력이 61이 되는 것이다.

 

 

2. 파이썬 제공 내장 함수

2.1 계산 및 문자 변환 내장 함수

 

• Sequence 자료형 합 구하기 : sum

print(sum([1,2,3,4]))

print(sum([1,2,3,4],5))

10

15

l = [(1,2),(7,9),(3,4)]

l.sort(key=sum)

print(l)

[(1, 2), (3, 4), (7, 9)]

• 소수점 조정 및 몫과 나머지 구하기

round : 반올림

divmod : 나누기해서 나머지를 보는것

print(type(round))

print(type(divmod))

<class 'builtin_function_or_method'>

<class 'builtin_function_or_method'>

 

빌트인인것을 보면 파이썬 루트에서 작동되는 코드이다.

f = 100.123456789

print(round(f)) # 반올림해서 소수점 없이

print(round(f,3)) # 반올림해서 소수점 3자리

print(round(f,5))  # 반올림해서 소수점 5자리

100
100.123
100.12346

 

divmod(a, b) 함수:

• 이 함수는 두 숫자 a와 b를 인자로 받아서 (몫, 나머지)의 튜플을 반환

// 연산자 (정수 나눗셈):

• 이 연산자는 두 숫자 a와 b를 나누고 그 몫을 반환

% 연산자 (나머지 연산자):

• 이 연산자는 두 숫자 a와 b를 나누고 그 나머지를 반환

d = 100

n = 23

print(divmod(d,n))

print(d // n)

print(d % n)

(4, 8)
4
8

 

• 절대값, 제곱과 논리식 구하기
• abs는 절대값 나타내는 함수

print(type(abs))

print(abs(-100))

<class 'builtin_function_or_method'>

100

 

math제공 함수들

 

• pow는 제곱을 계산하는 함수
• pow(base, exp, mod) 형태로 사용 이는 (base ** exp) % mod를 계산한 것이다
• math.pow(10, 3)은 10을 3제곱하는 것이므로, 1000.0을 반환합니다. math.pow는 항상 부동 소수점 수를 반환한다
• pow(10, 1/2)은 10의 1/2제곱을 계산하는데, 이는 10의 제곱근을 의미
• math.sqrt는 math 모듈에 있는 함수로, 주어진 숫자의 제곱근을 계산

import math

print(type(pow))

print(pow(10,2))

print(pow(10,2,3)) # pow(10, 2, 3)는 10을 2제곱한 다음 3으로 나눈 나머지를 계산

print(math.pow(10,3))

print(pow(10,1/2))

print(math.sqrt(10)) # 10의 제곱근을 계산

<class 'builtin_function_or_method'>
100
1
1000.0
3.1622776601683795
3.1622776601683795

• 숫자를 문자로 문자를 숫자로 변환하기
• map() 함수의 역할은 각 문자열에 대해 문자 코드를 변환하거나 문자 코드를 문자로 다시 변환하는 것

s = "알아보고싶은파이썬"

l = list(map(ord,s))

print(l)

ls = "".join(list(map(chr,l)))

print(ls)

[50508, 50500, 48372, 44256, 49910, 51008, 54028, 51060, 50028] # 아스키코드값

알아보고싶은파이썬

s = "IwanttoknowPython "

l = list(map(ord,s))

print(l)

ls = "".join(list(map(chr,l)))

print(ls)

[73, 119, 97, 110, 116, 116, 111, 107, 110, 111, 119, 80, 121, 116, 104, 111, 110, 32]  # 아스키코드값

IwanttoknowPython

• 논리식의 결과로 처리하기

any, all 는 빌트인에 있는 함수

any() : 반복 가능한(iterable) 객체를 받아 그 객체의 어떤 요소라도 참(True)이면 True를 반환하고, 모든 요소가 거짓(False)일 때만 False를 반환

all() : 반복 가능한(iterable) 객체를 받아서, 객체의 모든 요소가 참(True)이면 True를 반환하고, 그렇지 않으면 False를 반환

print(type(any), type(all))

<class 'builtin_function_or_method'> <class 'builtin_function_or_method'>

print(any([]))

print(any([None]))

False

False

print(all([]))

print(all([None]))

True

False

print(any({'a':None})) #딕셔너리 들어간 것

print(any({}))

True
False

print(all({'a':None}))

print(all({}))

True

True

print(any(""))

print(all(""))

False

True

2.2 정렬 내장 함수 이해하기

• 정렬 함수 sorted

print(sorted)

l = ['abc', 'bc', 'a']

s = sorted(l)

print(s)

<built-in function sorted>
['a', 'abc', 'bc']

l = ['abc', 'bc', 'a']

s = sorted(l,reverse=True)

print(s)

['bc', 'abc', 'a']

l = ['abc', 'bc', 'a']

s = sorted(l,key=len)

print(s)

['a', 'bc', 'abc']

l = ['abc', 'bc', 'a']

l.sort()

print(l)

['a', 'abc', 'bc']

l = ['abc', 'bc', 'a']

l.sort(reverse=True)

print(l)

['bc', 'abc', 'a']

l = ['abc', 'bc', 'a']

l.sort(key=len)

print(l)

['a', 'bc', 'abc']

• 문자열을 바로 실행하기
• exec() 함수는 문자열로 제공된 코드를 실행, 따라서 s = "a_e = a_e + 100" 이 실행될 때 exec(s)를 호출하면 a_e 변수가 새로운 값으로 업데이트된다.
• exec() 함수는 전역 범위(global scope)에서 코드를 실행하므로, a_e 변수는 전역 범위에서 사용된다

s = "exec_a = '변수에 할당하기'"

exec(s)

print(globals()["exec_a"])

변수에 할당하기

s = "a_e = a_e + 100"

a_e = 100

exec(s)

print(globals()["a_e"])

200

s = """

def add_exec(x,y) :

    return x+y

"""

exec(s)

print(globals()["add_exec"])

print(globals()["add_exec"](10,10))

print(add_exec(20,20))

<function add_exec at 0x7a0b0f983e20>

20

40

 

파일 저장해서 불러와서 실행

%%writefile exec_add.py

s = """

def add_exec(x,y) :

    return x+y

"""

exec(s)

Writing exec_add.py

import exec_add

print(exec_add.add_exec(20,30))

50

• 컴파일에서 eval, exec 실행을 지정한 후에 나중에 실행하기
• 컴파일을 통해서 준비과정으로 만들어놓고, 이를 호출해서 시용

sc = """

class Person :

    def __init__(self,name) :

        self.name = name

    def getname(self) :

        return self.name

"""

ex = compile(sc,"fakefile",'exec')

• eval(ex)를 통해 컴파일된 코드를 실행, 이는 전역 범위에 Person 클래스를 정의
• p = Person("춘식이")는 위에서 정의된 Person 클래스를 사용하여 객체를 생성
• print(p.getname())은 생성된 객체 p의 getname() 메서드를 호출하여 이름을 출력

eval(ex)

p = Person("춘식이")

print(p.getname())

춘식이

• compile() 함수를 사용하여 표현식으로 컴파일
• fakefile은 컴파일된 코드의 파일명을 지정하는 것
• eval(ev)를 통해 컴파일된 표현식을 실행하고, "춘장이"를 인자로 전달하여 Person 클래스의 객체를 생성
• 생성된 객체 b의 getname() 메서드를 호출하여 이름을 출력

sv = "Person('춘장이')"

ev = compile(sv,"fakefile",'eval')

b = eval(ev)

print(b.getname())

춘장이

• 약수 구하기

def common_div(x) :

    s = set()

    for i in range(1,x+1) :

        if x % i == 0 :

            s.add(i)

    return s

a = int(input(" 수를 입력하세요"))

ass = common_div(a)

print("약수",ass)

1

b = int(input(" 수를 입력하세요"))

bss = common_div(b)

print("약수",bss)

print("공약수",(ass & bss))

print("최대 공약수",max(ass & bss))

 수를 입력하세요9
약수 {1, 3, 9}
 수를 입력하세요18
약수 {1, 2, 3, 6, 9, 18}
공약수 {1, 3, 9}

최대 공약수 9

 

재귀함수 : 자기 자신을 호출하는 것

구성을 잘하면 코드도 짧고, 빠르게 작동 가능

a = int(input("수를 입력하세요 "))

b = int(input("수를 입력하세요 "))

print(a,b)

def gcd(p, q) :

    print(p,q)

    if (q == 0) :

        return p;

    return gcd(q, p%q)

print(" 최대 공약수 ",gcd(a,b))

수를 입력하세요 75
수를 입력하세요 33
75 33
75 33
33 9
9 6
6 3
3 0
 최대 공약수  3

3. 함수 정보 조회

 

6.1 Function 및 code class 이해하기

 

• 함수(람다함수 포함)는 로딩될 때 function 클래스에 속성이 만들어지고 이 내부에 code 클래스의 인스턴스까지 연결하여 속성을 확인할 수 있음

• 함수의 자료형 확인

def addd(x,y) :

    return x+y

print(type(addd))

print(isinstance(addd, type(addd)))

<class 'function'>

True

함수 내의 code 클래스 정보 확인하기 

import pprint

print(type(addd.__code__))

co = set(dir(addd.__code__))

o = set(dir(object))

pprint.pprint(co-o)

<class 'code'>
{'co_argcount',
 'co_cellvars',
 'co_code',
 'co_consts',
 'co_filename',
 'co_firstlineno',
 'co_flags',
 'co_freevars',
 'co_kwonlyargcount',
 'co_lines',
 'co_linetable',
 'co_lnotab',
 'co_name',
 'co_names',
 'co_nlocals',
 'co_posonlyargcount',
 'co_stacksize',
 'co_varnames',
 'replace'}

print(addd.__code__.co_argcount)

print(addd.__code__.co_name)

print(addd.__code__.co_names)

print(addd.__code__.co_varnames)

2
addd
()
('x', 'y')

• 함수 소스 및 바이트 코드 보기
• inspect.getsource() 함수는 주어진 함수나 클래스의 소스 코드를 문자열 형태로 반환

import inspect

def addd(x:int,y:int) -> int :

    return x+y

print(inspect.getsource(addd))

def addd(x:int,y:int) -> int :

return x+y

• dis 모듈은 파이썬의 바이트 코드(bytecode)를 분석하고 디스어셈블한(disassembled) 결과를 제공하는 모듈
• dis.dis() 함수는 함수나 메서드의 바이트 코드를 분석하여 그 내용을 출력함

import dis

print(dis.dis(addd))

  4           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_ADD
              6 RETURN_VALUE
None

 

6.2 함수 시그니처

• 함수 시그니처
  • 함수의 입력과 출력을 정의하는 부분
  • 함수의 이름, 매개변수의 개수, 매개변수의 자료형, 반환값 등을 포함

 

• 시그니처와 매개변수 정보 확인하기

import inspect

def addd(x:int,y:int) -> int :

    return x+y

a = inspect.signature(addd)

print(type(a))

print(a)

print(a.parameters)

print(a.parameters['x'])

print(a.parameters['y'])

print(a.return_annotation)

<class 'inspect.Signature'>
(x: int, y: int) -> int
OrderedDict([('x', <Parameter "x: int">), ('y', <Parameter "y: int">)])
x: int
y: int
<class 'int'>

 

• 함수에 대한 기본 정보도 함수로 조회하기

import inspect

def addd(x:int,y:int) -> int :

    """ addd 함수에 대한 __doct__ """

    return x+y

a = inspect.getdoc(addd)

print(type(a))

print(a)

m = inspect.getmodule(addd)

print(m)

b = inspect.getargs(addd.__code__)

print(b)

c = inspect.getsourcefile(addd)

print(c)

<class 'str'>
addd 함수에 대한 __doct__ 
<module '__main__'>
Arguments(args=['x', 'y'], varargs=None, varkw=None)
<ipython-input-119-7e25935ec5a4>