[python] 사용자 정의 함수

return 

 

 

 

 

메모리

 

튜플은 값의 복사가 일어난다.

 

 

재귀함수 

 

가급적이면 일반 for문으로 돌려라...

 

이유는

1. 스택프레임에 쌓임

2. 가독성이 안좋다.

3. 자원 관리의 어려움.

 

만약 할당 변수가 있을 시에 변수가 계속적으로 선언됨.

-> 관리하기 매우 어렵다.

 

for문은 어떤 자원이 어떻게 쓰이는지 잘 보인다.

 

 

불가피한 경우)

1. depth를 예측할 수 없는 경우.

2. 

 

def func1():
    return 5

x1  = func1()
print("{}".format(x1))
print("{}".format(func1()))


# 두 개의 숫자를 더해서 나온 합산 값을 return하는 함수
def func2(a,b):
    print("이것은 두 개의 값을 더하는 함수 입니다.") # 리턴 전에 출력값을 넣으면 먼저 출력된다.
    return(a+b) # 합산한 결과를 return
    # 리턴을 만나면 그 후에 어떠한 함수를 만나도 여기서 멈춘다.
    print("이것은 리턴 후에 실행되는 함수 입니다.") # 리턴 후에 출력은 안된다.

# 예외 사항
# 조건부
def func3(a):
    if a == 10 :
        return # 로직을 강제로 블락한다. return 이후의 출력값을 출력한다.
    print("입력한 숫자 : {}".format(a))

# 처리 순서는 위에서 아래로
# print 값을 먼저 출력하고 그 다음 값이 return이 된다.
print("{}".format(func2(3,5)))

func3(5)
func3(10) # 로직을 강제로 블락한다.

 

def func1(x, y):
    return x+y, x-y # 복수개로 리턴을 하면 결과값이 튜플로 떨어진다.

x1 = func1(20,5)
print(x1)
print("{}".format(x1), type(x1)) # 복수개로 리턴을 하면 결과값이 튜플로 떨어진다.

x2, y2 = func1(20, 5)
print(x2) # 25
print(y2) # 15


print("---------------------------------------------")

def func2(x, y):
    return x+y, x-y, x*y # 복수개

# 일부데이터를 한꺼번에 받기 위해 * 를 변수에 사용하여 받을 수 있다.
x3, *y3 = func2(20, 10)
print(x3) # singlarity
print(y3) # multiplier 형태의 데이터타입을 받는다.
print(y3, type(y3)) # 리스트 형태로 떨어진다.

 

 

memory 

a = 1

def func1(a):
    a = a + 1 # 스택

func1(2)
print(a)

# 전역 메모리
# a => 1
# func1
# 실제로 교체될 일이 없다.

# 메모리에 대한 참조는 본인의 구역상에서 메모리 참조는 가능하다.
# 현재 구역에서 다른 구역의 메모리를 참조하지는 못한다.

# func1 메모리 (스택 메모리)
# a => 2 + 1

print("--------------------------------")
a = 1
b = 2
# 본인의 메모리 스택상에 없으면 상위 스택(전역메모리)상의 메모리를 참조한다.
def func1(a):
    a = a + 1 # 스택
    print(b)
    return a

func1(2)
print(a)
# b 출력됨
print(func1(2))

print("--------------------------------")

def func2(b):
    global a # 상위 메모리(전역메모리) 를 참조하고 싶을 때.
    a += 1

func2(10)
print(a)

def test1(a):
    a += 10

# 메모리는 다르다.
# 하나는 전역
# 하나는 스택
a = 1
test1(a)
print(a)


# 주소에 의해서 참조가 일어난다. = 로직이 바뀐다.
def test2(b):
    b[0] = "zzz"

b = ["aaa"]
test2(b)
print(b)

# 값을 비교
print( (1,2,3) == (1,2,3) )
print( [1,2,3] == [1,2,3] )
print( {1,2,3} == {1,2,3} )

 

 

 

 

 

람다식

 

함수, 객체지향을 lamda로 정리 가능.

 

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

print(func1(2,3))

print("---------------------------------------")
# 람다식
add = lambda a, b: a+b
result = add(3,4)
print(result)
print(add(3,4))

print("---------------------------------------")
print((lambda a,b: a-b)(3, 4))

print("---------------------------------------")
# 함수 채로 넣어서 사용 가능.
def func2(a):
    print(a)

func2((lambda a: "{}".format(a))("aaa"))


print("---------------------------------------")

def func3():
    return lambda x: x**2

x1 = func3()
print(x1(3))


print("---------------------------------------")

def func4():
    print("복잡한 수식")
    return 1

x3 = lambda x: x+func4()
print(x3(3))

# map

def func1(x):
    return x*2

list1 = list(map(func1, [1,2,3,4]))  # list로 변환을 한번 시켜주고 넘겨줘야함.
print(list1)

print("------------------------------------------------------")


dic1 = {1: 10, 2: 20, 3: 30}
list2 = list(map(func1, [dic1[i] for i in dic1]))
print(list2)

print("------------------------------------------------------")
# 굳이 func1 을 사용할 필요없이 람다식 사용
print(list(map(lambda x: x+10, [1,2,3])))

print("------------------------------------------------------")

a3 = [1,2,3,4,5,6,7,8,9]
# 3의 배수를 문자열로 처리하고 싶다
# str(x) -> 숫자를 문자열로 변환
# 삼항연산자 사용
print(list(map(lambda x: str(x) if x % 3 == 0 else x, a3)))

print("------------------------------------------------------")

a4 = [1,2,3,4,5]
b4 = [2,4,6,8,10]

print(list(map(lambda x, y : x * y, a4, b4)))

 

# filter

def func1(x):
    return 5 <= x <= 10

a1 = [8,1,3,4,5,8,10,11,15,12,16]

print(list(filter(func1, a1)))

print(list(filter(lambda x : 5 <= x < 12, a1)))

from functools import reduce
# reduce -> 누적계산
a1 = [1,2,3,4,5]

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

# reduce(이미존재하는값, 새로들어오는값)
print(reduce(func1, a1))
# 람다식
print(reduce(lambda x, y : x + y, a1))

 

 

클로져 

def outer_func1(a) :
    hello = "hello outer func1"
    def inner_func1() :
        print(hello)
        return 1

    return inner_func1()



def outer_func2(a):
    hello = a
    return lambda x : hello + ":" + x

inner_func2 = outer_func2("hello")
print(inner_func2("world"))

 

타입체크

def func1(a: int) :
    return a + 1

print(func1(1))


def func2(a: int, b: str) -> int: # return 타입을 int로
    return "asdasdsd"

print(func2(1, "asdada"))


def func3(a: list) :
    pass

print(func3())

 

내장함수 

 

*

리스트 함수 

딕셔너리 함수 

셋 함수 

 

무조건 한번 다뤄봐야함.

 

 

 

정규표현식

 

# 정규 표현식 

import re # regular expression 

str1 = "asdasd 010-1234-5678 asdasdasd"
pattern1 = re.compile("[0-9]{3}-[0-9]{4}-[0-9]{4}")
result = pattern1.findall(str1)
print(result)