파이썬 클래스에 관한 모든 것

참조 :

wayhome25.github.io/cs/2017/04/05/cs-07/

강의노트 07. [객체지향] 클래스 / 인스턴스 변수, 클래스 / 인스턴스 / 스태틱 메소드 · 초보몽키

---

■ 클래스에 선언할 수 있는 모든 것

클래스의 기본에 대해 이해하고 있다고 가정

대부분의 클래스는 다음의 어느 항목을 포함하고 있음

class Point:
    a = 10 # 클래스 변수
    
    def __init__(self, x, y):
        self._x = x # 인스턴스 변수, class 내부변수
        self.__y = y # hidden 변수

    @classmethod 
    def class_method(cls):
        print("클래스 메소드 호출!", cls.a)
	
    
    @staticmethod
    def static_method():
    	print("스태틱 매소드 호출!")
        
    def instance_func(self): # 인스턴스 메소드
        print("인스턴스 메소드 호출!")

    def __str__(self):
    	print("매직 매소드 호출!")
        return "({}, {})".format(self._x, self.__y)

---

---

■ 인스턴스 변수

p1 = Point(1, 2)
p1.__dict__  # 인스턴스의 심볼 테이블 확인
# {'_x': 1, '__y': 2}

Point.__dict__  # 클래스의 심볼 테이블 확인
# 'a': 10,
# 'class_method': <classmethod at 0x10d5a2ba8>,
# 'instance_func': <function __main__.Point.instance_func>})

 

 

■ 인스턴스 메소드

1) 인스턴스 생성되어야 실행 가능

Point.instance_func() # TypeError 발생
>>>
Traceback (most recent call last):
  File "<string>", line 23, in <module>
TypeError: instance_func() missing 1 required positional argument: 'self'

p = Point(1,2)
p.instance_func()

>>> 인스턴스 메소드 호출!

2) 객체에서 클래스 변수 접근 불가능

class Point:
    a = 10 # 클래스 변수
    def __init__(self, x, y):
        self._x = x # 인스턴스 변수, class 내부변수
        self.__y = y # hidden 변수

    @classmethod 
    def class_method(cls):
        print("클래스 메소드 호출!", cls.a)
	
    
    @staticmethod
    def static_method():
    	print("스태틱 매소드 호출!")
        
    def instance_func(self): # 인스턴스 메소드
        print("인스턴스 메소드 호출!")

    def __str__(self):
    	print("매직 매소드 호출!")
    	return "({}, {})".format(self._x, self.__y)
    

p = Point(1,2)
p.a = 5
print(p.a, Point.a)

>>> 5 10  # 이미 생성된 부분

> but 인스턴스 메소드에서 클래스 변수 수정은 가능

class Point:
    a = 10 # 클래스 변수
    def __init__(self, x, y):
        self._x = x # 인스턴스 변수, class 내부변수
        self.__y = y # hidden 변수

    @classmethod 
    def class_method(cls):
        print("클래스 메소드 호출!", cls.a)
	
    
    @staticmethod
    def static_method():
    	print("스태틱 매소드 호출!")
        
    def instance_func(self): # 인스턴스 메소드
        print("인스턴스 메소드 호출!")

    def __str__(self):
    	print("매직 매소드 호출!")
    	return "({}, {})".format(self._x, self.__y)
    
    """이부분이 추가 됨! """
    def change_classVar(self):
        Point.a -= 5

p.change_classVar()
print(p.a, Point.a)

>>> 5, 5

---

■ 클래스 변수

1) 모든 인스턴스 객체가 공유

- 인스턴스 보다 상위에 존재하는 클래스 namespace 에서 참조 가능

 

 

 

■ 클래스 메소드

1) 클래스 메소드는 클래스에서 바로 호출 가능

Point.class_method()

>>> 클래스 메소드 호출! 10 # cls.a

2) 주로 생성자 오버로딩으로 쓰임

- 생성자 오버로딩이란?

  C / Java 등에서 Python  __init__ 의 기본 생성 사항을 같은 class 내부에서 선언을 중복해서 오버로딩하여

  생성자를 오버로딩 하는 것을 의미

- 파이썬은 그렇게 __init__을 중복하여 오버로딩할 수 없기 때문에 밑에와 같이 구현

  (오버로딩 안되고 가장 밑에 선언 된 __init__ 사용)

class Person:
    
    nationality = "USA"
    
    # none을 받게 함
    def __init__(self, var1=None, var2=None, var3=None):
        self.v1 = var1
        self.v2 = var2
        self.v3 = var3
    
    def printNamespace(self):
        print(self.__dict__)
    
    @classmethod
    def changeNation(cls):
        if cls.nationality != "UK":
            cls.nationality = "UK"

        elif cls.nationality != "USA":
            cls.nationality = "USA"

    
    @classmethod # 생성자 오버로딩
    def createUser(cls, str_input:str) -> 'Person':
        
        _list = str_input.split(',')
        if len(_list) in [0,1]:
            # 생성에 대한 restriction 존재
            # 모든 생성자 param에 대한 존재 check
            # / 특정 생성자 param None을 피하고 싶을 때
            raise ValueError('no valid string value')
        elif len(_list) in [2]:
            return cls(var1=_list[0], var2=_list[1])
        else:
            return cls(var1=_list[0], var2=_list[1], var3=_list[2])


u1 = Person.createUser('Jane Doe,21,female')
u2 = Person.createUser('John Doe,22')

u1.printNamespace()
u2.printNamespace()

>>> {'v1': 'Jane Doe', 'v2': '21', 'v3': 'female'}
>>> {'v1': 'John Doe', 'v2': '22', 'v3': None}

print(u1.nationality)
>>> USA
print(u2.nationality)
>>> USA

# 클래스 변수 change
u1.changeNation()

print(u1.nationality)
>>> UK
print(u2.nationality)
>>> UK

---

■ 스태틱 메소드

1) 클래스 안에 "일반 함수" 를 가져다 놓는 것과 유사

2) 상속시 차이가 남 

class momClass(object):
    name = 'mom'

    @staticmethod
    def get_name_static():
        print(momClass.name) # 애시당초 원본 클래스 변수 참조하고 있음

    @classmethod
    def get_name_class(cls):
        print(cls.name)

# momClass를 상속받는 sonClass 정의
class sonClass(momClass):
    name = 'son'

sonClass.get_name_static() # mom : momClass의 name 속성을 반환  
sonClass.get_name_class() # son : sonClass의 name 속성을 반환

>>> mom
>>> son