파이썬 -상속 및 함수

1. 상속

# 상속
# 상속이라는 것은 상위 개념을 적용받은 하위 개념을 만들 때
# 사용하는 것이다.(하향식)
# 상속을 하는 클래스는 부모 클래스라고 부르며,
# 상속을 함으로써 상속받는 자식 클래스는
# 부모 클래스가 정의한 속성, 메서드 등등을
# 그대로 (재)사용할 수 있게 된다.

# 혹은 상속받은 것을 수정하거나
# 자식 클래스만의 새로운 무언가를 추가할 수도 있다.

# 부모 클래스, 슈퍼 클래스, 상위 클래스
# 상위 클래스를 먼저 만들고 하위 클래스를 만드는 것을
# 하향식 클래스 작성이라고 부른다.
# 이런 방식은 기초 개념(공통 개념)을 정립한 후
# 구체적인 개념을 추가하는 방식에서 주로 쓰인다.
class Person:
    def __init__(self, name) -> None:
        self.name = name
        pass

    def walk(self, floor:str):
        """
        floor: 어디를 걷고 있는 설명해보자.
        """
        print(f"{self.name}이(가) {floor} 위로 걸어갑니다.")

# 자식 클래스, 서브 클래스, 하위 클래스
# 부모 클래스로부터 속성, 메서드(init 제외)를 그대로 가져와서
# 사용할 수 있는 클래스를 말한다.
# 부모 클래스로부터 상속받은 정보를 수정해서 사용하거나
# 새로운 자신만의 속성이나 기능(메서드)을 추가할 수 있다.
# 상속받은 내용은 재작성할 필요가 없기 때문에
# 개발시간을 단축할 수 있다(생산성 향상)

# 같은 부모 클래스를 상속받은 자식 클래스들은
# 부모 클래스가 정의한 메서드를 모두 가지고 있기 때문에
# 일괄적인, 일관적인 관리와 사용이 가능하다.
class Male(Person):
    def __init__(self, name) -> None:
        # super().__init__(name)
        self.name = name
    
    def walk(self, floor: str):
        # return super().walk(floor)
        # 재정의(override)
        # 부모 클래스에 정의된 메서드를
        # 가리고 스스로가 만든 내용으로 변경하는 것
        print(f"{self.name} 님이 {floor} 위로 걸어갑니다.")

class Female(Person):
    def __init__(self, name) -> None:
        super().__init__(name)
    
    def walk(self, floor: str):
        # return super().walk(floor)
        print(f"{self.name}씨가 {floor}로 된 복도를 걸어갑니다.")

if __name__ == "__main__":
    # m = Male("홍길동")
    # f = Female("홍순자")
    # people: list[Person] = [m, f]
    # 다형성
    # 자식 클래스가 부모 클래스로부터 상속받음으로써
    # 속성과 메서드 뿐만 아니라 부모 클래스라는 "타입"도
    # 상속 받는다.
    # for p in people:
    #     print(p.name)
    #     p.walk("대리석")

    # 원시 타입과 참조 타입
    # 원시타입은 값 그 자체가 들어가 있는 저장공간을 의미한다.
    # 변수에 원시타입의 값을 담아서 다른 변수에 담으면
    # 값만 복사된다.
    num = 3
    num2 = num + 5 # 8
    num += 2    # num == 5
    print(num2) # 8
    # 기존 num을 사용한 것에 대해서
    # 이후에 num의 값을 바꿔도
    # 이전 연산에 영향을 주지 않는다.

    # 참조 타입(클래스)
    # 참조 타입은 값이 위치한 주소값을 담고 있기 때문에
    # 다른 변수에 대입하면 값이 아니라 주소값을 전달한다.
    # 이때 주소값을 가진다는 것은 "참조한다"라고 표현하며
    # 참조 대상이 같은 경우(주소값이 같다면)
    # 같은 대상을 바라보고 있는 것이기 때문에
    # 같은 주소값을 가졌다면 같은 값에 접근할 수 있다.
    철수네집 = Person("철수")
    철수엄마네집 = 철수네집

    # 주소값이 같은지 확인
    print(f"철수네집: {철수네집}")
    print(f"철수엄마네집: {철수엄마네집}")
    print("=============")
    철수네집.name = "홍길동"
    print(f"철수name:\n{철수네집.name}\n")
    print(f"철수엄마name:\n{철수엄마네집.name}")
  
 -->
#8
#철수네집: <__main__.Person object at 0x0000022FD6AF9D50>
#철수엄마네집: <__main__.Person object at 0x0000022FD6AF9D50>
=============
#철수name:
#홍길동

#철수엄마name:
#홍길동

 

2. 이터레이터

# 이터레이터
# 반복 가능한 객체, 즉 이터러블 객체에 대해서
# 그 요소를 순차적으로 하나씩 반환 할 수 있는
# 객체를 의미한다.
# 한번에 하나의 요소에 접근하여
# 메모리 효율적이다.




if __name__ == "__main__":
    nums = [e for e in range(3)]
    iter_nums = iter(nums)
    # print(next(iter_nums))
    # print(next(iter_nums)*2)
    # print(next(iter_nums)*3)

    # 기존 값의 길이를 활용하여 반복
    #iterator 객체는 len()함수에 넣을 수 없다.
    # for i in range(len(nums)):
    #     print(next(iter_nums))
    
    # enumerate()
    # 전달된 이터러블 객체의 각 요소에 인덱스를 부여해서
    # (index,element)와 같은 방식으로 tuple 자료형의 값을
    # #반환하는 함수이다.
    nums = [e*3 for e in range(4)]
    # for i, e in enumerate(nums):
    #     print(f"{i:2d}. {e:2d}")       

    for enum in enumerate(nums):
        print(type(enum))
   -->
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>

 

3. 함수 길이

class Num:
    def __init__(self, value) -> None:
        self.value = value
    
    # __str__(self)
    # 출력했을 때 나오는 값을 설정하는 매직 메서드
    def __str__(self) -> str:
        # 해당 클래스 타입을 가지고 있는지 확인하는 함수
        if isinstance(self.value, Num):
            return str(self.value.value)
        else:
            return str(self.value)
    
    def __add__(self, other):
        print(self.value)
        print(other.value)
        return self.value + (other.value if isinstance(other, Num) else other)
    
    def __len__(self):
        return len(str(self.value))
    
if __name__ == "__main__":
    n = Num(30)
    n2 = Num(15)
    # print(str(n)) # 30
    # print(n)      # 30
    
    print(n + n2)
    print(len(n))
    # print(len(312)) #숫자의 길이는 할수 없음
 -->
#30
#15
#45
#2

 

4. unpacking

# unpacking
# 메서드에서 값을 반환할때,
# 여라개의 값을 반환하면
# tuple 형태로 packing하여 반환된다.
# 이때, 메서드를 사용한 쪽에서
# 변수에 담으려고 할때, 반환된 튜플 요소의 개수가
# 담으려는 변수의 개수와 동일하다면 ->다르면 오류
# 순서에 맞게 값이 변수에 각가 담긴다.


def split_name(name:str, len_lastname:int=1):
    last_name = name[0:1] # 성 부분
    first_name = name[1:] #이름 부분
    return last_name, first_name

if __name__ == "__main__":
    print(split_name("홍길동"))      # ('홍', '길동')
    print(split_name("남궁길동", 2))  # ('남', '궁길동')


def split_name(name:str, len_lastname:int=1):
    last_name = name[0:len_lastname] # 성 부분
    first_name = name[len_lastname:] #이름 부분
    return last_name, first_name

if __name__ == "__main__":
    성, 이름 = split_name("남궁길동", 2)   
    print(f"성:{성}, 이름:{이름}")   # 성:남궁, 이름:길동