Function

def f() : 
    pass

def f() : 
    print('Hello')

f()

Hello

def f_(x) : 
    print('Hello' + str(x))

y=f_(5555)

Hello5555

y

type(y)

NoneType

아무것도 안 나옴
output이 없는 함수이기 때문에
output이 있는 함수를 만들어보자

def fn(x) :
    y=x+10
    return y # OUTPUT

y=fn(3)

y

13

type(y)

int

return이라는 output이 생김

out=fn(123)

print(out)

133

out

133

local & global

# global 변수
y=5

def fn(x) :
    y=x+10
    print('함수 안에 있는 변수, y=' + str(y))
    return y # local 변수 # output

fn(2)

함수 안에 있는 변수, y=12

12

print('함수 밖에 있는 변수, y=' + str(y))

함수 밖에 있는 변수, y=5

def d_is_10():
    d=10
    print('d 값은',d,'이다')

d_is_10()

d 값은 10 이다

d는 d_is_10이라는 함수에서만 정의해준 지역변수이기에 함수 밖에서 d를 호출하면 반환되지 않음

반대로 전역변수는 언제든지 함수 안으로 끌고 들어와 지역변수로서 사용할 수 있음

x=10 # global variable
def printx():
    print(x)
printx()
# output 없음

10

함수 안에서 전역변수를 만들 수 있음

즉 local을 local로도 사용하고 global로도 사용해보자

def e_is_12():
    # e라는 변수를 사용할 건데 함수 안에서 정의해주지만 , 전역변수로도 사용할 것이다라고 명해줌
    global e   
    # 이때 e는 지역변수로도, 전역변수로도 사용하겠다.
    e=12
    print('e값은 여기서 불러도',e,'로 불러와지고')
e_is_12()

e값은 여기서 불러도 12 로 불러와지고

print('함수 밖인 여기서 불러도','e는', e ,'로 불러와진다')

함수 밖인 여기서 불러도 e는 12 로 불러와진다

e

12

def f2(x):
    return x+10

f2(3)

13

input을 지정 안 하고 함수가 알아서 지정할 수 있게 할 수 있음

def f2(x=5):
    return x+10

f2()

15

f2(40)
# 함수 만들 때 지정해준 변수 값을 수정하여 input을 다시 줄 순 있음

50

def f3(x1,x2):
    return x1+x2

f3(3,5)

8

def f4(name,age=0,lan='NONE'):
    print(name+' '+str(age)+' '+lan)
    # age와 lan은 미리 지정해줌으로서 초기화해놓았다고 생각해놓으면 됨

f4('rhkrehtjd')
# 이렇게 나이와 lan을 입력 안 해도 함수 만들 때 미리 지정해주고 시작해도 됨

rhkrehtjd 0 NONE

f4('rhkrehtjd',2,'R')
# 그런데 입력값이 생겼을 땐 그 입력값을 사용할 수 있음

rhkrehtjd 2 R

순서를 바꿔 쓴다면?

f4('rhkrehtjd',lan='python',age=123)

rhkrehtjd 123 python

이렇게 순서 바꿔쓸거면 keyword만 제대로 명시해주자
그런데 이렇게 순서 바꿔쓸 수 있는건 초기화로 설정된 변수에서만 사용가능함
즉 이 함수 f4에선 age하고 lan만 초기화 상태로 명했고 name은 초기화해놓지 않았기 때문에 name은 그 자리에서 input해줘야 함

def ff(*x):
    print(x)

ff('abc','asd','qgeqve','asdasdf')

('abc', 'asd', 'qgeqve', 'asdasdf')

이렇게 input이 몇개가 들어와도 해결이 가능함

def fff(*x):
    for a in x:
        print(a)

fff('asd','asdqw','qwg')

asd
asdqw
qwg

이런식으로 input을 몇개주더라도 그 input을 다 더해주는 함수

def qq(*args):
    total = 0
    for a in args:
        total += a
    return total

qq(12,12,34)

58

def cc(*x):
    com=''
    for a in x:
        com +=a
    return com

cc('pt','Rhkrehtjd')

'ptRhkrehtjd'

a=[10,15]
list(range(a[0],a[1]+1))

[10, 11, 12, 13, 14, 15]

a[1]+=1

a

[10, 16]

# 박스를 펼치는 것처럼 arguements를 하나로 받아서 펼치는!
list(range(*a))

[10, 11, 12, 13, 14, 15]

def qq():
    num_s=int(input('Start num: '))
    num_e=int(input('End num: '))
    num_inc=int(input('Increment: '))
    
    out_list=list(range(num_s,num_e+1,num_inc))
    
    return out_list

qq()

[55, 709]

입력 세번을 한 번에 할 수 있게 해보자

a=input()

a

'5 6 8'

a[1]

' '

input은 입력해주는대로 str으로 만들어서 반환해줌
즉 만약 내가 3 2 1이렇게 입력해주면 총 7개의 원소가 str안에 들어가고
내가 3 1 2 이렇게 입력해주면 총 5개의 원소가 str안에 들어가게 된다.
그렇다면 내가 3,1,2 이렇게 입력해주면 콤마까지도 하나의 원소로서 들어가면서 총 5개의 원소가 str으로 입력되게 된다.

def qq2():
    print('숫자를 다음과 같이 입력해주세요 ')
    print('시작: ,끝: ,증가단위: ')
    print('예시: 0,5,1')
    
    ui=input('자, 이제 알려줬으니 한 번 입력해봐여: ')
    ui_list=[int(i) for i in ui.split(',')]
    # ,기준으로 나눈다음(콤마는 없앰) 각각을 list의 하나의 원소로서 반환시켜준다.
    out_list=list(range(*ui_list))
    
    return out_list

qq2 ()

숫자를 다음과 같이 입력해주세요 
시작: ,끝: ,증가단위: 
예시: 0,5,1

[5, 7, 9]

만약 마지막 숫자도 포함하고 싶다면?

def qq2():
    print('숫자를 다음과 같이 입력해주세요 ')
    print('시작: ,끝: ,증가단위: ')
    print('예시: 0,5,1')
    
    ui=input('입력해주세요: ')
    ui_list=[int(i)for i in ui.split(',')]
    ui_list[1]+=1
    out_list=list(range(*ui_list))
    
    return out_list

qq2()

숫자를 다음과 같이 입력해주세요 
시작: ,끝: ,증가단위: 
예시: 0,5,1

[5, 10, 15, 20, 25]

documentation $\to$ 함수에 도움말을 넣어보자

def qw(x):
    """
    여기가 함수의 도움말
    """
    return x+10

qw?

Signature: qw(x)
Docstring: 여기가 함수의 도움말
File:      c:\users\ehfus\appdata\local\temp\ipykernel_13032\1023470262.py
Type:      function

help(qw)

Help on function qw in module __main__:

qw(x)
    여기가 함수의 도움말

print(qw.__doc__)

    여기가 함수의 도움말

annotation :사용방법 달아주기, input이 들어올 때 어떤 형식으로 들어와야 하는지 주석을 달아준다고 생각하면 됨

def fu(num):
    out=num+10
    return out

print(fu.__annotations__)

{}

def fu(num:int):
    out=num+10
    return out

print(fu.__annotations__)

{'num': <class 'int'>}

def fu(num:int)->int:
    out=num+10
    return out

print(fu.__annotations__)

{'num': <class 'int'>, 'return': <class 'int'>}

이렇게 output의 자료형도 주석을 달듯이 알려줄 수가 있음

lambda

add_one = lambda x: x+1

add_one이라는 함수를 만들어줬다고 생각하면 됨

add_one(1)
# output이 있음

2

(lambda x:x+1)(10)
# lambda를 사용할 때 이렇게 한 줄로 함수와 입력을 동시에 명해줄 수가 있음

11

def a(x):
    return x+10

high_ord_function=lambda x: x+a(x)

high_ord_function(2)

14

high_ord_function=lambda x, ff : x+ff(x)

high_ord_function(2,lambda x:x+1)

5

high_ord_function(2,lambda x:x-1)

3

이런식으로 lmabda를 사용하게 되면 실시간으로 함수자체를 input으로 줘서 고차원 함수를 사용할 수 있게 됨

map

import numpy as np
a=np.array([1,2,3,4,5])
a*2

array([ 2,  4,  6,  8, 10])

a=[1,2,3,4,5]
a*2
# numpy에서의 결과처럼 list도 활용하고 싶다. 
# map을 활용한다.

[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

list(map(lambda x: x*2,[1,2,3]))

[2, 4, 6]

map은 list전체에 함수를 적용하는 게 아니라 map의 각 원소 각각에 함수를 적용해주는 것 같음
그렇다면 아래와 같이도 활용할 수 있겠다.

vip='rhkrehtjd'
print(vip.upper())
print(vip.capitalize())

RHKREHTJD
Rhkrehtjd

vip_list=['adqw','wfdf','sdgv']

vip_list는 list이기 때문에 upper라는 함수를 지원하지 않음
upper는 문자열에서 지원하는 함수
따라서 vip_list안에 있는 str은 upper라는 함수를 사용할 수 있음

print(list(map(lambda x: x.upper()  ,vip_list)))
print(list(map(lambda x: x.capitalize()  ,vip_list)))

['ADQW', 'WFDF', 'SDGV']
['Adqw', 'Wfdf', 'Sdgv']

len(vip_list)

3

이건 list를 전체적인 관점에서 보고 원소가 몇개 들어있는지 알려주는 것

vip_list_name_len_list=list(map(lambda x:len(x),
                               vip_list))

vip_list_name_len_list

[4, 4, 4]

map이 list전체가 아니라 그 안으로 들어가서 적용함을 알 수 있다.

!중요! filter

BOOL형이 활용된다고 생각하면 될 것 같다.

vip_list

['adqw', 'wfdf', 'sdgv']

list(filter(lambda x: 'P' in x, vip_list))

[]

해당되지 않아서 빈 list가 나왔음

list(filter(lambda x: 'a' in x, vip_list))

['adqw']

x=[1,2,3,4,5]
list(filter(lambda x: x%2==0,x))

[2, 4]

list(filter(lambda x: x%2!=0,x))

[1, 3, 5]

reduce

from functools import reduce

list_=[10,20,30]

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

reduce(add,list_)

60

reduce(lambda a,b : a+b,list_)

60

sum(list_)

60

strlist=['p','y','t','h','o','n',]

reduce(lambda x,y:x+y,strlist)

'python'

for문 $vs$ list comprehension $vs$ lambda function

letter_list=[]
for letter in 'python':
    letter_list.append(letter)
print(letter_list)

['p', 'y', 't', 'h', 'o', 'n']

letter_list_2=[letter for letter in 'python']
letter_list_2

['p', 'y', 't', 'h', 'o', 'n']

list(map(lambda x : x, 'python'))
# 각 원소에 적용됨을 알 수 있다.

['p', 'y', 't', 'h', 'o', 'n']

a,b=0,1

a

0

b

1

이렇게 변수 두개를 한 번에 저장해줄 수 있음 (tuple을 만드는 게 아님)

def my_fib_seq(n):
    a,b=0,1
    seq=[a,b]
    for i in range(n-2):  # 이미 0,1은 있으니까 -2해줌
        a,b=b,a+b
        seq.append(b)
    return seq

my_fib_seq(3)

[0, 1, 1]

def my_powers(number):
    return number,number**2,number**3

a=my_powers(2)

a

(2, 4, 8)

list(a)

[2, 4, 8]

number,square,cube=my_powers(2)

cube만 필요하다?

*_, cube=my_powers(2)

cube

8

_

[2, 4]

이렇게 unpacking할 수도 있음

def my_sum(num_list):
    total = 0
    for num in num_list:
        total+=num
    return total

my_sum([1,2,3])

6

def my_mean(num_list):
    s=my_sum(num_list) # 바로 위 셀에서 정의해준 function
    N=len(num_list)
    return s/N

my_mean([8,10])

9.0

2021/12/28/TUE

`lambda`

`map`

`reduce`