Python 기초 018 - 클래스 생 성 및 실례 화, 클래스 계승

4566 단어
클래스 생 성 및 실례 화, 클래스 계승
  • 클래스 의 생 성 및 실례 화
  • 정의: 같은 속성 과 방법 을 가 진 대상 의 집합 을 묘사 하 는 데 사용 된다.이 집합 에서 모든 대상 이 공유 하 는 속성 과 방법 을 정의 합 니 다.대상 은 클래스 의 인 스 턴 스 입 니 다.
  • 유형 명 은 보통 대문자 로 시작 하 는데 이것 은 표준 적 인 관례 이다.
  • eg: class BookShop(object):

  • 실례 화 --- > 클래스 의 구체 적 인 대상 을 만 듭 니 다.
  • 방법: 클래스 에서 정 의 된 함수
  • 대상: 클래스 를 통 해 정 의 된 데이터 구조 인 스 턴 스;두 개의 데이터 구성원 (클래스 변수 와 인 스 턴 스 변수) 과 방법
  • 을 포함 합 니 다.
  • 클래스 변 수 는 클래스 에서 함수 체 를 제외 한 것 으로 정의 합 니 다.인 스 턴 스 변 수 는 방법 에 정 의 된 변수 로 현재 인 스 턴 스 의 클래스 에 만 작 동 합 니 다.
  • #      
    In [3]: class Employee(object):
    ...:     empCount = 0                                        
    ...:     def __init__(self,name,salary):                     #      
    ...:         self.name=name
    ...:         self.salary = salary
    ...:         Employee.empCount += 1
    ...:     def displayCount(self):
    ...:         print 'Total Employee %d' % Employee.empCount
    ...:     def displayEmployee(self):
    ...:         print 'Name:',self.name, 'salary:',self.salary
    ...:         
    
    In [4]: emp1 = Employee('Zara',2000)                        #          
    In [5]: emp2 = Employee('Manni',5000)
    In [6]: emp1.displayEmployee()                              #            
    Name: Zara salary: 2000
    In [7]: emp2.displayEmployee()
    Name: Manni salary: 5000
    In [8]: print 'Total Employee %d' % Employee.empCount       #        
    Total Employee 2
    In [9]: emp1.age = 7                                        #     age  
    In [10]: emp1.displayEmployee() 
    Name: Zara salary: 2000
    In [11]: emp1.age = 8                                       #     age  
    In [13]: hasattr(emp1, 'age')                               #              
    Out[13]: True
    In [14]: getattr(emp1, 'age')                               #       
    Out[14]: 8
    In [15]: setattr(emp2, 'age', 18)                           #       
    In [16]: getattr(emp2, 'age')
    Out[16]: 18
    In [17]: delattr(emp1, 'age')                               #       
    In [18]: hasattr(emp1, 'age')
    Out[18]: False
    
    
  • _init_마법 방법 은 대상 을 만 들 때 사용 되 며, 자동 으로 호출 되 며, 여기에서 속성 을 초기 화 할 수 있 습 니 다.
  • self 대표 클래스 의 인 스 턴 스 는 첫 번 째 에 있어 야 합 니 다. self 는 클래스 를 정의 하 는 방법 에 있어 야 합 니 다. 호출 할 때 해당 하 는 매개 변 수 를 입력 하지 않 아 도 되 지만.
  • self 도 클래스 방법 과 일반 방법의 특별한 차이 점 입 니 다. > 그들 은 반드시 추가 적 인 첫 번 째 매개 변수 이름 이 있어 야 합 니 다. 관례 에 따라 self 여야 합 니 다.
  • self 는 python 키워드 가 아니 라 다른 것 으로 바 꿔 도 정상적으로 실행 할 수 있 습 니 다.

  • 대상 을 향 한 각종 마법 속성
  • _init_마법 방법: 이 방법 은 대상 을 만 들 때 사용 합 니 다. 자동 으로 호출 됩 니 다. 여기 서 속성 을 초기 화 할 수 있 습 니 다
  • _str_마법 방법: 대상 이 문자열 로 전 환 될 때 자동 으로 호출 되 며, 반환 값 이 있어 야 합 니 다.
  • _new_마법 방법: 대상 을 만 들 고 대상 의 값 을 되 돌려 줍 니 다.
  • 재init_이전 호출
  • 호출new_,인 스 턴 스 대상 되 돌리 기
  • 호출init, 호출new 가 되 돌아 오 는 인 스 턴 스 대상 은 self
  • 에 게 매개 변수 로 되 돌려 줍 니 다.

  • 클래스 계승
  • 정의: 파생 클래스 (derived class) 계승 기본 클래스 (base class) 의 필드 와 방법 입 니 다.
  • 한 클래스 가 다른 클래스 인지 아 닌 지 를 issubclass 로 판단 할 수 있다
  • #     
    In [20]: class Parent(object):
    ...:     parentAttr  = 100
    ...:     def __init__(self):
    ...:         print '        '
    ...:     def parentMethod(self):
    ...:         print '      '
    ...:     def setAttr(self, attr):
    ...:         Parent.parentAttr = attr
    ...:     def getAttr(self):
    ...:         print "    :",Parent.parentAttr
    ...: class Child(Parent):
    ...:     def __init__(self):
    ...:         print "        "
    ...:     def childMethod(self):
    ...:         print '      '
    ...:         
    
    In [21]: c = Child()                        #      
            
    In [23]: c.childMethod()                    #       
          
    In [25]: c.parentMethod()                   
          
    In [27]: c.setAttr(200)                     #     
    In [28]: c.getAttr()
        : 200
    In [33]: issubclass(Child,Parent)           #          
    Out[33]: True
    
    #     
    In [38]: class P1(object):
    ...:     def foo(self):
    ...:         print 'called P1-foo()'
    ...: class P2(object):
    ...:     def foo(self):
    ...:         print 'called P2-foo()'
    ...:     def bar(self):
    ...:         print 'called P2-bar()'
    ...: class C1(P1,P2):
    ...:     def bar(self):
    ...:         print 'called C1-bar()'
    ...:         
    In [39]: c = C1()                           #      
    In [40]: c.foo()                            #     P1    ,     P1      P2   
    called P1-foo()
    In [41]: c.bar()                            #               ,             
    called C1-bar()
    
    

    좋은 웹페이지 즐겨찾기