1. 实例变量与类变量

class Role:n = 123  # 类变量n_list = []name = "我是类name"def __init__(self, name, role, weapon, life_value=100, money=15000):# 构造函数# 在实例化时做一些类的初始化的工作# self就相当于一个实例化的对象self.name = name  # r1.name=name实例变量(静态属性),作用域就是实例本身self.role = roleself.weapon = weaponself.life_value = life_valueself.money = moneydef __shot(self):  # 类的方法，功能 （动态属性）print("shooting...")r1 = Role('Chenronghua', 'police', 'AK47')  # Role(r1,'Alex', 'police',  'AK47')把一个类变成一个具体对象的过程叫 实例化(初始化一个类，造了一个对象)
r1.n = 456
print(r1.n)  # 456  并没有改变类变量n。而是在对象r1中自动生成了一个实例变量n
print(Role.n)  # 123r2 = Role('jack', 'terrorist', 'B22')  # 生成一个角色
r2.n_list.append("from r1")
print(r2.n_list,Role.n_list) # ['from r1'] ['from r1']  直接修改了类的类变量 n_list
r2.bullet_prove = True  # 这句话是对的，相当于定义了一个对象r2之后，新增了一个实例变量bulet_prove
del r2.weapon # 删除实例变量weapon

类变量的作用：大家共用的属性，节省开销

2. 析构函数

在实例释放、销毁的时候执行的，通常用来做一些收尾工作，如关闭一些数据库链接，打开的临时文件。

def __del__(self):print("%s 彻底销毁了。。。",self.name)

3. 私有属性

私有属性在类的内部可以访问，在类的外部无法访问在构造函数中定义，在前面加上__就可以了。

定义如下：

    def __init__(self, name, role, weapon, life_value=100, money=15000):self.name = name  # r1.name=name实例变量(静态属性),作用域就是实例本身self.role = roleself.weapon = weaponself.__life_value = life_value # 这里的life_value就是一个私有属性了。self.money = money

那么如何访问私有属性呢？这个时候需要在类的内部定义方法来实现：

    def get_lifevalue(self):print(self.__life_value)

4. 私有方法

私有方法在类的内部可以访问，在类的外部无法访问。在类内定义私有方法只需要在方法名前面加上__就可以了。

定义如下：

def __fun1(self):print("这是一个私有方法！")

5. 类的继承

class Parent(object):__init__(self):passclass Child(Parent):pass

6. 类方法的重构

# class People: 经典类
class People(object):  # 新式类def __init__(self, name, age):self.name = nameself.age = ageclass Man(People):# 重构父类方法def __init__(self, name, age, money):People.__init__(self, name, age)  # 经典类的写法super(Man, self).__init__(name, age)  # 新式类的写法self.money = money

7. 新式类和经典类的区别

在Python2.7中：

BC为A的子类，D为BC的子类，A中有save方法，C对其进行了重写

• 在经典类中 调用D的save方法 搜索按深度优先 路径B-A-C， 执行的为A中save 显然不合理
• 在新式类的 调用D的save方法 搜索按广度优先 路径B-C-A， 执行的为C中save

#经典类
class A:def __init__(self):print 'this is A'def save(self):print 'come from A'class B(A):def __init__(self):print 'this is B'class C(A):def __init__(self):print 'this is C'def save(self):print 'come from C'class D(B,C):def __init__(self):print 'this is D'd1=D()
d1.save()  #结果为'come from A

#新式类
class A(object):def __init__(self):print 'this is A'def save(self):print 'come from A'class B(A):def __init__(self):print 'this is B'class C(A):def __init__(self):print 'this is C'def save(self):print 'come from C'class D(B,C):def __init__(self):print 'this is D'd1=D()
d1.save()   #结果为'come from C'

在Python 3.x中，经典类和新式类均为广度优先

8. 多态

一种接口，多种实现。

#_*_coding:utf-8_*_class Animal(object):def __init__(self, name):  # Constructor of the classself.name = namedef talk(self):              # Abstract method, defined by convention onlyraise 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)

9. 静态方法

静态方法定义在类中，名义上归类管，相当于类的工具包。

class Dog(object):@staticmethod #静态方法装饰器，实际上和类没有什么关系def eat():print("You are eating some food!")d = Dog()
d.eat()  # 可以通过实例化对象调用静态方法
Dog.eat() # 直接通过类名调用静态方法

10. 类方法

类方法只能访问类变量，不能访问实例变量

class Dog(object):name = "Jack"@classmethod  # 类方法装饰器def eat(cls): # 这里不是self 而是clsprint("%s is eating!"%cls.name)
d = Dog()
d.eat()
Dog.eat()

11.属性方法

属性方法就是把一个方法变成一个静态属性。

class Dog(object):name = "Jack"@property  # 注意不是attributedef eat(self):print("%s is eating!" % self.name)d = Dog()
# d.eat()  # 会报错：TypeError: 'NoneType' object is not callable
d.eat  # Jack is eating!
# Dog.eat()  #

调用的时候不能加括号

那么，既然是一个静态属性，那么就意味着我们无法对其传参，只能读取。

考虑一下，首先，如果我们在类内直接赋予参数，应该如何呢？

class Dog(object):name = "Jack"@property  # 注意不是attributedef eat(self, food):print("%s is eating!" % self.name)d = Dog()
d.eat("baozi")  # TypeError: eat() missing 1 required positional argument: 'food'
# 如果给他赋值呢？
# d.eat = "baozi"  # AttributeError: can't set attributeQ

从上面的代码我们可以看出，属性方法我们无法直接对其进行赋值，这个时候就需要使用如下方法：

class Dog(object):name = "Jack"def __init__(self):self.__food = None@property  # 注意不是attributedef eat(self):print("%s is eating! %s" % (self.name, self.__food))#需要定义在eat之后@eat.setterdef eat(self,food):self.__food = foodprint("set to food:%s" %food)d = Dog()
d.eat = "baozi"
d.eat

那么如何删除属性方法呢？

del d.eat
>>>  File "D:/Python/PycharmProjects/test/core/main.py", line 24, in <module>del d.eat
AttributeError: can't delete attribute

显然，直接删除是不正确的，这个时候，就需要重新定义：

    @eat.deleterdef eat(self):del self.__foodprint("删完了")

再使用：

del d.eat

来删除属性。

好吧，把一个方法变成静态属性有什么卵用呢？既然想要静态变量，那直接定义成一个静态变量不就得了么？well, 以后你会需到很多场景是不能简单通过 定义 静态属性来实现的， 比如 ，你想知道一个航班当前的状态，是到达了、延迟了、取消了、还是已经飞走了， 想知道这种状态你必须经历以下几步:

1. 连接航空公司API查询
2. 对查询结果进行解析
3. 返回结果给你的用户

因此这个status属性的值是一系列动作后才得到的结果，所以你每次调用时，其实它都要经过一系列的动作才返回你结果，但这些动作过程不需要用户关心， 用户只需要调用这个属性就可以，明白 了么？

class Flight(object):def __init__(self,name):self.flight_name = namedef checking_status(self):print("checking flight %s status " % self.flight_name)return  1@propertydef flight_status(self):status = self.checking_status()if status == 0 :print("flight got canceled...")elif status == 1 :print("flight is arrived...")elif status == 2:print("flight has departured already...")else:print("cannot confirm the flight status...,please check later")f = Flight("CA980")
f.flight_status航班查询