函数和类的相同与区别：
1. 相同点：构造函数，用于调用，不用重复代码。
2. 区别：函数传给变量是内存地址，以及数据无法保留。
类的调用，即给变量开辟了一个内存空间，用于存放自己的数据。但方法是公用的。
类：
属性：
实例变量
类变量
私有属性__var
方法：
构造方法： def __int__ 用于初始化函数。
析构方法：实例在释放/销毁的时候，会自动执行这个方法。如，实例打开了一些临时文件，连接，销毁的时候就会将其关闭掉。
私有方法
继承：
单继承
多继承：顺序：
2.7 经典类，深度优，新式类，广度优先
3.0 & above， 均是广度优先
class foo（object）： #新式类
多态：
接口重用，一种接口，多种实现。可以写一个统一的接口/调用函数，具体调用哪个方法，可以动态的把函数值传进去。
class Role(object):
n = 123 #类变量, 其用途是节省开销。
def __init__(self,name,role,weapon,life_value=100,money=15000): #构造函数 self.name = name #实例变量，作用域就是实例本身，R1的数据不能被R2调用。 self.role = role self.weapon = weapon self.life_value = life_value self.money = money def shot(self): #类的方法/功能。（动态属性） print("shooting...") def got_shot(self): print("ah...,I got shot...") def buy_gun(self,gun_name): print("just bought %s" %gun_name)r1 = Role('Alex','police','AK47’) #生成一个角色，（实例化）r1是Role的对象，即实例。r2 = Role('Jack','terrorist','B22’) #生成一个角色r1 = Role(self,'Alex','police','AK47')
Role在内存中开辟一个空间，存放实例变量（静态属性）和方法（动态属性）。
r1在将Role赋值的过程中，在内存开辟一个空间，用于存放自己的数据。但方法是公用的。
打印类变量，实例化后与不实例化，打印n都是一样的。但如果类变量与实例变量有重名时，实例化后打印实例变量，而不实例化，打印类变量。
print(Role.n)
print(r1.n，r1.name)
print(r2.n, r2.name)
output：
r1.name = 'David' #实例化后，再给r1.name赋值，值会变成David
r1.bullet_prove = True #实例化后，再加一个属性，只能在r1的内存中有，r2没有. 因为他们都是独自的内存。 删除属性亦然。
r1.n = ‘改变类变量’ #其实只是在r1 的内存中开辟一段新内存，存放n，与类变量n没有关系。
print('r1:' r1.n)
print('r2': r2.n) #r2，没有变量n，即打印类变量。
output:
Role.n = 'ABC' #修改类变量
print（r2.n）
output：
ABC
析构函数： 在实例释放、销毁的时候 自动执行的，通常用于做一些收尾工作，如关闭一些数据库连接，关闭打开的临时文件。
怎么叫销毁，如果你什么也不做，变量在程序结束时，自动销毁。
__del__(self) 是在你的程序释放或销毁的时候就会自动执行。
或者，在程序中，你想明确销毁该变量。你可以手动调用del将其销毁。
私有方法-》方法，私有属性－》变量。
__life_value #只能内部看见，所以在内部加函数访问。
__shot(self) #私有方法。通过r1.__shot()调用。
继承
class pepale: #父类，
def __init__ (self, name, age)
self.name = name
self.age = age
def eat(self):
print('%s is eating...' % self.name)
def talk(self):
print(‘%s is talking...' % self.name)
def sleep(self):
print('%s is sleeping...' %self.name)
class man(people): #(people) -> 继承people父类的属性和方法。
def piao(self):
print(’% is doing .... 20S .... done.' % self.name)
def sleep(self):
people.sleep(self)
print(‘man is sleeping')
class Man(people):
def__init__(self,name,age,money) #如要在子类在变量，（不要在父类加，这样不会其他子类），必须从新构造函数。但问题来了，为了加money这个变量，子类要加入name，age就会把父类给覆盖了，要将父类的变量传到Man这个子类。
people.__init__(self,name,age) #self.name 和 self.age的赋值在父类实现
self.money =money #self.money在这赋值。这样就为Man子类加入了一个参数。
OR
def__init__(self,name,age,money) #上面的另一种写法。
super(Man,self).__init__(name,age)
class Woman(people):
def give_birth(self):
print("%s is giving birth to a baby...." % selfname)
m1 = Man('xiaoJ', 22)
m1.eat()
m1.piao()
w1= Woman(’xiaoA‘，23）
w1.give_birth()
多继承
class Relation(object): #Relation 作为多继承的父类，并不一定要什么变量都带，Man子类已经从People那传入了name的变量。
def make_friends(self,obj):
print('%s is making friends with %s' %(self.name,obj.name))
class Man(People,Relatioin) #继承是有先后顺序的。
def__init__(self,name,age,money):
super(Man,self).__init__(name,age)
self.money = money
m1 = Man('xiaoJ', 22,10)
w1= Woman(’xiaoA‘，23）
m1.make_friends(w1）
继承循序：
Python多态示例：
#_*_coding:utf-8_*_
class Animal(object): def __init__(self, name): # Constructor of the class self.name = name def talk(self): # Abstract method, defined by convention only raise NotImplementedError("Subclass must implement abstract method")class Cat(Animal): def talk(self): print('%s: 喵喵喵!' %self.name)class Dog(Animal): def talk(self): print('%s: 汪！汪！汪！' %self.name)def func(obj): #一个接口，多种形态 obj.talk()c1 = Cat('小晴')d1 = Dog('李磊')func(c1)func(d1)