python面向对象

##**语言的分类**
– 面向机器:汇编语言
– 面向过程:c语言
– 面向对象：C++ Java Python

##**面向对象**
– 类class
– 类是抽象的概念，万事万物的抽象，是一类事物的共同特征集合。
– 对象instance object
– 对象是类的具象，是一个实体
– 人这样的个体，就是人类的不同实体
– 属性
– 对象状态的抽象，用数据结构描述
– 操作
– 它是对象行为的抽象，用操作名和实现该操作的方法来描述
– 哲学
– 一切皆对象；对象是数据和操作的封装；对象是独立的，但是对象之间可以相互作用
– 目前oop是最接近人类认知的编程范式

##**面向对象的三要素**
– 封装
– 组装：将数据和操作组装到一起
– 隐藏数据：对外只暴露一些接口，通过接口访问对象。
– 继承
– 多复用，继承来的就不用自己来写
– 多继承少修改，OCP，使用继承来改变，来体现个性
– 多态
– 面向对象编程是最灵活的地方，动态绑定

##**python的类**
– 定义
– class ClassName:
– (1) 必须使用class关键字 (2) 类名大驼峰 (3) 类定义完后，产生类对象，绑定到了ClassName上
###**举例**
class MyClass:
”’A example class”’
x = ‘abc’
def foo(self):
return ‘My Class’
print(MyClass.x)
print(MyClass.foo)
print(MyClass.__doc__)

##**类对象及类属性**
– 类对象 类的定义就会生成一个类对象
– 类的属性，类定义中的变量和类中定义的方法都是类的属性
– 类变量，x是类MyClass的变量
– foo是method方法对象，不是普通的函数对象function，它必须至少有个一参数，且第一个参数必须是self。
– **self指代当前实例本身** a = MyClass() 就是实例化

##__init__方法
– MyClass()实际上调用的是__init__(self)方法，可以不定义，如果没有定义会在实例化后隐式调用
– 作用：对实例进行初始化
– __init__() 方法不能有返回值，也就是只能是None
###举例
案例1
class MyClass:
def __init__(self):
print(‘init’)
a = MyClass() #实例化
案例2
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def showage(self):
print(‘{} is {}’.format(self.name,self.age))
tom = Person(‘Tom’,20)
jerry = Person(‘jerry’,25)
print(tom.name,jerry.age)
jerry.age += 1
print(jerry.age) # 26
jerry.showage()

##**实例对象instance**
– 类实例化后一定会获得一个对象，就是实例对象。
– 实例变量是每一个实例自己的变量，是自己独有的；类变量是类的变量，是类的所有实例共享的属性和方法
– __name__ 对象名 __class__ 对象的类型 __dict__ 对象的属性的字典 __qualname__ 类的限定名
– 类属性保存在__dict__中，同样，实例也有__dict__中，如果从实例访问类的属性，就需要借助__class__找到所属的类

##**装饰一个类**
– 之所以能够装饰，本质上是为类对象动态的添加了一个属性，而Person这个标识符指向这个类对象
###实例
def logger(name):
def wrapper(cls):
cls.NAME = name
return cls
return wrapper

@logger(‘MAGE’) #@wrapper –> Human = wrapper(Human)
class Human:
print(‘123’)
print(Human.NAME)

##**类方法和静态方法**
– 类除了普通方法都可以调用，普通方法需要对象的实例作为第一参数
– 实例可以调用所有类中定义的方法(包括类方法、静态方法)，普通方法传入实例自身，静态方法和类方法需要找到实例的类
class Person:
def normal_method():
print(‘normal’)
Person.normal_method() # normal
Person().normal_method() # 报错因为Person()给了一个参数给normal_method但是，这个函数并不需要参数

类方法
class Person:
@classmethod #在类定义中用它装饰器修饰的方法
def class_method(cls): #cls 代表传上来的类
print(‘class={0.__name__} ({0})’.format(cls))
cls.HEIGHT = 170

@staticmethod #静态方法很少用
def static_methd():
print(Person.HEIGHT)

Person.class_method()
Person.static_method()
print(Person.__dict__)

##**访问控制**
– 私有属性，属性在外部可以访问，或者说可见，就可以直接绕过方法，直接修改这个属性
– 私有属性使用双下划线开头的属性名，就是私有属性
– 私有变量的本质：类定义的时候，使用双下划线，Python解释器会将其改名，转换为_类名__变量名。
##
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age
def growup(self,i=1):
if i>0 and i<150:
self.__age += i

##**保护变量**
– 使用 _方法名，这只是开发者共同的约定，看见这种变量，就如同私有变量，不要直接使用

##**私有方法**
– 与私有变量一样，使用单双下划线命名的方法
– 单下划线的方法只是开发者之间的约定，解释器不做任何改变
– 双下划线的方法，是私有方法，解释器会改变，改名策略和私有变量相同
– 方法变量都在__dict__中可以找到
###举例
class Person:
def __init__(self,name,age=18):
self.name = name
self._age = age

def _getname(self):
return self.name

def __getage(self):
return self._age

tom = Person(‘Tom’)
print(tom._getname())

print(tom._Person__getage())
print(tom.__class__.__dict__)
print(tom.__dict__)

##补丁
#test1
from test2 import Person
from test3 import get_score

def change():
Person.get_score = get_score
print(Person().get_score())
change()
print(Person().get_score())
#test2
class Person:
def get_score(self):

ret = {‘eng’:68,’his’:78,’math’:98}
return ret
#test3
def get_score(self):
return dict(eng=88,his=99,math=100)

##**属性装饰器**
– 把实例的属性保护起来，不让外部直接访问，外部使用getter读取属性和setter方法设置属性
– property装饰器
– 后面跟的函数名就是以后的属性名。他就是getter。这个必须有，有了它至少只读属性
– setter装饰器
– 与属性名同名，且接收2个参数，第一个是self，第二个是将要赋值的值，有了它，属性可写
– deleter装饰器
– 可以控制是否删除属性。很少用
– property必须在前，setter、deleter装饰器在后。
– property装饰器能通过简单的方式，把对方法的操作变成对属性的访问，并起到了一定隐藏效果
###举例
法一：
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age
@property #property把age作为属性名，不是方法了
def age(self):
return self.__age

@age.setter #设置年龄
def age(self,age):
self.__age = age

@age.delter #删除
def age(self):
#del self.__age
print(‘del’)
tom = Person(‘Tom’)
print(tom.age)
tom.age = 20
print(tom.age)
del tom.age #删除tom.age属性
法二：
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age

def getage(self):
return self.__age

def setage(self,age):
self.__age = age

def delage(self):
del self.__age

age = property(getage,setage,delage,’age property’)

##**对象的销毁**
– 类中定义__del__方法，称为析构函数(方法)
– 作用：销毁类的实例的时候调用，以释放占用的资源
– python已经实现了垃圾回收机制，这个方法不能确定何时执行。有必要时，使用del语句删除实例。
###举例
class Person:
def __init__(self,name,age=18):
self.name = name
self.__age = age

def __del__(self):
print(‘delete {}’.format(self.name))
tom = Person(‘Tom’)
del tom