Python基础知识之面向对象编程
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 = role
self.weapon = weapon
self.life_value = life_value
self.money = money
def __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) # 123
r2 = 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 = role
self.weapon = weapon
self.__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):
pass
class Child(Parent):
pass
6. 类方法的重构
# class People: 经典类
class People(object): # 新式类
def __init__(self, name, age):
self.name = name
self.age = age
class 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 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)
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 而是cls
print("%s is eating!"%cls.name)
d = Dog()
d.eat()
Dog.eat()
11.属性方法
属性方法就是把一个方法变成一个静态属性。
class Dog(object):
name = "Jack"
@property # 注意不是attribute
def 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 # 注意不是attribute
def 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 # 注意不是attribute
def eat(self):
print("%s is eating! %s" % (self.name, self.__food))
#需要定义在eat之后
@eat.setter
def eat(self,food):
self.__food = food
print("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.deleter
def eat(self):
del self.__food
print("删完了")
再使用：
del d.eat
来删除属性。
好吧，把一个方法变成静态属性有什么卵用呢？既然想要静态变量，那直接定义成一个静态变量不就得了么？well, 以后你会需到很多场景是不能简单通过 定义 静态属性来实现的， 比如 ，你想知道一个航班当前的状态，是到达了、延迟了、取消了、还是已经飞走了， 想知道这种状态你必须经历以下几步:
- 连接航空公司API查询
- 对查询结果进行解析
- 返回结果给你的用户
因此这个status属性的值是一系列动作后才得到的结果，所以你每次调用时，其实它都要经过一系列的动作才返回你结果，但这些动作过程不需要用户关心， 用户只需要调用这个属性就可以，明白 了么？
class Flight(object):
def __init__(self,name):
self.flight_name = name
def checking_status(self):
print("checking flight %s status " % self.flight_name)
return 1
@property
def 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
航班查询
