- 以后定义属性的时候，不要让外界直接用，而是需要定义一个方法。示例如下：
class Dog:
def set_age(self, new_age):
if new_age > 0 and new_age <= 100:
self.age = new_age
else:
self.age = 0
def get_age(self):
return self.age
dog = Dog()
#dog.age = -10
#dog.name = "小白"
#print(dog.age)
dog.set_age(-10)
age = dog.get_age()
print(age)
#dog.get_age()
#dog.get_name()
- 私有方法
class Msg:
#私有方法
def __send_msg(self):
print("-----正在发送短信-----")
#公有方法
def send_msg(self, new_money):
if new_money > 10000:
self.__send_msg()
else:
print("余额不足，请先充值，再发送短信")
msg = Msg()
msg.send_msg(10000000)
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
-----正在发送短信-----
Process finished with exit code 0
这种开发的思想，比如开发一个发送短信的功能。不能直接让你调用这个私有的函数，我得先验证你的条件，如果满足就调用，不满足就不调用。换句话说，在实际开发中，如果一个函数前面有两个下划线，就意味着这个方法一般比较重要，不想让外面直接用。而是需要先调用一个方法也就是send_msg()，相当于先去验证。如果验证通过了，然后在方法里面self.__send_msg()再调用真正核心的方法。
- __del __ 方法
class Dog:
def __del__(self):
print("-----英雄over-----")
dog1 = Dog()
dog2 = dog1
del dog1
print("=================")
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
=================
-----英雄over-----
Process finished with exit code 0
此处指的注意的是，最下面的先打印，而del函数里面的之后打印，这是为什么呢？此外重新改一下就会发现结果会发生变化
class Dog:
def __del__(self):
print("-----英雄over-----")
dog1 = Dog()
dog2 = dog1
del dog1
del dog2
print("=================")
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
-----英雄over-----
=================
Process finished with exit code 0
这是因为，如果使用程序引用计数来描述这个步骤的话，当执行"dog1 = Dog()"之后，计数为1，当执行"dog2 = dog1"之后，计数为2。而当执行"del dog1"之后，计数减1，当执行"del dog2"之后，计数归零。此时，就要调用"__del __"函数，执行上面的print，之后再执行下面的print
而第一个程序中，在执行完下面的print之后，程序准备结束并把内存信息归零的时候，此时执行"__del __"函数，所以会出现先print下面的信息，再print函数里面的信息的情况。
以上的知识点可以用于比如说英雄联盟里面，在英雄被击杀之后，需要调用一个类似于喊叫，倒地的程序。
- 测量一个对象引用计数的方法
>>> import sys
>>> class T:
pass
>>> t = T()
>>> sys.getrefcount(t)
2
#此处我们发现，数量一定比实际的多一个
>>> tt = t
>>> sys.getrefcount(tt)
3
>>> del tt
>>> sys.getrefcount(t)
2
>>> del t
>>> sys.getrefcount(t)
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
sys.getrefcount(t)
NameError: name 't' is not defined
>>>
- 继承
#继承只需要在子类的class里面插入父类的名称就可以使用父类的函数功能了
#但是需要注意的是，dog只能调用Dog()和Animal里面的功能，不能调用Cat()里面的功能，反之亦然
class Animal:
def eat(self):
print("---eat---")
def drink(self):
print("---drink---")
def sleep(self):
print("---sleep---")
def run(self):
print("---run---")
class Dog(Animal):
def bark(self):
print("---shout---")
class Cat(Animal):
def catch(self):
print("--catching---")
dog = Dog()
dog.eat()
dog.bark()
tom = Cat()
tom.eat()
tom.catch()
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---shout---
---eat---
--catching---
Process finished with exit code 0
还有一个神奇的功能，如果想要定义一个啸天犬类能够继承Dog的功能，代码如下
class Animal:
def eat(self):
print("---eat---")
def drink(self):
print("---drink---")
def sleep(self):
print("---sleep---")
def run(self):
print("---run---")
class Dog(Animal):
def bark(self):
print("---shout---")
class Xiaotianquan(Dog):
def fly(self):
print("---fly---")
xx = Xiaotianquan()
xx.eat()
xx.bark()
xx.fly()
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---shout---
---fly---
Process finished with exit code 0
实现一层继承一层的功能，等于是将一个大类细分成很多个小类
- 重写
如果说定义的最小子类Xiaotianquan()的bark()函数实现的跟Dog()不一样，那么我们就可以重写一个函数实现一个新的功能。
如下的代码就是重写一个bark()的功能：
class Animal:
def eat(self):
print("---eat---")
def drink(self):
print("---drink---")
def sleep(self):
print("---sleep---")
def run(self):
print("---run---")
class Dog(Animal):
def bark(self):
print("---shout---")
class Xiaotianquan(Dog):
def fly(self):
print("---fly---")
#在此处等于是重写bark()的功能，让它不再使用Dog()里面的函数
def bark(self):
print("---LOL---")
xx = Xiaotianquan()
xx.eat()
xx.bark()
xx.fly()
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---LOL---
---fly---
Process finished with exit code 0
如果想要调用被重写的方法，有两种操作
class Animal:
def eat(self):
print("---eat---")
def drink(self):
print("---drink---")
def sleep(self):
print("---sleep---")
def run(self):
print("---run---")
def bark(self):
print("---测试一下---")
class Dog(Animal):
def bark(self):
print("---shout---")
class Xiaotianquan(Dog):
def fly(self):
print("---fly---")
#在此处等于是重写bark()的功能，让它不再使用Dog()里面的函数
def bark(self):
print("---LOL---")
#第一种调用被重写的父类的方法
#Dog.bark(self)
#第二种方法
super().bark()
xx = Xiaotianquan()
xx.eat()
xx.bark()
xx.fly()
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---eat---
---LOL---
---shout---
---fly---
Process finished with exit code 0
经过测试发现，这两种调用的方法都是只能调用上一层的同名函数bark()的功能，我在Animal这个class里面也谢了一个bark()的函数作为测试，发现并没有调用。
- 私有方法、私有属性在继承中的表现
第一种：
class A:
def __init__(self):
self.num1 = 100
self.__num2 = 200
def test1(self):
print("---test1---")
def __test2(self):
print("---test2---")
class B(A):
pass
b = B()
b.test1()
#b.__test1() #私有方法并不会被继承
print(b.num1)
#print(b.__num2) #私有属性并不会被继承
第二种：
class A:
def __init__(self):
self.num1 = 100
self.__num2 = 200
def test1(self):
print("---test1---")
def __test2(self):
print("---test2---")
def test3(self):
self.__test2()
print(self.__num2)
class B(A):
pass
b = B()
#b.test1()
#b.__test1() #私有方法并不会被继承
#print(b.num1)
#print(b.__num2) #私有属性并不会被继承
b.test3()
得到结果：
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
---test2---
200
Process finished with exit code 0
第三种：
class A:
def __init__(self):
self.num1 = 100
self.__num2 = 200
def test1(self):
print("---test1---")
def __test2(self):
print("---test2---")
def test3(self):
self.__test2()
print(self.__num2)
class B(A):
def test4(self):
self.__test2()
print(self.__num2)
b = B()
#b.test1()
#b.__test1() #私有方法并不会被继承
#print(b.num1)
#print(b.__num2) #私有属性并不会被继承
#b.test3()
b.test4()
如果是像第二种那样，在B的父类A里面调用test3()的函数，而test3()函数里面调用私有属性和私有方法，那么是可以得到结果的。
但是如果像第三种那样，在子类里面创建一个新的test4()，试图在这个函数里面调用父类里面的私有属性和私有方法，那么就是不被允许的。
专业一点来说，就是，如果调用的是父类中的公有方法，则可以在这个公有方法中访问父类中的私有属性和私有方法；但是如果在子类中实现了一个公有方法，那么这个方法是不能够调用继承的父类中的私有方法和私有属性。
- 多继承
class Base:
def test(self):
print("----Base")
class A(Base):
def test1(self):
print("----test1")
class B(Base):
def test2(self):
print("----test2")
#如果想要C()继承A()和B()两个父类的函数功能，那么只需要在括号里面把二者添加上就可以了
#当然，它本来就可以调用Base里面的函数功能
class C(A, B):
pass
c = C()
c.test1()
c.test2()
c.test()
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
----test1
----test2
----Base
Process finished with exit code 0
关于多继承的调用
class Base:
def test(self):
print("----Base")
class A(Base):
def test(self):
print("----A")
class B(Base):
def test(self):
print("----B")
class C(A, B):
def test(self):
print("----C")
c = C()
c.test()
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
----C
Process finished with exit code 0
值得注意的是，如果C里面有test()，那么它就会在调用完C之后就停止了；如果C里面没有test()，那么它就只会调用A的而不会A和B都调用，这里面可以用"print(C.__mro __)"来查看它实现的路径
- 多态
class Dog(object):
def print_self(self):
print("Hello world")
class Xiaotq(Dog):
def print_self(self):
print("Oh ha you")
def introduce(temp):
temp.print_self()
dog1 = Dog()
dog2 = Xiaotq()
introduce(dog1)
introduce(dog2)
/Library/Frameworks/Python.framework/Versions/3.6/bin/python3.6 /Users/xinqi/PycharmProjects/test/test.py
Hello world
Oh ha you
Process finished with exit code 0
多态的含义就是，当你写完程序之后，我仅仅知道你是调用一个方法"temp.print_self()"，但是我不确定它到底是调用基类的还是子类的。但是真正在程序执行的时候，我才根据当前的对象是谁，我才确定到底是调用Xiaotq()里面的方法还是调用Dog()里面的方法，这就是多态。
