python class와 method

클래스의 원형

#[Step 01:  클래스 선언 ]
class Test: # object의  후손 클래스가 되어 선조의 메소드들을 참조하고 있다.    object <- Test
    # class UserName :
    # 1.class안의 모든 메소드의 첫번째 매개인자는 self가 지정되어있다.
    # 2.모든 메소드에 self로 변수 또는 메소드를 호출해서 구현할 수 있다.
    
    def empty(self):
       self.data = []

    def add(self, x):
       self.data.append(x)

if __name__ == '__main__':
#[Step 02:  클래스 객체 생성  ]
    my01 = Test()    # 객체 생성
    my02 = Test()
    print(my01) # 주소 출력
    print(my02)

    my01.empty() #메소드 호출
    my01.add(10)
    print(my01.data) # 값 대입 받은 변수 확인
    my03 = my01 #my01 주소 복사
    print(my03.data) # my01과 같은 data 출력
    print(my03) # my01을 복사했기 때문에 주소가 동일

# [Step03 :  멤버 호출]
     my01.empty()
     my02.empty()
     for  i in range(1,6):
         my01.add(i)
     print(my01.data)
     print(my02.data) # my02에는 데이터가 없으므로 비어있다. = []
     print(my01, my02) # 주소 출력

💡
class 안의 모든 메소드의 첫번째 매개인자는 self 지정
객체생성은 java의 new 생성자와 같다.

#이름 , 주소 , 전화 번호를 관리하는 Address 라는 클래스를 선언해서 변수로 값을 저장해 보자
# 정적 변수  static 변수   클래스.멤버변수
class Address:
   name="Dominica"
   addr = "seoul"
   tel ="02-0000-000"
   def prn(self):  # 멤버 메소드
       print(Address.name, Address.addr, Address.tel) #정적호출
       
if __name__ == '__main__':
   print(Address.name, Address.addr, Address.tel)
   #Dominica seoul 02-0000-000
   Address.name ="1111111111111" #Address클래스의 name을 변경
   print(Address.name, Address.addr, Address.tel) # 111로 변경된 후 출력
   #1111111111111 seoul 02-0000-000

   a1 = Address() #주소복사
   a1.prn()  # 메소드출력
   #1111111111111 seoul 02-0000-000

Address.name == 정적호출 (클래스 변수를 직접 호출한다.)
a1= Address() == 객체생성(주소복사)

#__class__ : 인스턴스가 자신을 생성한 클래스 객체를 참조하기 위하여 파이선에서 제공하는 키워드로 클래스영역(heap)에
# 모든 인스턴스 객체에  있는 데이터를 참조하거나 수정할 때 사용한다.
'''
사원 번호    7월 영업실적
a111          850
b111          750
c111          650
Emp 라는 클래스를 만들어서  변수를 2개 선언한 후  a1,b1,c1의 이름으로 객체를 생성한 다음 값을 전달 후 출력 해 보자.
'''

class Emp:
    empno =0
    result=0
    
if __name__ == '__main__':

    a1=Emp()
    a1.empno ='a111'
    a1.result =850
    print(a1.empno, a1.result)
	# a111 500

    b1=Emp()
    b1.empno ='b111'
    b1.result = 750
    print(b1.empno , b1.result)
	# b111 700

    c1=Emp()
    c1.empno='c111'
    c1.result= 650
    print(c1.empno, c1.result)
	# c111 600
    #정적 호출
    print(Emp.empno, Emp.result)
    # 0 0 출력
    # Emp클래스의 변수들의 값은 0 이기 때문
	
    #클래스 명명 , 객체의 타입을 외부에서 참조
    print(Emp.__name__, type(a1.__class__) , b1.__class__ , c1.__class__)
  # Emp <class 'type'> <class '__main__.Emp'> <class '__main__.Emp'>

캡슐화

# 캡슐화 : 은닉된 멤버 변수에 오픈된 메소드로 값을 전달(setXX)  및  변경하는 구조(getXX return)
# getter & setter
class Test:
    __b=100 #객체 생성 후 호출할 수 없고, Test의 멤버만 접근 가능하다. #__ = 강한(strong) private
    def __m(self): #한문자를 리턴하는 private 메소드
        return 'a'
    def k(self):
        print(self.__m(), self.__b)


if __name__ == '__main__':
    my = Test()
    my.k()
    #print(my.__b)오류 ,,!!Test.__b X

__x= 강한 private 객체 생성 후 호출할 수 없다.

# 정수형 변수 a,b 를 관리하는 클래스를 만들어 보자. 단 캡슐화로 구현 해보자.
# 은닉된 멤버 변수에게  setxx으로 값 전달 및 변경하고   getxx return 메소드로 리턴하는 구조
class Test:
    __a=0  #주소 히든 private 초기값은 생성자에서 대입
    __b=0
    #name ="abc"   def setName():~~
    def setA(self, a):
        self.__a =a  # 객체 생성후 값을 a 로 전달받아  멤버__a 에게 값전달 및 변경
    def getA(self):
       return self.__a

    def setB(self,b):
        self.__b=b
    def getB(self):
        return self.__b

    def gethap(self):
        return (self.__a+self.__b)

    def gethsub(self):
        return (self.__a - self.__b)


if __name__ == '__main__':
    t1 = Test()
    t1.setA(100) 
    print(t1.getA())
    t1.setB(200)
    print(t1.getB())
    print('hap=',t1.gethap())
    t1.setA(300) # a값 변경
    print('sub=',t1.gethsub())

생성자와 소멸자

#생성자와 소멸자를 살펴보자.
# 생성자를 명시하지 않으면 자동으로 내부호출되어 생성되고 명시하게 되면 명시된 생성자가 호출된다.
# 생성자는 단한번 객체를 생성할 때 자동 호출되며 해당클래스의 모든 멤버를 동적 할당 메모리로 로드하게 된다.
# 생성자의 목적은 멤버변수 초기화에 있다.

class MyDel:

    #생성자가 2개일 경우 2번째 생성자가 출력된다. (덮어쓰기)
    def __init__(self, a=100):  #생성자
        self.a=a
        print("__ init__",a)

    # def __init__(self):
    #     print("__ init__")

    def __del__(self):  #소멸자 객체가 소멸되는 시점에서 호출 되면서 리소스 해제
        print("나 소거된다. 현재 클래스에서 호출되거나 참조한 다른클래스를 멤버로 가질때  소거한다.  ")

if __name__ == '__main__':
    # 1. 기본 객체를 생성하자
    m1 = MyDel()


    # a1 = MyDel(200)  #MyDel이라는 클래스를 생성자를 호출하면서 객체 생성한다.
    # print(a1.a)
    # MyDel.a=10000   #
    # print(MyDel.a, a1.a)

같은 생성자가 여러개 있을 경우 가장 아래에 있는 생성자가 출력
소멸자는 객체가 소멸되는 시점에 호출된다.

상속

#간단한  구조의 상속을  구현해 보자.
# 이름과 나이를 관리하는  Person 클래스있다.
# Student클래스 Person을 상속을 받아 학년만 추가해서  이름, 나이, 학년을 모두 출력하는 클래스를 만들고 싶다.
# this, super  = self, super | java => super(name,age,b)  | python => super().__init__(name,age,b)

'''
1. 상속 구조 : 후손클래스 (선조클래스):
2. 후손 클래스에서 선조의 멤버를 호출하는 방법 및 상속 받는 멤버
3. 생성자를 호출하는 방법과 메소드를 호출하는 방법
#1. return  self.personInfo() + ",grade :"+ str(self.grade) #self.선조의 멤버
#2. return super().personInfo()+ ",grade :"+ str(self.grade) # super().선조의 멤버
#3. return Person.personInfo(self)+ ",grade :"+ str(self.grade) #선조의 class명.선조의 멤버(self)
'''

class Person:
    __b = 10 #강한 private 형식은 멤버만 호출이 가능하다 후손은 호출이 불가능하다.
    def __init__(self, name, age,b): #5. 선조의 객체가 생성되면서 멤버변수에게 값전달
        self.name = name
        self.age = age
        self.__b=b
    def personInfo(self):  #멤버변수 출력용 메소드  + 연결연산자는 시퀀스의 같은 객체끼리 연결이 가능하다. str+str
        return  self.name  +": (age :" +  str(self.age) +")"

class Student(Person): #2
    def __init__(self,name, age,b, grade):#3
        # Person.__init__(self,name,age) #4 선조의 생성자
        super().__init__(name,age,b) # self가 필요없음?
        self.grade = grade #6. 객체 생성 하면서 grade변수 값전달

    def GetStudent(self):
        # print("b= " ,  self.__b) #선조의 멤버의 private은 상속받지 못한다.
        # 1. return  self.personInfo() + ",grade :"+ str(self.grade)
        # 2. return super().personInfo()+ ",grade :"+ str(self.grade) #self와동일
        return Person.personInfo(self)+ ",grade :"+ str(self.grade) #선조의 class명 + self
if __name__ == '__main__':
    x=Student("Ruri",7,3,5) #1.Student("Ruri",7,3) 7.생성된 선조의 주소를 리턴
    print(x.GetStudent())

생성자 호출 방법과 메소드 호출 방법

• return self.메소드이름
• return super().메소드이름
• return 클래스.메소드이름(self)

선조와 후손

#super() : 선조 클래스를 의미한다. 명시적으로 후손 클래스에서 선조의 변수나 메소드를 참조할때 사용한다.
#후손클래스에서 후손이 가진 값을 선조 클래스의 생성자를 호출해서 대입하려면 super()키워드를 사용한다.
class AA:
    def __init__(self):
        print("나 AA 생성자 ")

class BB(AA):
    def __init__(self):
        super().__init__() #선조의 기본 생성자를 호출
        #AA.__init__(self)
        print("나 BB 생성자 ")

if __name__ == '__main__':
    #a1 = AA()  #생성자를 호출하면서 객체가 생성되면 자유영역공간 메모리 할당된다.
    b1=BB()  # AA()  <- BB() 선조가 생성 된후  후손이 생성

후손 클래스에서 선조 클래스의 메소드를 호출(대입) 하려면 super()키를 사용해야 한다.

class MyScore:
    def __init__(self,kor,eng):
        self.kor =kor
        self.eng= eng
    def getTot(self):
        print("선조")
        return(self.kor + self.eng)

class MyScore_Sub(MyScore):
    def __init__(self, kor,eng,mat):
        # super().__init__(kor,eng)
        MyScore.__init__(self,kor,eng) #__init__메소드 동일하게 넣어준다
        self.mat=mat
    def getTot(self):
        print("후손 메소드")
        # return (super().getTot()+ self.mat) #후손이 선조의 동일한 이름의 메소드를 호출한 것
        return MyScore.getTot(self)+ self.mat

if __name__ == '__main__':
    #print(MyScore(20,30).getTot())
    print(MyScore_Sub(100,100,100).getTot()) #상속시에 재정의된 후손의 메소드가 호출된다.

a1 = MyScore(10,20) #객체 생성
    print(a1.getTot())
    

추상메소드 (abstractmethod)

from abc import abstractmethod, ABCMeta
class Base(metaclass=ABCMeta):
    @abstractmethod
    def start(self):
        print("base start")
    @abstractmethod
    def Stop(self):
        print("base stop")

class Cat(Base):
    def start(self):
        print("cat start")
    def Stop(self):
        print("cat stop")
class Duck(Base):
    def start(self):
        print("duck start")
    def Stop(self):
        print("duck stop")
class Puppy(Base):
    def start(self):
        print("puppy start")

    def Stop(self):
        print("puppy stop")
def MY_Call(m):
    print(m.__class__)
    m.start()
    m.Stop()
if __name__ == '__main__':
    MY_Call(Puppy())
    MY_Call(Cat())
    MY_Call(Duck())

@abstractmethod를 걸고 java의 추상메소드 처럼 사용할 수 있다.

다중상속

#하나 이상의 선조를 가진 다중상속을 받은 클래스가 선조의 메소드를 호출하는 방법
#선조의 생성자에게 값 전달 하는 것


class Dog:
    def sound(self):
     print ("bark" )
    def AA(self):
     print("Dog'AA ")

class Cat:
    def sound(self):
        print ("meow")
    def BB(self):
       print("Cat's BB ")

#다중 상속에 경우 class명으로 명시하여 호출하자. 1. O ,2.X
class Chimera(Dog,Cat):
    def sound(self):
        #1 어떤 클래스의 메소드인지 알수있다
        Cat.sound(self)
        Dog.sound(self)
        #2 어떤 클래스의 메소드인지 모름
        super().sound()
        super().AA()
        print("Chimera")

if __name__ == '__main__':
    Chimera().sound()   #    a1 = Chimera() ;  a1.sound()

다중상속에 경우 class명으로 명시하여 호출하는것이 좋다.
es) Cat.sound(self)

@property (getter & setter)

# @property : 메소드를 변수로 호출할 수 있도록 지정
class My:
    def __init__(self):
        self.x=0

    @property      #@mFun.getter의 의미를 가진다. 값을 받는 변수로 변환
    def mFun(self):   # 멤버 변수 x를 리턴하는 UserMethod    /   print(a.mFun)
        return  self.x

    @mFun.setter
    def mFun(self, x): #멤버 변수 x에게 지역변수 x가 값을 받아 전달 및 변경하는 UserMethod
        self.x = x

if __name__ == '__main__':
    a = My()
    a.mFun = 100
    print(a.mFun)

@property == (getter)
@메소드이름.setter