面向对象 Object Oriented Programming

基本单元：对象
把数据和功能封装在里边，能实现很好的复用性，灵活性和扩展性。

面向对象的两个基本概念：类和对象

面向对象的基本要素：属性和方法

属性和功能组成一个类。

类的特性：
封装性；--->类对暴露了这些功能，却隐藏了具体的实现细节，这就是封装性。
继承；--->还有多继承
多态；--->一个类继承的几个不同类，调用同一方法时会有不同反应。会重写方法

定义类

class ClassName:
　　statement1
　　....
　　statementN

新建类的时候要对属性进行设置，这时就需要类的构造函数
构造函数：

def __init__(self,[...):

析构函数：当一个对象被垃圾回收机制回收时，调用这个。与内建函数del不同
def __del__(self,[...):

现在python3中所有的类都是用新式类：需要继续object这个类，继承object的一些特性
class NewStyle（object）：
    pass

两个内建函数：是函数！
dir（）返回对象的属性
type（）返回对象的类型

定义类的属性

直接在类里定义：
class Programer(object):
　　sex = ‘male‘ --->会被所有对象所共享，所有类的对象的这个属性都是一样的。

在构造函数里定义：
class Programer(object):
    def __init__ (self,name,age):
        self.name = name
        self.age = age ---> 在构造对象时把属性传进去，每个不同的对象其属性值就会不太一样

访问控制：

python没有提供私有属性的功能，没有访问控制，依靠编程规范和命名规则来进行约束

常用属性定义

class Programer(object):
    def __init__ (self,name,age，weight):
        self.name = name --->没有下划线，可以公开访问
        self._age = age --->一个下划线，这个属性一般代表类的私有属性，但也可访问到，只是编程规范的约束而不是语法的约束
        self.__weight = weight --->两个下划线，实现了部分私有属性，在类中是可以访问的，生成对象后是访问不了的，只是在属性的名称上做了改变。可通过print programer.__dict__ --->代表从构造函数中获取的属性 查看只是变相地实现对私有属性的访问，只是把名称改了。

定义类的方法

函数和方法：

函数是直接调用函数名来调用的，而方法必须和对象结合在一起使用。函数仅仅是一块代码供人调用，方法从属于某个类，由别的程序调用。是否依附于一个类是最为关键的区别。

python中一切皆对象。可以把类的方法看做类的属性，类型是method类。

方法的访问控制也没有

常用的方法的定义：

class Example(object):
    def add(self): --->没有下划线是公用方法
        pass

    def _minus(self): --->有一个下划线，代表是私有方法，但没有受到限制
        pass

    def __multiply(self): --->有两个下划线，只是在名称上被改了。
        pass

两个方法的装饰器：

@classmethod
调用的时候用类名，而不是某个对象
@property
像访问属性一样调用方法。平时调用方法时是：对象名.方法名（）,这个调用时不用加括号。

例子：

class Programer（object)：
    hobby = ‘Play Computer‘

    def __init__(self,name,age,weight):
        self.name = name
        self._age = age
        self.__weight = weight

    @classmethod
    def get_hobby(cls):
        return cls.hobby

    @property
    def get_weitht(self):
        return self.__weight

    def self_introduction(self):
        print ‘my name is %s \nI am %s years old\n‘ % (self.name,self,_age)

if __naem__ == ‘_main_‘:
programer = Programer(‘Albert‘,25,80)
print dir(programer)
print Programer.get_hobby() ！注意是用类名调用的，大写！
print programer.get_weight ！注意像访问属性一样，后边没有括号！
programer.self_introduction()

类的继承！面向对象中很重要，它使得大量代码可以复用，是面向对象的优势所在。

定义类的继承：

class DerivedClassName（BaseClassName）：
    <statement-1>
    ...
    <statement-N>

继承的子类，会继承父类的属性和方法，也可以自己定义，覆盖父类的属性和方法。

重写父类时要调用父类方法，用super()调用父类的方法。

class A(object):
    def method(self,arg):
        pass

    class B(A):
    def method(self,arg):
        super(B,self).method(arg)

还有一种用类名调用父类的方法

class A(object):
    def method(self,arg):
        pass

class B(A):
    def method(self,arg):
　　    A.method(arg)

子类的类型判断
内建函数：
isinstance 判断类型，是否是父类，一个对象是从属于父类的，一个对象在判断类型时会认为是所在类的父类。
issubclass 判断子类

多继承，应用不多
class DerivedClassName（Base1，Base2，Base3）：
　　<statement-1>
　　...
 　<statement-N>

类的多态，就是在做同一件事情，有不同的反馈和流程
两大要素：继承和方法重写。因为不同子类要继承同一个父类，正是方法重写，使得在做同一件事时出现不同的结果。python可以直接重写父类方法。

Python Magic Method 魔术方法

从对象的建立，属性访问，到运算符的支持，语法的支持，可以用魔术方法以极大的自由度来定义我们的类。

方法名的前后有两个下划线

def __init__(self):

前边的构造函数和析构函数都是magic method.

对象的创建和初始化

对象实例化的过程：
创建类的对象----------初始化对象

def __new__(cls)： def __init__(self)：
会返回一个对象交给init去初始化

类与运算符

比较运算符
__cmp__(self,other)
__eq__(self,other)
__lt__(self,other)
__gt__(self,other)

数字运算符

__add__(self,other)
__sub__(self,other)
__mul__(self,other)
__div__(self,other)

逻辑运算符

__or__(self,other)
__and__(self,other)

类的展现

实例化一个类后可以打出来，是因为在print中转化为字符串
__str__ 转换为适合人看的字符串
__repr__ 转换为适合机器看的字符串
__unicode__

一个对象可以由相应的方法转换为字符串，一定是定义了可继承了相应的魔术方法

展现对象属性
内建方法dir查看对象属性，与之对应的是魔术方法__dir__来控制调用dir函数的结果，可以自己定义dir魔术方法。

很多内建函数都是由魔术方法支持的。可以定义相应的魔术方法

类的属性访问控制

设置对象属性:注意无限递归的情形！定义时调用本身
__setattr__(self,name,value):

def __setattr__(self,name,value):
        self.__dict__[name] = value

查询对象属性
__getattr__(self,name): 查询时没有访问到会调用这个方法
def __getattribute__(self,naem): 每次访问都会调用
        return super(Programer,self).__getattribute(name) 调用父类的getattribute方法程序

删除对象属性
__delattr__(self,name):

python面向对象总结！