1.權限訪問：

公開的（public）：類的里面、類的外面都可以使用，也可以被繼承
保護的（protect）：類的里面可以使用，類的外面不能使用，可以被繼承
私有的（private）：類的里面可以使用，類的外面不能使用，也不能被繼承

2.python中類的內(nèi)容的訪問權限

嚴格來說，python類中的內(nèi)容只有公開的；私有化是假的私有化

3.怎么私有化

在方法名前或者屬性名前加(但是名字后面不加)
原理：不是真的私有化，而是在_開頭的屬性和方法名前加了‘類名’

class Preson:
      num = 61
      __num2 = 100
      def __init__(self,name,age = 18):
            self.name = name
            self.age = age
            self.gender = "男"
            self.gender = "男"

      def func1(self):
            print('%s今年%d歲' % (self.name,self.age),self.__gender)
            self.func11()

      def __func11(self):
            print('私有的對象方法')
      
      @staticmethod
      def func2():
            print("我是靜態(tài)方法1")
      
      @staticmethod
       def __func22():
            print("我是靜態(tài)方法1")

      @classmethod
       def  func3(cls):
              print(cls.num)
              print(cls.__num2)
print("=============默認公開的屬性和方法在類的外面都可以用=========")
print(Person.num)

p1 = Person('小明')
print(p1.name,p1.age,p1.gender)

p1.func1()

Person.func2()
print("============私有的屬性和方法=============")
# print(Person.__num2)    # AttributeError: type object 'Person' has no attribute '__num2'
Person.func3()
# print(p1.__gender)  # AttributeError: 'Person' object has no attribute '__gender'
# p1.__func11()   # AttributeError: 'Person' object has no attribute '__func11'
# Person.__func22()   # AttributeError: type object 'Person' has no attribute '__func22'

print(p1.__dict__)   # 可以看到名字
print(p1._Person__gender)
print(Person._Person__num2)

1.getter和setter

1)什么時候使用
如果希望在對象屬性賦值前做點兒別的什么事情就會給這個屬性添加setter
如果希望在獲取屬性值之前做點兒別的什么事情就給這個屬性添加getter

2）怎么用
getter：
a.將需要添加getter的屬性名前加_
b.聲明函數(shù)：聲明前加@property；
函數(shù)名就是不帶_的屬性名；
函數(shù)需要一個返回值，返回值就是獲取這個屬性能夠得到的值
c.在外面使用屬性的時候不帶下劃線

setter：
注意：如果想要給屬性添加setter必須先添加getter
a.聲明函數(shù)：聲明前加@getter名.setter;
函數(shù)名就是不帶_的屬性名；
函數(shù)不需要返回值，但是需要一個參數(shù)，這個參數(shù)就是給屬性賦的值
b.在外面給屬性賦值的時候不帶下劃線

class Person:
        def __init__(self,age:int):
             self.age = age
             self._time = 0
        
        @ property
        def time(self):
              t_time = time.localtime(self._time)
              return '{}-{}-{} {}:{}:{}',format(t_tiame.tm_year,t_time.tm_mon,t_time.tm_mday,t_time.tm_hour,t_time.tm_min,t_time.tm_sec)
    
        @property
          def age(self):
                return  self._age


        @ age.setter
          def age(self,value):
                  print("value:",value)
                  if isinstance(value,int):
                          if 0<= value <= 200:
                              self._age = value
                          else:
                              raise ValueError
                  else:
                          raise ValueError
p1 = Person(10)
p1.age = 18
# p1.age = 'abc'
# p1.age = [1, 2, 3]
# p1.age = 19273897298

print(p1.time)

class Circle:
        pi = 3.1415926

        def __init__(self,r):
              self.r = r
              self._area = 0

       @property
       def area(self):
              return Circle.pi * self.f * self.r

        @area.setter
        def area(self,value):
              print(給area屬性賦值:',value)
              raise ValueError

c1 = Circle(1)

print(c1.area)  # 本質(zhì)是在調(diào)用area函數(shù)：c1.area()

c1.r = 10
print(c1.area)  # 本質(zhì)是在調(diào)用area函數(shù):c1.area()

c1.r = 3
print(c1.area)  # 本質(zhì)是在調(diào)用getter的area函數(shù)：c1.area()

# c1.area = 31.4   # 本質(zhì)是在調(diào)用setter的area函數(shù): c1.area(31.4)
# c1.area = 1000   # 本質(zhì)是在調(diào)用setter的area函數(shù): c1.area(1000)

1.什么是繼承

繼承是讓子類直接擁有父類的屬性和方法
子類 - 繼承者(兒子）
父類 - 被繼承者（爸爸），又叫超類

2.怎么繼承

語法：
class 類名（父類1，父類2，……）：
類的說明文檔
類的內(nèi)容

3.繼承那些東西

父類所有的屬性和方法都會繼承

class Person(object):
         num = 61
         
         def __inti__(self):
               self.name = '小明'
               self.age = 18

         @staticmethod
          def func1():
                 print("靜態(tài)方法")


class Student(Preson):
          pass

# 子類直接使用父類的屬性和方法
print(Student.num)
Student.func1()

stu = Student()
print(stu.name,stu.age)

4.子類中添加屬性和方法

1）添加字段和方法
在子類中直接聲明新的字段和方法；
注意：如果添加的字段名和方法名和父類的字段方法同名了，子類中的字段和方法會覆蓋父類的字段和方法 ->重寫

2）添加對象屬性
在自己的init方法中添加新的屬性，并且需要通過super（）去調(diào)用父類init方法繼承父類的對象屬性

5.super的應用

可以在類中任何一個方法或者類方法中通過super（）調(diào)用父類的對象想方法或者類方法

super（類1，類1的對象）.方法（） --> 調(diào)用類1的父類中的方法
super（）.方法 等價于 super（當前類，當前類的對象）

super（type，obj) -> 要求obj必須是type的對象或者是type的子類對象

class Animal:
    num = 100

    def __init__(self):
        self.age = 10
        self.gender = '雌'

    @staticmethod
    def a_func1():
        print('動物的對象方法1')

    @staticmethod
    def func1():
        print('動物中的靜態(tài)方法')

    def func2(self):
        print('動物中的對象方法2')

    @classmethod
    def func4(cls):
        print('動物中的類方法')


class Cat(Animal):
    voice = '喵~'

    def __init__(self):
        super().__init__()    # 調(diào)用當前類的父類的__init__方法
        self.color = '白色'
        self.breed = '加菲貓'


    @classmethod
    def c_func1(cls):
        print('貓的類方法')

    @staticmethod
    def func1():
        print('貓中的靜態(tài)方法')
        # 注意: 靜態(tài)方法中不能直接使用super()
        # super().a_func1()

    def func3(self):
        super().func2()
        print('貓中的對象方法')

    @classmethod
    def func5(cls):
        print('貓中的類方法2')
        super().func4()


print(Cat.num, Cat.voice)
Cat.a_func1()
Cat.c_func1()
Cat.func1()   # 貓中的靜態(tài)方法
Animal.func1()  # 動物中的靜態(tài)方法

cat1 = Cat()
print(cat1.age, cat1.gender)
print(cat1.color, cat1.breed)

print('===============super================')
cat1.func3()
Cat.func5()

class A:
    def func(self):
        print('this is A')


class B(A):
    def func(self):
        print('this is B')


class D(A):
    def func(self):
        print('this is D')

class C(B):
    def func(self):
        # super().func()
        # super(C, self).func()
        # super(B, self).func()
        # super(D, D()).func()
        # super(A, A()).func()
        print('this is C')

obj = C()

# ==> super().func()
# obj.func()  # this is B; this is C

# ==> super(C, self).func()
# obj.func()   #  this is B;  this is C

# ==> super(B, B()).func()  /  super(B, self).func()
# obj.func()    # this is A;  this is C

# ==> super(D, D()).func()
# obj.func()    # this is A;  this is C

# ==> super(A, A()).func()
# obj.func()    # AttributeError: 'super' object has no attribute 'func'

多繼承

class Animal:
    num = 100

    def __init__(self, age=0, gender='雄'):
        self.age = age
        self.gender = gender

    def a_func1(self):
        print('動物的對象方法')

    def message(self):
        print('this is Animal')


class Fly:
    flag = '飛行'

    def __init__(self, height=1000, time=3):
        self.height = height
        self.time = time

    @classmethod
    def f_func1(cls):
        print('飛行的類方法')

    def message(self):
        print('this is Fly')


class Bird(Animal, Fly):
    pass


class A1:
    def message(self):
        super(Bird, Bird()).message()


b1 = Bird()

# 字段都可以繼承
print(Bird.num, Bird.flag)

# 方法都可以繼承
b1.a_func1()
Bird.f_func1()

# 對象屬性只能繼承第一個父類的
print(b1.age, b1.gender)
# print(b1.height, b1.time)   # AttributeError: 'Bird' object has no attribute 'height'

b1.message()

A1().message()

class A:
    def message(self):
        print('this is A')


class B:
    def message(self):
        print('this is B')


class C(A, B):
    def message(self):
        super().message()
        print('this is C')


# this is A
# this is C
C().message()

print('=================================================')
# 查看繼承順序: 先畫出和需要的類相關聯(lián)的所有的父類的繼承關系，然后從左往右看沒有子類的類

class A:
    def message(self):
        print('this is A')


class B(A):
    def message(self):
        super().message()
        print('this is B')


class C(A):
    def message(self):
        super().message()
        print('this is C')


class D(B, C):
    def message(self):
        super().message()
        print('this is D')

class E(C):
    def message(self):
        super().message()
        print('this is E')

class F(D, E):
    def message(self):
        super().message()
        print('this is F')

class G(F):
    def message(self):
        super().message()
        print('this is G')

D().message()
"""
'this is A'
'this is B'
'this is D'
"""
print(D.__mro__)
print('=========================================')
F().message()

print('==================================================')
class A:
    def message(self):
        print('this is A')

class B:
    def message(self):
        super().message()
        print('this is B')


class C(B, A):
    def message(self):
        super().message()
        print('this is C')

class D(B):
    def message(self):
        super().message()
        print('this is D')

class E(C):
    def message(self):
        super().message()
        print('this is E')

class F(D, E):
    def message(self):
        super().message()
        print('this is F')


class K(F):
    def message(self):
        super().message()
        print('this is K')


F().message()
print(F.__mro__)