Python(7) 함수

함수

함수의 종료 구분은 들여쓰기 기준 or return으로 구분

def printnum():
    print('1')
    return # 여기서 함수 종료
    print('2')
print('3')
printnum()
print(printnum()) # 디폴트가 return None

# 3
# 1
# 1
# None

 

파선아실 : 파라미터는 선언할 때, 아규먼트는 실행할 때 (인자 구분)

def function(x, y): # x, y = 파라미터
    z = x + y
    return z
print('function(5, 7)=', function(5, 7)) # 5, 7 = 아규먼트

 

함수 안에 함수

def f():
    def ff():
        return 100
    x = ff()
    return x
f() # 100
# ff() Error 함수 내부에서 선언한 변수와 함수는 밖에서 호출할 수 없음

 

함수를 아규먼트로 전달

def f(a, b):
    return a + b

def ff(a):
    return a(10, 20)

ff(f) # 30

 

아규먼트 여러개 받기

def f(a, b, c):
    print(a, b, c)

# f() # error
# f(100, 10) # error
f(a=100, b=200, c=300) # 100 200 300
f(c=300, a=100, b=200) # 100 200 300 순서 바꿔서 전달 가능

 

파라미터 초기값 설정

def f(a=10, b=20, c=30):
    print(a, b, c)

f() # 10 20 30
f(100, 10) # 100 10 30
f(a=100, b=200, c=300) # 100 200 300
f(c=300, a=100, b=200) # 100 200 300

def f(a=10, b=20, c): # Error c가 맨 앞으로 와야함.
    print(a,b,c)
 
 
def f(a, b=20, c=30):
	print(a,b,c)

# f() # error
# f(100, 10) # 100 10 30
# f(a=100, b=200, c=300) # 100 200 300
# f(c=300, a=100, b=200) # 100 200 300
# f(c=300) # error

 

지역변수와 전역변수 조심

def f():
    inner_value = 100

print(inner_value) # Error

x = 100
def f():
    y = x + x
    return y

f() # 200

x = 100
def f():
    x = 200 # 전역변수 x와 다른 변수임
    return x

print(f()) # 200
print(x) # 100

 

global 을 사용하면 전역변수 접근가능

a = 100
def f():
    global a
    a = a + 1
f()
print(a) # 101

 

여러개의 값 반환하기

def f():
    a = 10
    b = 20
    c = 30
    return a, b, c

print(f()) # (10, 20, 30)

 

함수의 이름은 변수

kimdonghu = print # 이런식으로 가능
kimdonghu('hello world') # hello world

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

def sub(x, y):
    return x - y

ll = [add, sub]
ll[0](10, 20) # add(10, 20)과 같음
# 30

 

람다 함수

add = lambda x, y : x + y
sub = lambda x, y : x - y
print(add(10, 20)) # 30
print(sub(10, 20)) # -10

 

재귀함수

될 수 있으면 사용 x (주니어 때)

위험하고 일부 효율이 좋지 않음.

반복문 <-> 재귀함수 서로 상호 호환이 가능.

 

상식 수준의 재귀함수

1. 팩토리얼

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n-1)

factorial(5) # 120

2. 문자열 뒤집기

def reversed_str(s):
    if len(s) <= 1:
        return s
    return reversed_str(s[1:]) + s[0]

reversed_str('hello')


# 함수 호출                 return
# reversed_str(s)         reversed_str(s[1:]) + s[0]
# reversed_str('hello')   reversed_str('ello') + 'h'
# reversed_str('ello)     reversed_str('llo') + 'e'
# reversed_str('llo')     reversed_str('lo') + 'l'
# reversed_str('lo')      reversed_str('o') + 'l'
# reversed_str('o')       'o'

 

built-in function

built-in function이라고 부르지만, 자료형인것 주의

print(type(print))
print(type(enumerate))
print(type(range))
print(type(max))
print(type(len))
print(type(format))
print(type(zip))
print(type(map))
print(type(filter))
print(type(int))
print(type(str))

# <class 'builtin_function_or_method'>
# <class 'type'>
# <class 'type'>
# <class 'builtin_function_or_method'>
# <class 'builtin_function_or_method'>
# <class 'builtin_function_or_method'>
# <class 'type'>
# <class 'type'>
# <class 'type'>
# <class 'type'>
# <class 'type'>

# type 인것은 메서드가 아니라 자료형임.

 

all : 모두 True여야 True 반환

any : 하나라도 True가 있으면 True 반환

all([True, True, True]) # T
all([True, True, False]) # F
all([1, 1, 1, 0]) # F
all([100, 10, -1]) # T

any([True, False, False]) # T
any([False, False, False]) # F

 

chr : 10진수로 유니코드표에서 찾아 대응하는 값을 반환

ord : 문자를 입력하면 유니코드표 숫자를 반환

print(chr(65)) # A
print(chr(97)) # a
print(chr(54616)) # 하

print(ord('a')) # 97
print(ord('하')) # 54616

 

map(함수, iterable) : iterable자료형을 하나씩 반복하면서 함수에 집어넣어서 수행

filter(함수, iterable) : iterable자료형을 하나씩 함수에 넣어서 True인값을 필터링

map(lambda x: x**2, [1, 2, 3, 4]) # 계산 되기 전 object
# <map at 0x7cbc5d054130>
# map 객체를 반환하므로 list로 형 변환 해주어야함.

list(map(lambda x: x**2, [1, 2, 3, 4])) # 계산 된 후 object # [1, 4, 9, 6]

list(filter(lambda x: x>10, [1, 2, 11, 12, 9, 6, 13])) # [11, 12, 13]

 

zip : iterable 자료형을 순서대로 묶어서 새로운 iterable 자료형 생성

list(zip('abc', '123')) # [('a', '1'), ('b', '2'), ('c', '3')]

list(zip('abc', '1234567', [10,20,30])) # [('a', '1', 10), ('b', '2', 20), ('c', '3', 30)]

S = [1, 3, 4, 8, 13, 17, 20]
list(zip(S, S[1:]))
# [(1, 3), (3, 4), (4, 8), (8, 13), (13, 17), (17, 20)]

 

format : 지정 값을 지정 형식으로 포맷

format(10000000, ',')
# '10,000,000'

 

len : 길이

max : 제일 큰 값

min : 제일 작은 값

len('hello world') # 11

max([1, 2, 3, 4, 5]) # 5

min([1, 2, 3, 4, 5]) # 1

 

sum : 합

sum([1, 2, 3, 4, 5]) # 15

sum([1, 2, 3], 10) # 10에다가 1, 2, 3을 더함. 16

sum([[1, 2], [3, 101], [1, 20], [3, 100]],[]) # []에다가 배열들을 더함.
# [1, 2, 3, 101, 1, 20, 3, 100]

 

print 와 repr

print()함수로는 __str__메서드 호출, repr은 __repr__ 메서드 호출.

__repr__ : 개발자를 위한 문자열 표현? 공식적인 표현을 반환.

__str__ : 사용자를 위해서 비공식적인 표현을 반환.

class Charactor:
    def __repr__(self):
        return 'hello'
    def __str__(self):
        return 'world'

hero = Charactor()
print(hero) # world # 최대한 보기 편한 문자열로
repr(hero) # 'hello' # 좀 더 원래 값에 가깝다

 

enumerate : iterable 자료형의 순서를 지정함.

가수 = ['뉴진스', '르세라핌', '에스파', '아이브']
print(list(enumerate(가수))) # [(0, '뉴진스'), (1, '르세라핌'), (2, '에스파'), (3, '아이브')]
print(list(enumerate(가수, 1))) # 1부터 [(1, '뉴진스'), (2, '르세라핌'), (3, '에스파'), (4, '아이브')]
print(list(enumerate(가수, 100)))# 100부터 [(100, '뉴진스'), (101, '르세라핌'), (102, '에스파'), (103, '아이브')]

for i, j in enumerate(가수, 1):
	print(i, j)
# 1 뉴진스
# 2 르세라핌
# 3 에스파
# 4 아이브

 

range(start, stop, step) : 슬라이싱과 비슷한 형태

print(range(10)) # 값이 없음. range(0, 10)
print(list(range(10))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = range(10)
print(type(x)) # <class 'range'>
print(list(range(0, 10, 2))) # [0, 2, 4, 6, 8]
print(list(range(10, 0, -2))) # [10, 8, 6, 4, 2]

 

reversed : 뒤집음

list(reversed('hello world')) # ['d', 'l', 'r', 'o', 'w', ' ', 'o', 'l', 'l', 'e', 'h']

list(reversed([1, 2, 3, 10, 5, 4]) # [4, 5, 10, 3, 2, 1]

 

sorted : 정렬

list(sorted([1, 2, 3, 100, 200, 5, 10, 20], reverse=True))
# [200, 100, 20, 10, 5, 3, 2, 1]

sorted(['hello', 'l', 'hllo', 'hel', 'heo', 'a'], key=len) # len을 기준으로 정렬
# ['l', 'a', 'hel', 'heo', 'hllo', 'hello']
# 위 코드는 sorted([5, 1, 4, 3, 3, 1])와 같음

data = [
    [2, 'hello world', 30],
    [3, 'hworl', 33],
    [4, 'hello w', 31],
    [5, 'hello wo', 35],
    [6, 'hello w', 39]
]

print(list(sorted(data, key=lambda x: len(x[1])))) # 두번째 요소의 문자열 길이를 기준으로 정렬
# [[3, 'hworl', 33], [4, 'hello w', 31], [6, 'hello w', 39], [5, 'hello wo', 35], [2, 'hello world', 30]]