함수(function) - 내장함수, 사용자 정의함수

함수(function)

함수 기반의 프로그래밍 방식: 절차적 프로그래밍 (Procedural programming)

 

# python에서 함수는 크게 2가지로 구분

1. 내장함수

2. 사용자 정의함수(user define 함수)

---

1. 내장함수: python이 제공해주는 함수

- int() : 인자로 들어온 값을 정수로 변환

- abs() : 절대값

- all() : 인자로 반복가능한 타입이 와야 함 (list, tuple, dict, set, str) (int는 값 1개이므로 반복 X)

         인자로 들어온 값이 모두 True일 경우 True를 리턴

a = [True,100,{},3.14]   # {}: 기본적으로 dict(set이 될 수도 있지만)
print(all(a))    # False -> {}이 False이므로

 

- any() : 인자로 반복 가능한 타입이 와야 함

            인자로 들어온 값 중 True 있으면 True 리턴

print(any(a))     # True

 

- len() : 길이를 구하는 내장함수

- list() : 리스트로 변환하는 함수

- tuple() : 튜플로 변환하는 함수

- str() : 문자열로 변환하는 함수

- type() : 인자로 들어온 데이터의 타입

- max(), min() : 최대, 최소

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

※ mean은 없음-> sum()/len() 으로 구하기

 

- sorted() : 오름차순으로 정렬

- join() : 하나의 문자열을 다른 것과 결함

a = ["이것은","소리없는","아우성"]
print(" ".join(a))   # 이것은 소리없는 아우성 -> 붙이는 거 사이에 공백 넣어라

 

- input(): 값 1개 입력받음

inputValue = input()  # 입력받는 내장함수: 무조건 str로 받음

(+) 숫자 3개를 받아보자

# 100 200 300이라고 입력: 지금 inputValue는 "100 200 300"
print("입력받은 값은:{}".format(inputValue))

var1 = inputValue.split(" ")    # 공백을 기준으로 문자열을 분리. 결과는 list
result = mySum(int(var1[0]),int(var1[1]),int(var1[2]))
print("최종결과는 {}".format(result))

---

2. 사용자 정의함수

- 사용자 정의함수를 만드는 keyword는 def

- 함수이름은 소문자로 시작(관용적, 프로그램적으로는 대문자도 문제 X)

- 함수의 정의(definition) → 함수 이름, 인자 형태, 인자 개수 + 기능구현

- 함수의 선언(declaration) → 함수 이름, 인자 형태, 인자 개수

def mySum(a,b,c):
    total = a+b+c   # 함수의 기능을 구현
    return total

 

# 사용자 정의함수를 만들어보자.

- default parameter (parameter: input값)

- 마지막 parameter에 default값 지정 가능 → 무조건 마지막만 가능!

def mySum(a,b,c=100):   # c는 값이 안들어올수도 있다. 안들어오면 100으로 쓰겠다.
    return a+b+c
    
mySum(1,2)    # 103
mySum(1,2,4)  # 7

 

- 변수의 scope: 전역변수와 지역변수의 차이

tmp = 100    # global variable (전역변수)
def myFunc(x):     # 함수 안에서 선언된 변수는 local variable (지역변수)
                    # local variable은 함수가 호출될 때 생성되고 함수 수행이 끝나면 없어짐
    tmp = 10
    tmp += x
    return tmp

print(myFunc(20))   # 30
print(tmp)     #100  → 30이 아님

# 함수 안에서 global variable 사용 → 좋지 않음.
# tmp를 저 위의 tmp를 말하고 싶다면 global tmp = 10 이렇게 하면 global tmp가 10이 됨
# 선언과 대입은 동시에 할 수 없다.

def myFunc(x):     # 함수 안에서 선언된 변수는 local variable (지역변수)
                   # local variable은 함수가 호출될 때 생성되고 함수 수행이 끝나면 없어짐
    global tmp    # tmp를 global에서 찾아서 사용할 것! 
    tmp = 10
    tmp += x
    return tmp

 

[예제 1] 전달받은 모든 값들을 더해서 리턴하는 함수

def mySum2(*a):   # *: 입력 개수 모를때   # a : 튜플로 간주됨.
    k=0
    for i in range(len(a)):  # 받은것 개수만큼 for문 돌겠다
        k += a[i]
    return k
total = mySum2(10,20,30,40)   # a => (10,20,30,40)
print("최종결과:{}".format(total))   # 최종결과:100

 

[예제 2] 숫자 2개 받아서 두 개의 합과 두 개의 곱을 리턴

tuple을 이용해서 마치 여러 개의 값이 리턴 되는 것처럼 사용 가능

# tuple에서
# a = (10,20,30) 인데 소괄호 생략 가능.
# a = 10,20,30 가능
# list, set 등은 괄호 생략 불가!

def multi_process(x,y):
    result1 = x+y
    result2 = x*y
    return result1,result2   # result1,result2 : 결과값 튜플로 나옴 # (result1,result2) 과 같음    

a,b = multi_process(100,200)  
# a,b = (300,20000) 와 동치
print(a)  # 300

 

---

연습문제

[연습문제 1] 앞에서부터 읽을 때나 뒤에서부터 읽을 때 모양이 같은 수를 대칭수라고 한다.
ex) 9009, 303 등
두 자리 수를 곱해서 만들 수 있는 대칭수 중 가장 큰 수는 9009 (91*99)
세 자리 수를 곱해서 만들 수 있는 가장 큰 대칭수는 얼마인가?

3자리수 답: 906609

4자리수 답: 99000099

 

 

# 방법 1

# 대칭수 판별하는 함수
def syTF(x):
    x = str(x); xList=list(); result = False
    for i in range(len(x)):
        xList.append(x[i])
    ans = [0]*round(len(xList)/2)

    for j in range(round(len(xList)/2)):
        if(xList[j]==xList[len(xList)-j-1]):
            ans[j] = True
        else:
            ans[j] = False
    if all(ans)==True:
        result = True
    return result     
#syTF(10301)


# n자리 수를 곱해서 대칭수 list 구해서 max 구하기
def mySymmetry(n):
    sym = list()
    for i in range(10**(n-1),10**n):
        for j in range(10**(n-1), 10**n):
            if syTF(i*j):
                sym.append(i*j)
    return max(sym)           

print(mySymmetry(2))
print(mySymmetry(3))
print(mySymmetry(4))

 

# 방법 2 - reversed 이용  ( s[::-1] 도 문자열 뒤집기 )

def syTF2(x):
    result = False
    x = str(x);
    y = ''.join(reversed(x))
    if x == y :
        result = True
    return result
#print(syTF2(10301))


def mySymmetry2(n):
    sym = list()
    for i in range(10**(n-1),10**n):
        for j in range(10**(n-1), 10**n):
            if syTF2(i*j):
                sym.append(i*j)
    return max(sym)   

print(mySymmetry2(2))
print(mySymmetry2(3))
print(mySymmetry2(4))

 

# 방법 3 - reverse이용

def check_number(x):
    # 숫자로 처리는 힘듦 -> 문자열로 처리가 쉬움
    str1 = str(x)     # 원래형태 문자열
    tmp = list(str(x))
    tmp.reverse()    # reverse된 문자열
    if str1 == "".join(tmp):
        return True
    else:
        return False
check_number(323)

def calcul_number(x):
    result = []
    for i in range(10**(x-1),10**x):
        for j in range(10**(x-1),10**x):
            if check_number(i*j):
                result.append(i*j)
    return max(result)
print(calcul_number(2))

---

[연습문제 2] 1부터 10 사이의 어떤 수로도 나누어 떨어지는 가장 작은 수는?

답: 2520 (1부터 20 사이의 경우 답: 232792560)

 

 

# 방법 1: 1-20 다 나눠주기

# 방법 1
def myF(x,y):
    num=y-1; result=False;
    while result==False:
        result1=list(); num += 1
        for i in range(x,y+1):    # num을 1-20으로 나눠보기 -> 다 나눠떨어지면 result를 return
            if num%i==0:
                result1.append(True)
            else:
                result1.append(False)
        if all(result1):
            result=True
    print(num)
myF(1,20)

# 방법 1-1: 1-20 다 나눠주는데 len 이용
# t=0; result=[]
# while len(result)<10:
#     result=[]
#     t +=1
#     for i in range(1,11):
#         if t%i==0:
#             result.append(i)
# print(t)

   

# 방법 2: 최소공배수 이용

def myMulti(x,y): # 최소공배수 구하는 함수 : myMulti
    if x>y:
        mul = x
    else:
        mul = y
    while True:
        if mul%x==0 and mul%y==0:
            break
        mul+=1
    return mul
myMulti(2,3)

def myMultis(a,b):     #myMultis: a~b의 최소공배수 구하는 함수
    x = myMulti(a,a+1)
    for i in range(a+2,b+1):
        x = myMulti(x,i)
    return x
myMultis(1,20)


# 방법 2-1 : 최소공배수 구하는 함수 하나로!

def myF(a,b):
    mul = a; mul2 = a+1
    for i in range(a,b+1):
        while True:
            if mul%i==0 and mul%mul2==0:
                mul2 = mul
                break
            mul +=1
    return mul    
myF(1,20)