Python Class

생성자

class Test:
    def __init__(self):
        self.a = 0        self.b = 0
    def setData(self, x, y):
        self.a = x
        self.b = y
        print(id(self))

    def show(self):
        print(self.a, self.b)

obj = Test()
print(id(obj))
obj.setData(100,200)
obj.show()

소멸자

class Test:
    def __init__(self):
        self.a = 0
        self.b = 0

    def setData(self, x, y):
        self.a = x
        self.b = y
        print("setData", id(self))

    def show(self):
        print("show", self.a, self.b)

    def __del__(self):
        print("del")


t = Test()
t.setData(10, 20)
t.show()
s = t
del(t) # target memory object를 지우는게 아니다. 참조 변수만 지우는 것이다.
print("hello")

t = Test()
t = 100 # 기존 Test() target object는 ref count가 0이되어 삭제 된다.
다른 참조가 혹시 있으면 그 참조가 없어질 때까지 삭제되지 않는다.


클래스 변수나 static 함수는 반드시 클래스 이름을 붙여줘야 한다.

class Test:
    st = 10 # class 변수 # Instance 생성과 무관. py 파일 해석시 바로 메모리에 할당됨.   

    def __init__(self, x, y): # 인스턴스 함수       

        print("init")
        self.a = x  # 인스턴스 변수        

        self.b = y

    def setData(self, x, y):
        st = 10 # 이건 지역 변수다 !!!        

        Test.st = 10 # 이건 class 변수다 !!!        

        self.a = x
        self.b = y
        print("setData", id(self))

    def show(self):
        Test.sfn() # static 함수 호출 시
        print("show", self.a, self.b)

    def sfn(): # static 함수       

        print("sfn")


print (Test.st)
Test.st = 100

print (Test.st)
a = Test(10, 20)
Test.sfn()
a.show()

class My:
    count = 0    def __init__(self):
        My.count += 1
    def showCount():
        print(My.count)

o1 = My()
o2 = My()
o3 = My()
My.showCount()


static 메소드와 달리 class 메소스는 class이름을 첫번째 인자로 받는다.



Class 함수와 Static 함수는 다르다.
class Test:
    st = 10 # class 변수 # Instance 생성과 무관. py 파일 해석시 바로 메모리에 할당됨.
    def __new__(cls, *args, **kwargs):
        print("new call")
        return object.__new__(cls)
    def __init__(self): # 인스턴스 함수        print("init call")
        self.a = 0        self.b = 0
obj = Test()

# 모든 python 클래스는 object라는 클래스를 자식 클래스다.
# object.__new__(cls)가 실제 객체 생성하는 일을 함.
#1. obj = Test.__new__(Test)  # 실제 객체 메모리 잡는 과정
#2. obj.__init__(obj)

# not thread-safe solution

class MySingle:
    __instance = None    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def setData(self, x, y):
        self.x = x
        self.y = y


obj1 = MySingle()
obj2 = MySingle()
print(id(obj1), id(obj2))



상속

class People:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def setName(self, name):
        self.name = name

class Student(People):

    def __init__(self, name, age, stdnum):
        super().__init__(name,age)
        self.stdnum = stdnum


std = Student("홍", 20, 2323)
std.setName("이")