Python 대상 멤버 에 대한 지식 총화

23921 단어 Python구성원
구성원
 1.1 변수
  • 인 스 턴 스 변 수 는 대상 에 속 하고 모든 대상 에서 자신의 데 이 터 를 유지 합 니 다.
  • 가지 변 수 는 클래스 에 속 하고 모든 대상 에 게 공유 할 수 있 으 며 일반적으로 대상 에 게 공공 데 이 터 를 제공 하 는 데 사용 된다(전체 변수 와 유사).
  • 
    class Person(object):
        country = "  "
     
        def __init__(self, name, age):
            self.name = name
            self.age = age
     
        def show(self):
            # message = "{}-{}-{}".format(Person.country, self.name, self.age)
            message = "{}-{}-{}".format(self.country, self.name, self.age)
            print(message)
     
    print(Person.country) #   
     
     
    p1 = Person("    ",20)
    print(p1.name)
    print(p1.age)
    print(p1.country) #   
     
    p1.show() #   -    -20
    
    알림:모든 대상 에 존재 하 는 같은 예제 변 수 를 선택 할 때 클래스 변수 에 넣 으 면 대상 에서 같은 데 이 터 를 여러 개 유지 하 는 것 을 피 할 수 있 습 니 다.
    오류 점
  • 읽 기와 쓰기 의 차이 에 주의 하 세 요.
  • 
    class Person(object):
        country = "  "
     
        def __init__(self, name, age):
            self.name = name
            self.age = age
     
        def show(self):
            message = "{}-{}-{}".format(self.country, self.name, self.age)
            print(message)
     
    print(Person.country) #   
     
    p1 = Person("    ",20)
    print(p1.name) #     
    print(p1.age) # 20
    print(p1.country) #   
    p1.show() #   -    -20
     
    p1.name = "root"     #    p1  name   root
    p1.num = 19          #    p1        num=19
    p1.country = "china" #    p1        country="china"
     
    print(p1.country)   # china
    print(Person.country) #   
    
    
    class Person(object):
        country = "  "
     
        def __init__(self, name, age):
            self.name = name
            self.age = age
     
        def show(self):
            message = "{}-{}-{}".format(self.country, self.name, self.age)
            print(message)
     
    print(Person.country) #   
     
    Person.country = "  "
     
     
    p1 = Person("    ",20)
    print(p1.name) #     
    print(p1.age) # 20
    print(p1.country) #   
    
  • 상속 관계 중의 읽 기와 쓰기
  • 
    class Base(object):
        country = "  "
     
     
    class Person(Base):
     
        def __init__(self, name, age):
            self.name = name
            self.age = age
     
        def show(self):
            message = "{}-{}-{}".format(Person.country, self.name, self.age)
            # message = "{}-{}-{}".format(self.country, self.name, self.age)
            print(message)
     
     
    #  
    print(Base.country) #   
    print(Person.country) #   
     
    obj = Person("    ",19)
    print(obj.country) #   
     
    #  
    Base.country = "china"
    Person.country = "  "
    obj.country = "  "
    
    1.2 방법
  • 바 인 딩 방법 은 기본적으로 self 매개 변수 가 있 고 대상 에 의 해 호출 됩 니 다(이때 self 는 호출 방법의 이 대상 과 같 습 니 다)[대상&클래스 모두 호출 가능]
  • 가지 방법 은 기본적으로 cls 매개 변수 가 있 습 니 다.클래스 나 대상 으로 모두 호출 할 수 있 습 니 다(이때 cls 는 호출 방법의 이 종류 와 같 습 니 다)[대상&클래스 는 모두 호출 가능]
  • 정적 방법 으로 기본 매개 변수 가 없 으 며 클래스 와 대상 을 모두 호출 할 수 있 습 니 다.[대상&클래스 모두 호출 가능]
  • 
    class Foo(object):
     
        def __init__(self, name,age):
            self.name = name
            self.age = age
     
        def f1(self):
            print("    ", self.name)
     
        @classmethod
        def f2(cls):
            print("   ", cls)
     
        @staticmethod
        def f3():
            print("    ")
            
    #     (  )
    obj = Foo("   ",20)
    obj.f1() # Foo.f1(obj)
     
     
    #    
    Foo.f2()  # cls            。( )
    obj.f2()  # cls               。
     
     
    #     
    Foo.f3()  #        ( )
    obj.f3()  #         
    
    Python 에서 비교적 유연 하고 방법 은 대상 과 클래스 를 통 해 호출 할 수 있 습 니 다.자바,c\#등 언어 에서 바 인 딩 방법 은 대상 에서 만 호출 할 수 있 습 니 다.클래스 방법 이나 정적 방법 은 클래스 에서 만 호출 할 수 있 습 니 다.
    
    import os
    import requests
     
     
    class Download(object):
     
        def __init__(self, folder_path):
            self.folder_path = folder_path
     
        @staticmethod
        def download_dou_yin():
            #     
            res = requests.get('.....')
     
            with open("xxx.mp4", mode='wb') as f:
                f.write(res.content)
     
        def download_dou_yin_2(self):
            #     
            res = requests.get('.....')
            path = os.path.join(self.folder_path, 'xxx.mp4')
            with open(path, mode='wb') as f:
                f.write(res.content)
     
     
    obj = Download("video")
    obj.download_dou_yin()
    
    1.3 속성
    속성 은 바 인 딩 방법+특수 장식 기 조합 으로 만들어 진 것 으로 앞으로 호출 방법 에 괄호 를 넣 지 않 아 도 됩 니 다.
    
    class Foo(object):
     
        def __init__(self, name):
            self.name = name
     
        def f1(self):
            return 123
     
        @property
        def f2(self):
            return 123
     
     
    obj = Foo("    ")
     
    v1 = obj.f1()
    print(v1)
     
    v2 = obj.f2
    print(v2)
    
    
    class Pagination:
        def __init__(self, current_page, per_page_num=10):
            self.per_page_num = per_page_num
            
            if not current_page.isdecimal():
                self.current_page = 1
                return
            current_page = int(current_page)
            if current_page < 1:
                self.current_page = 1
                return
            self.current_page = current_page
    	
        def start(self):
            return (self.current_page - 1) * self.per_page_num
    	
        def end(self):
            return self.current_page * self.per_page_num
     
     
    user_list = ["  -{}".format(i) for i in range(1, 3000)]
     
    #     ,    10 
    while True:
        page = input("     :")
    	
        # page,       
        # 10,    10   
    	#     Pagination  init  。
        pg_object = Pagination(page, 20)
        
        page_data_list = user_list[ pg_object.start() : pg_object.end() ]
        for item in page_data_list:
            print(item)
    
    
    class Pagination:
        def __init__(self, current_page, per_page_num=10):
            self.per_page_num = per_page_num
     
            if not current_page.isdecimal():
                self.current_page = 1
                return
            current_page = int(current_page)
            if current_page < 1:
                self.current_page = 1
                return
            self.current_page = current_page
     
        @property
        def start(self):
            return (self.current_page - 1) * self.per_page_num
     
        @property
        def end(self):
            return self.current_page * self.per_page_num
     
     
    user_list = ["  -{}".format(i) for i in range(1, 3000)]
     
    #     ,    10 
    while True:
        page = input("     :")
     
        pg_object = Pagination(page, 20)
        page_data_list = user_list[ pg_object.start : pg_object.end ]
        
        for item in page_data_list:
            print(item)
    
    속성 에 대한 작성 은 두 가지 방법 이 있 습 니 다.
  • 방식 1.장식 기 를 바탕 으로
  • 
    class C(object):
        
        @property
        def x(self):
            pass
        
        @x.setter
        def x(self, value):
            pass
        
        @x.deleter
        def x(self):
    		pass
            
    obj = C()
     
    obj.x
    obj.x = 123
    del obj.x
    
  • 방식 2.정의 변 수 를 바탕 으로
  • 
    class C(object):
        
        def getx(self): 
    		pass
        
        def setx(self, value): 
    		pass
            
        def delx(self): 
    		pass
            
        x = property(getx, setx, delx, "I'm the 'x' property.")
        
    obj = C()
     
    obj.x
    obj.x = 123
    del obj.x
    
    메모:속성 과 실례 변수의 호출 방식 이 같 기 때문에 작성 할 때 주의해 야 합 니 다.속성 이름 은 실례 변수의 이름 을 바 꾸 지 마 십시오.
    
    class Foo(object):
     
        def __init__(self, name, age):
            self.name = name
            self.age = age
     
        @property
        def func(self):
            return 123
     
     
    obj = Foo("    ", 123)
    print(obj.name)
    
    일단 이름 을 바 꾸 면 잘못 보고 할 수도 있다.
    
    class Foo(object):
     
        def __init__(self, name, age):
            self.name = name  #   ,         @name.setter      。
            self.age = age
     
        @property
        def name(self):
            return "{}-{}".format(self.name, self.age)
     
     
    obj = Foo("    ", 123)
    
    
    class Foo(object):
     
        def __init__(self, name, age):
            self.name = name 
            self.age = age
     
        @property
        def name(self):
            return "{}-{}".format(self.name, self.age) #   ,      (        )
     
        @name.setter
        def name(self, value):
            print(value)
     
     
    obj = Foo("    ", 123)
    print(obj.name)
    
    이름 에 관 계 를 만 들 려 면 인 스 턴 스 변 수 를 밑줄 로 그 을 수 있 습 니 다.
    
    class Foo(object):
     
        def __init__(self, name, age):
            self._name = name
            self.age = age
     
        @property
        def name(self):
            return "{}-{}".format(self._name, self.age)
     
     
    obj = Foo("    ", 123)
    print(obj._name)
    print(obj.name)
    
    2.멤버 장식 부적
    Python 에서 구성원 의 수식 부 는 공유,사유 라 는 것 을 말한다.
  • 공유 로 어디서 든 이 멤버 를 호출 할 수 있다.
  • 사유 로 클래스 내부 에서 만 구성원 을 호출 할 수 있 습 니 다(구성원 은 두 개의 밑줄 로 시작 하면 이 구성원 을 사유 로 합 니 다).
  • 
    class Foo(object):
     
        def __init__(self, name, age):
            self.__name = name
            self.age = age
     
        def get_data(self):
            return self.__name
     
        def get_age(self):
            return self.age
     
     
    obj = Foo("    ", 123)
     
     
    #     
    print(obj.age)
    v1 = self.get_age()
    print(v1)
     
    #     
    # print(obj.__name) #   ,       ,         。
    v2 = obj.get_data()
    print(v2)
    
    특히 부모 클래스 의 개인 구성원 은 하위 클래스 가 계승 할 수 없다 는 것 을 일 깨 워 준다.
    
    class Base(object):
     
        def __data(self):
            print("base.__data")
     
        def num(self):
            print("base.num")
     
     
    class Foo(Base):
     
        def func(self):
            self.num()
            self.__data() # #              
     
     
    obj = Foo()
    obj.func()
    
    
    class Base(object):
     
        def __data(self):
            print("base.__data")
     
        def num(self):
            print("base.num")
            self.__data()  #              
     
     
    class Foo(Base):
     
        def func(self):
            self.num()
     
     
    obj = Foo()
    obj.func()
    
    이치대로라면 개인 구성원 은 외부 에서 호출 될 수 없 지만 특수 한 문법 을 사용 해도 된다.
    
    class Foo(object):
     
        def __init__(self):
            self.__num = 123
            self.age = 19
     
        def __msg(self):
            print(1234)
     
     
    obj = Foo()
    print(obj.age)
    print(obj._Foo__num)
    obj._Foo__msg()
    
    구성원 이 독립 된 기능 으로 외부 에 노출 되 어 외부 에서 호출 되 고 사용 할 수 있 습 니까?
  • 네,공유 합 니 다.
  • 안 됩 니 다.내부 에 다른 보조,사유 가 있 습 니 다.
  • 3.대상 끼 워 넣 기
    대상 을 대상 으로 프로 그래 밍 을 할 때 대상 간 에 여러 가지 관계 가 존재 할 수 있다.예 를 들 어 조합,관련,의존 등(자바 의 호칭)은 큰 말로 여러 가지 포 함 된 것 이다.
    상황 1:
    
    class Student(object):
        """     """
     
        def __init__(self, name, age):
            self.name = name
            self.age = age
     
        def message(self):
            data = "      ,  :{},   {} ".format(self.name, self.age)
            print(data)
     
    s1 = Student("    ", 19)
    s2 = Student("    ", 19)
    s3 = Student("    ", 19)
     
     
     
    class Classes(object):
        """     """
     
        def __init__(self, title):
            self.title = title
            self.student_list = []
     
        def add_student(self, stu_object):
            self.student_list.append(stu_object)
     
        def add_students(self, stu_object_list):
            for stu in stu_object_list:
                self.add_student(stu)
     
        def show_members(self):
            for item in self.student_list:
                # print(item)
                item.message()
     
    c1 = Classes("    ")
    c1.add_student(s1)
    c1.add_students([s2, s3])
     
    print(c1.title)
    print(c1.student_list)
    
    상황 2:
    
    class Student(object):
        """     """
     
        def __init__(self, name, age, class_object):
            self.name = name
            self.age = age
            self.class_object = class_object
     
        def message(self):
            data = "    {}    ,  :{},   {} ".format(self.class_object.title, self.name, self.age)
            print(data)
     
     
    class Classes(object):
        """     """
     
        def __init__(self, title):
            self.title = title
     
     
    c1 = Classes("Python  ")
    c2 = Classes("Linux   ")
     
     
    user_object_list = [
        Student("    ", 19, c1),
        Student("    ", 19, c1),
        Student("    ", 19, c2)
    ]
     
    for obj in user_object_list:
        print(obj.name,obj.age, obj.class_object.title)
    
    상황 3:
    
    class Student(object):
        """     """
     
        def __init__(self, name, age, class_object):
            self.name = name
            self.age = age
            self.class_object = class_object
     
        def message(self):
            data = "    {}    ,  :{},   {} ".format(self.class_object.title, self.name, self.age)
            print(data)
     
     
    class Classes(object):
        """     """
     
        def __init__(self, title, school_object):
            self.title = title
            self.school_object = school_object
     
     
    class School(object):
        """     """
     
        def __init__(self, name):
            self.name = name
     
     
    s1 = School("    ")
    s2 = School("    ")
     
    c1 = Classes("Python  ", s1)
    c2 = Classes("Linux   ", s2)
     
    user_object_list = [
        Student("    ", 19, c1),
        Student("    ", 19, c1),
        Student("    ", 19, c2)
    ]
    for obj in user_object_list:
        print(obj.name, obj.class_object.title ,  obj.class_object.school_object.name)
    
    특수 구성원
    Python 클래스 에 특수 한 방법 이 존재 합 니 다.이런 방법 은 모두 __ __ 형식 입 니 다.이런 방법 은 내부 에서 모두 특수 한 의 미 를 가지 고 있 습 니 다.그 다음 에 흔히 볼 수 있 는 특수 멤버 들 에 게 말씀 드 리 겠 습 니 다.
  • __init__,초기 화 방법
  • 
    class Foo(object):
        def __init__(self, name):
            self.name = name
     
     
    obj = Foo("    ")
  • __new__,구조 방법
  • 
    class Foo(object):
        def __init__(self, name):
            print("   :     ,         ")
            self.name = name
     
        def __new__(cls, *args, **kwargs):
            print("   :         ")
            return object.__new__(cls)
     
     
    obj = Foo("    ")
    
  • __call__
  • 
    class Foo(object):
        def __call__(self, *args, **kwargs):
            print("  call  ")
     
     
    obj = Foo()
    obj()
  • __str__
  • 
    class Foo(object):
     
        def __str__(self):
            return "    "
     
     
    obj = Foo()
    data = str(obj)
    print(data)
  • __dict__
  • 
    class Foo(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age
     
     
    obj = Foo("    ",19)
    print(obj.__dict__)
  • __getitem____setitem____delitem__
  • 
    class Foo(object):
     
        def __getitem__(self, item):
            pass
     
        def __setitem__(self, key, value):
            pass
     
        def __delitem__(self, key):
            pass
     
     
    obj = Foo("    ", 19)
     
    obj["x1"]
    obj['x2'] = 123
    del obj['x3']
    
  • __enter____exit__
  • 
    class Foo(object):
     
        def __enter__(self):
            print("   ")
            return 666
     
        def __exit__(self, exc_type, exc_val, exc_tb):
            print("   ")
     
     
    obj = Foo()
    with obj as data:
        print(data)
    
    \#면접 문제(코드 추가,다음 기능 구현)
    
    class Context:
     
        def __enter__(self):
            return self        
     
        def __exit__(self, exc_type, exc_val, exc_tb):
            pass
     
        def do_something(self):      # __enter__  self       do_something  
            pass
     
     
    with Context() as ctx:
        ctx.do_something()
    
    상술 한 면접 문 제 는 상하 문 관리의 문법 에 속한다.
  • __add__
  • 
    class Foo(object):
        def __init__(self, name):
            self.name = name
     
        def __add__(self, other):
            return "{}-{}".format(self.name, other.name)
     
     
    v1 = Foo("alex")
    v2 = Foo("sb")
     
    #   + ,         .__add__  ,  +            。
    v3 = v1 + v2
    print(v3)
    
  • __iter__
  • 교체 기
    
    #         :
        1.       __iter__   __next__     。
        2.__iter__           , :self
        3. __next__   ,       ,       ,       StopIteration   。
    	    :https://docs.python.org/3/library/stdtypes.html#iterator-types
            
    #          :
    	class IT(object):
            def __init__(self):
                self.counter = 0
     
            def __iter__(self):
                return self
     
            def __next__(self):
                self.counter += 1
                if self.counter == 3:
                    raise StopIteration()
                return self.counter
     
    #                :
        obj1 = IT()
        
        # v1 = obj1.__next__()
        # v2 = obj1.__next__()
        # v3 = obj1.__next__() #     
        
        v1 = next(obj1) # obj1.__next__()
        print(v1)
     
        v2 = next(obj1)
        print(v2)
     
        v3 = next(obj1)
        print(v3)
     
     
        obj2 = IT()
        for item in obj2:  #            __iter__        ,         next(  ) 
            print(item)    
    
    교체 기 대상 은 next 를 통 해 값 을 추출 하 는 것 을 지원 하 며,값 이 끝나 면 자동 으로 StopIteration 을 던 집 니 다.
    for 순환 내부 가 순환 할 때 먼저 실행iter__방법,교체 기 대상 을 가 져 온 다음 에 계속 실행 되 는 next 값(이상 StopIteration 이 있 으 면 순환 을 종료 합 니 다).
    생 성기
    
    #        
        def func():
            yield 1
            yield 2
        
    #        (         generator     ),           :__iter__、__next__   。
        obj1 = func()
        
        v1 = next(obj1)
        print(v1)
     
        v2 = next(obj1)
        print(v2)
     
        v3 = next(obj1)
        print(v3)
     
     
        obj2 = func()
        for item in obj2:
            print(item)
    
    교체 기의 규정 에 따 르 면 생 성기 류 도 특수 한 교체 기 류(생 성기 도 하나의 특수 한 교체 기)이다.
    교체 가능 대상
    
    #        __iter__             ;                   。
     
    class Foo(object):
        
        def __iter__(self):
            return      (     )
        
    obj = Foo() # obj       。
     
    #           for     ,             __iter__   ,        ,                next  ,    。
    for item in obj:
        pass
    
    교체 가능 대상 은 for 를 사용 하여 순환 할 수 있 으 며,순환 하 는 내부 에 서 는 사실 먼저 실행iter__ 방법 은 교체 기 대상 을 가 져 온 다음 에 내부 에서 이 교체 기 대상 의 next 기능 을 실행 하여 점차적으로 값 을 추출 합 니 다.
    
    class IT(object):
        def __init__(self):
            self.counter = 0
     
        def __iter__(self):
            return self
     
        def __next__(self):
            self.counter += 1
            if self.counter == 3:
                raise StopIteration()
            return self.counter
     
     
    class Foo(object):
        def __iter__(self):
            return IT()
     
     
    obj = Foo() #      
     
     
    for item in obj: #         ,     obj.__iter__        ;           next  。
        print(item)
    
    
    #        &     :   range
    class IterRange(object):
        def __init__(self, num):
            self.num = num
            self.counter = -1
     
        def __iter__(self):
            return self
     
        def __next__(self):
            self.counter += 1
            if self.counter == self.num:
                raise StopIteration()
            return self.counter
     
     
    class Xrange(object):
        def __init__(self, max_num):
            self.max_num = max_num
     
        def __iter__(self):
            return IterRange(self.max_num)
     
     
    obj = Xrange(100)
     
    for item in obj:
        print(item)
    
    
    class Foo(object):
        def __iter__(self):
            yield 1
            yield 2
     
     
    obj = Foo()
    for item in obj:
        print(item)
    
    #        &      :   range
     
    class Xrange(object):
        def __init__(self, max_num):
            self.max_num = max_num
     
        def __iter__(self):
            counter = 0
            while counter < self.max_num:
                yield counter
                counter += 1
     
     
    obj = Xrange(100)
    for item in obj:
        print(item)
    
    일반적인 데이터 형식:
    
    from collections.abc import Iterator, Iterable
     
    v1 = [11, 22, 33]
    print( isinstance(v1, Iterator) )  # false,        ;     __iter__   __next__。
    v2 = v1.__iter__()
    print( isinstance(v2, Iterator) )  # True
     
     
     
    v1 = [11, 22, 33]
    print( isinstance(v1, Iterable) )  # True,         __iter__        。
     
    v2 = v1.__iter__()
    print( isinstance(v2, Iterable) )  # True,         __iter__        。
    
    이로써 파 이 썬 의 진급 대상 을 대상 으로 하 는 구성원 들 의 정 리 를 마 쳤 습 니 다.부당 한 점 이 있 으 면 지적 을 환영 합 니 다.
    파 이 썬 이 대상 을 대상 으로 하 는 멤버 들 에 대한 지식 을 정리 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 파 이 썬 멤버 들 의 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 응원 부 탁 드 리 겠 습 니 다!

    좋은 웹페이지 즐겨찾기