4.파이썬 심화

가. 함수심화

1)인자에 기본값 지정해주기

# 함수를 선언할 때 인자에 기본값을 지정해줄 수 있습니다.
EXPRESSION = {
        0: lambda x, y: x + y ,
        1: lambda x, y: x - y ,
        2: lambda x, y: x * y ,
        3: lambda x, y: x / y
    }

def calc(num1, num2, option=None): # 인자로 option이 들어오지 않는 경우 기본값 할당
    """
    option
     - 0: 더하기
     - 1: 빼기
     - 2: 곱하기
     - 3: 나누기
    """
    
    return EXPRESSION[option](num1, num2) if option in EXPRESSION.keys() else False
#위 문장의 뜻은 EXPRESSION이라는 연산자에서 option으로 dictionary 키로가져오는데, 만약에 옵션이 딕셔너리 안에 있는 키들이 리스트로 넘어감. 그러면 EXPRESSION.key()는 {01,2,3} 이 들어가있음. 만약에 option이 {0,1,2,3}에 포함되어있으면 true, 그렇지 않으면 False가 출력됨.
print(calc(10, 20))    # False
print(calc(10, 20, 0)) # 30
print(calc(10, 20, 1)) # -10
print(calc(10, 20, 2)) # 200
print(calc(10, 20, 3)) # 0.5

def calc(num1, num2, option)
이 있을때 calc라는 함수에 인자 3개를 안넣으면 에러남. 그런데 option에 기본값을 넣어주면 마지막 인자 안넣어도 에러 안나고 그냥 기본값 출력됨.
조건문과 비슷하게 해석될 수 있는데
if 사용자가 option을 입력했다면 :
option = 입력값
elif 사용자가 option을 입력 안했다면:
option = 기본값
과 같이 해석될 수 있음.

2) args / kwargs 에 대한 이해

• args(aguments)와 keyword arguments(kwargs)는 함수에서 인자로 받을 값들의 갯수가 불규칙하거나 많을때 사용
• 인자로 받을 값이 정해져있지 않기 때문에 함수를 더 동적으로 사용
• 함수를 선언할 때 args는 앞에 *를 붙여 명시하고 kwargs는 **를 붙여 명시
• 입력받아야 할 곳에 값이 없을 때 약간 땜빵쳐주는 느낌

가)args 활용

def add(*args):
    
    result = 0
    for i in args:
        result += i
        
    return result

print(add())           # 0
print(add(1, 2, 3))    # 6
print(add(1, 2, 3, 4)) # 10 

def main(num1, num2, num3, *args, **kwargs):
  print(num1)
  print(num2)
  print(num3)
  print(args)
  print(kwargs)
  
main(
     1, 2, 3, 4, 5, 6, 7, 8, 9
     )
     >>>
     1
     2
     (3,4,5,6,7,8,9) >args는 튜플. 특정인자 지정안하면 다 args인자로 들어감. 
     {} >kwargs는 딕셔너리 key,value가 필요
     

나)kwargs 활용

def set_profile(**kwargs):
    """
    kwargs = {
        name: "lee",
        gender: "man",
        age: 32,
        birthday: "01/01",
        email: "python@sparta.com"
    }
    """
    profile = {}
    profile["name"] = kwargs.get("name", "-")
    profile["gender"] = kwargs.get("gender", "-")
    profile["birthday"] = kwargs.get("birthday", "-")
    profile["age"] = kwargs.get("age", "-")
    profile["phone"] = kwargs.get("phone", "-")
    profile["email"] = kwargs.get("email", "-")
    
    return profile

profile = set_profile(
    name="lee",
    gender="man",
    age=32,
    birthday="01/01",
    email="python@sparta.com",
)

print(profile)
# result print
"""
{   
    'name': 'lee',
    'gender': 'man',
    'birthday': '01/01',
    'age': 32,
    'phone': '-',
    'email': 'python@sparta.com'
}
"""

다)args / kwargs 같이 사용

def print_arguments(a, b, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)
    
print_arguments(
    1, # a
    2, # b
    3, 4, 5, 6, # args
    hello="world", keyword="argument" # kwargs
)

# result print
"""
1
2
(3, 4, 5, 6)
{'hello': 'hello', 'world': 'world'}
"""

나. 패킹과 언패킹

1)패킹과 언패킹

• 요소를 묶거나 풀어주는 것
• list 혹은 dictionary의 값을 함수에 입력할 때 주로 사용.

2)list에서의 활용

def add(*args):
    result = 0
    for i in args:
        result += i
        
    return result

numbers = [1, 2, 3, 4]

print(add(*numbers)) # 10

3)dictionary에서의 활용

def set_profile(**kwargs):
    profile = {}
    profile["name"] = kwargs.get("name", "-")
    profile["gender"] = kwargs.get("gender", "-")
    profile["birthday"] = kwargs.get("birthday", "-")
    profile["age"] = kwargs.get("age", "-")
    profile["phone"] = kwargs.get("phone", "-")
    profile["email"] = kwargs.get("email", "-")
    
    return profile

user_profile = {
    "name": "lee",
    "gender": "man",
    "age": 32,
    "birthday": "01/01",
    "email": "python@sparta.com",
}

print(set_profile(**user_profile))
""" 아래 코드와 동일
profile = set_profile(
    name="lee",
    gender="man",
    age=32,
    birthday="01/01",
    email="python@sparta.com",
)
"""

# result print
"""
{
    'name': 'lee',
    'gender': 'man',
    'birthday': '01/01',
    'age': 32,
    'phone': '-',
    'email': 'python@sparta.com'
}

"""

다. 객체지향

1)객체지향

• 객체를 모델링하는 방향으로 코드 작성
• 다른 언어에서도 사용됨.

2)객체지향의 특성

• 캡슐화
  특정 데이터의 액세스를 제한해 데이터가 직접적으로 수정되는 것을 방지, 검증된 데이터만 사용
• 추상화
  사용되는 객체의 특성 중 , 필요한 부분만 사용하고 필요하지 않은 부분은 제거하는 것
• 상속
  상속은 기족에 작성 된 클래스의 내용을 수정하지 않고 그대로 사용하기 위해 사용되는 방식
  클래스 선언할 때 상속받을 클래스 지정 가능
• 다형성
  하나의 객체가 다른 여러객체로 재구성 되는 것을 의미
  오버라이드, 오버로드가 다향성을 나타내는 대표적인 예시

3)객체지향의 장/단점

• 장점
  클래스의 상속을 활용하기 때문에 코드의 재사용성이 높아짐
  데이터를 검증하는 과정이 있기때문에 신뢰도가 높음
  모델링하기 수월
  보안성 높음
• 단점
  난이도 높음
  코드의 실행속도가 비교적 느림
  객체의 역할과 기능을 정의하고 이해해야하기때문에 개발 속도 느려짐

4)객체지향 예제 코드

import re

# 숫자, 알파벳으로 시작하고 중간에 - 혹은 _가 포함될 수 있으며 숫자, 알파벳으로 끝나야 한다.
# @
# 알파벳, 숫자로 시작해야 하며 . 뒤에 2자의 알파벳이 와야 한다.
email_regex = re.compile(r'([A-Za-z0-9]+[.-_])*[A-Za-z0-9]+@[A-Za-z0-9-]+(\.[A-Z|a-z]{2,})+')

class Attendance:
    count = 0
        
    def attendance(self):
        self.count += 1
    
    @property
    def attendance_count(self):
        return self.count

class Profile(Attendance):
    def __init__(self, name, age, email):
        self.__name = name # __를 붙여주면 class 내부에서만 사용하겠다는 뜻
        self.__age = age
        self.__email = email
    
    @property # 읽기 전용 속성
    def name(self):
        return self.__name
    
    @name.setter # 쓰기 전용 속성
    def name(self, name):
        if isinstance(name, str) and len(name) >= 2:
            print("이름은 2자 이상 문자만 입력 가능합니다.")
            
        else:
            self.__name = name
    
    @property
    def age(self):
        return self.__age
    
    @age.setter
    def age(self, age):
        if isinstance(age, int):
            self.__age = age
            
        else:
            print("나이에는 숫자만 입력 가능합니다.")
        
    @property
    def email(self):
        return self.__email
    
    @email.setter
    def email(self, email):
        if re.fullmatch(email_regex, email):
            self.__email = email
        else:
            print("유효하지 않은 이메일입니다.")
        
    def attendance(self): # override
        super().attendance() # 부모 메소드 사용하기
        self.count += 1
    
    def __str__(self):
        return f"{self.__name} / {self.__age}"
    
    def __repr__(self):
        return f"{self.__name}"