一。

1.访问的权限
公开的（public）:类的里面外面都可以用，也可以被继承
保护的（protect）:类的里面可以使用，也可以被继承，外面不能用。
私有的（private）:类的里面可以用，外面不能用，也不能被继承。
2.python中的内容的访问的权限
严格来说，python类中的内容只有公开的，私有化是假的私有化的。
3.怎么私有化？
在方法或者属性名前加 _ _ （方法和 属性）， 类里面可以用 ，外面用不了。

class Person:
    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('我是静态方法1')

    @staticmethod
    def __func22():
        print('我是静态方法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('===============私有的属性和方法==========')

4.他在内部改名字了 把 gender 改成 '_Person__gender'。

原理：不是真的私有化，而是在_开头的属性名和方法名加了"类名 。

二.继承。

1.什么是继承？
继承是子类直接拥有父类的属性和方法。
子类---继承者
父类---被继承者，又叫超类。
2.如何继承。

class 类名（父类1，父类2.。。。）
        类的说明文档
        类的类容

3.继承的实例。

class Person:
     num=61
    def __init__(self,name):
        self.name=name
        self.age=18
    @staticmethod
    def func1():
        print("静态方法")
class Student(Person): #Person就是Student的父类。
    pass
  #子类的直接使用父类的属性和方法。
print(Student.num)
Student.fun1()

4.继承哪些东西

父类所有的属性和方法，子类都会继承。

5.子类中添加属性和方法：
(1)添加方法和字段
在子类中直接声明新的字段和方法。用父类的就直接用，
如果字段和方法名和父类的字段方法同名了，子类中的字段和方法会覆盖父类的字段和方法，这个现象叫做重写。重写了调用子类是重写的，但是调用父类的还是原来的。

（2）添加对象属性
在自己的init方法中添加新的属性，并且通过super()去调用父类的init方法去继承父类的对象属性。
6.super应用。
super可以在类中任何一个对象方法或则类方法中去通过super()调用父类的方法，静态方法中不能使用super()调用。

super(类1，类1的对象).方法（）--调用类1的父类中的方法。

super().方法（）===super(当前类，当前类的对象) ----调用当前类的父类的方法。

注意：super(type,obj)要求obj必须是type的对象或则是type的子类的对象。 调用的是 type的父类的方法。

super()去调用父类的方法，super().init(父类的参数)

# =============子类的添加属性和方法=============
class Animal:
    num=100
    def func2(self):
        print("动物的方法")
class Cat(Animal):
    voice="喵"
    @staticmethod
    def fun4(self):
        print("猫的函数。。。。")

    def func2(self):
        print("子类中重写的父类")  #子类重写方法
# ==================添加对象属性====================--super
class Animal:
    num=100
    def __init__(self):
        self.age = 10
        self.gender = "雄"
    def func2(self):
        print("动物的方法")

class Cat(Animal):
    voice="喵"
    def __init__(self,color,breed):
        super().__init__() #调用当前父类的init方法
        self.color="白色"
        self.breed="加菲猫"#添加自己的init方法不会调用父类的init方法。
    @staticmethod
    def fun4(self):
        print("猫的函数。。。。")

cat1=Cat("黑色","tumao")
print(cat1.gender,cat1.age)

三.多继承

1.多继承就是继承多个父类。

class Animal:
    num=100
    def __init__(self,age=0,gender="雄"):
        self.age=age
        self.gender=gender
    def a_func1(self):
        print("动物的对象方法")
class Fly:
    flag="飞行"
    def __init__(self,height=1000,time=3):
        self.height=height
        self.time=time
    @classmethod
    def f_fun1(cls):
        print("飞行的方法")

class Bird(Animal,Fly):
    pass
b1=Bird()

1.字段可以继承
print(Bird.num,Bird.flag)
2.方法都可以继承
b1.a_func1()
b1.f_fun1()
3.对象属性只能第一个父类的，
print(b1.age,b1.gender)

print(b1.height,b1.time)因为这个是第二个父类的所以继承不了

4.获取继承关系的方法：（主要应付面试）
1.print（类.mro）--获取类的继承关系图。
2.画出关系图。
（1）
画的时候看括号里的继承关系，前面在左边。
（2）看继承关系从下往上看，先取没有后代的，都没有后代，从左往右看。
（3）先画出需要类的所有的继承关系的父类，从左往右看没有子类的类就行了。
补充自己写的继承：

class A:
    def message(self):
        print("this is  a")
class B:
    def message(self):
        super().message()
        print("this is b")
class C(A):
    def message(self):
        super().message()
        print("this is c ")
class D(C,A):
    def message(self):
        super().message()
        print("thsi is D")
class F(B,D):
    def message(self):
        super().message()
        print("this is f")


F().message()
继承的关系是：
this is  a
this is c 
thsi is D
this is b
this is f
继承关系：
f--b--d-c--a

四。getter和setter

一。时间戳的概念
1970 年1月1日0时0秒的时间差，单位为秒。
tim.time()获取当前的世间，格式是时间戳
time.loctime(时间戳)----把时间戳变成当前的时间。
二。getter和setter
1.如果希望在获取属性值之前做点别的什么事情就给这个属性加getter.
2.如果需要在给对象赋值前做别的什么事情就给这个属性加setter.
第一：getter的用法：
1.将需要添加getter的属性名加一个下划线。
2.声明函数：
声明前加@property
函数名不带_的属性名（不带下划线）
函数需要返回值，返回值就是获取这个属性能够得到的值。
3.再次调用这个属性的时候是不需要加下划线的。
============getter例子============

class Person:
    def __init__(self,age):
        self.age=10
        self._time=1243214324.32432432
    @property
    def time(self):
        t_time=time.localtime(self._time)
        return t_time
p1=Person(10)
p1.age=18
p1.age="abc"
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.r*self.r




c1=Circle(1)
print(c1._area)
c1.r=10
print(c1.area)

第二：setter的用法。
首先：如果想要给属性添加setter必须先添加getter。
a.声明函数：
声明函数加@getter名.setter
函数名是不带_下划线的属性名。
函数不需要返回值，但是函数需要一个参数，这个参数就是给属性赋的值，用来判断的。
b.在外面给属性赋值的时候不带下户线的。
================setter例子========

class Person:
    def __init__(self,age):
        self._age=10
        self._time=1243214324.32432432
    # @property
    # def time(self):
    #     t_time=time.localtime(self._time)
    #     return t_time

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
          self._age=value #把传进来的传给value
        print(value)
        if isinstance(value, int):
            pass
        else:
            raise ValueError
p1=Person(10)
p1.age=18
# p1.age="abc"
print(p1.time)
#例2
class Circle:
    pi=3.1415926
    def __init__(self,r):
        self.r=r
        self._area=0
    @property
    def area(self):
        return  Circle.pi*self.r*self.r
    @area.setter
    def area(self,value):
        print("给value赋值",value)
        # raise   ValueError
c1=Circle(1)
c1.area=1000 #本质是调用c1.area(100)

=======================================