python学习之-- 面向对象

面向对象（简写：OOP）

面向对象编程定义：利用类和对象来创建各种模型,来实现对真实世界的描述。

优点：使程序更容易理解和维护以及扩展代码。

类定义：用来描述具有相同的属性和方法的对象的集合。（简单讲就是个模板）

实例化定义：创建一个类的实例，类的具体对象。

对象定义：通过类定义的数据结构的实例

举例：一个最简单最小结构的类写法如下：

class class_name(object):
    print('bababa'）

举例一个正常类的写法：

class 类名称(object):
    def __init__(self,name..) #构造函数
        self.arg1 = name # 普通属性（成员变量），注：self就是实例对象本身，保存在对象内存里
    def fun1(self): #　普通方法（动态属性）
        print('...')

类进行实例化的运行原理：

1：将类中的对象和方法存储于内存中，
  2：类进行实例化时，先在内存申请一块空间用于存放实例对象
  3：把实例对象的内存地址和赋值参数传递给类模板
  4：模板对传入的值进行self变量赋值，然后将self变量发送到实例对象内存空间。

类的三大特性：封装，继承，多态

-- 封装：类内部的数据和方法，对数据的赋值和内部调用对类外部而言是透明的。简单说就是隐藏实现的细节，使代码模块化。

特性：防止数据被随意修改，可以通过此对象对外接口进行直接访问。

　　　　   另（类封装了属性和方法，对象封装了普通属性的值）

-- 继承：一个父类派生出的子类，在父类里定义的属性和方法自动被子类继承，实现一个角色的共同点和不同点的同时存在。使代码重用

注意：承可以多级继承，不过越多代码会越复杂，建议继承2-3级即可，继承的2个类之间应该是属于的关系。

　　　　-- 被继承的类命名：父类，基类，超类

　　　　-- 继承的类命名：子类，派生类

　　　　　　--种类：单继承和多继承。

　　　　　　--继承的过程：从一般到特殊的过程。

　　　　　　　　　　　　　这里“一般”指：父类这样的对一个角色具有共同点。

　　　　　　　　　　　　　这里“特殊”指：子类这样的对每一个角色的不同点的单独定义

　　　　　　--实现方式有2类：实现继承 和 接口继承

　　　　　　　　　　　　　实现继承：指父类具有的功能，子类继承后直接调用不需再修改。

　　　　　　　　　　　　　接口继承：指仅使用父类的属性和方法的名称，具体实现需要在子类里单独实现。

举例：单继承基本继承写法

 class Person(object):
     def __init__(self,name,age=22):
         self.NAME = name
         self.AGE = age
         self.storage = 'Normal'
     def talk(self):
         print('custom ......')
 class blackPerson(Person):
     def __init__(self,name,age,job):
         Person.__init__(self,name,age)  #继承父类的属性（经典写法）
         self.JOB = job
     def talk(self):
         Person.talk(self)   # 继承父类的方法，不过这样没有意义，
         print('非洲语言')
 class writePerson(Person):
     def __init__(self,name,mess):
         Person.__init__(self,name)
         self.MESS = mess
     def talk(self):
         print('speak ENGLISH')

　-- 多态：同样的方法名的同时又对父类的方法做了不同的实现，这就是同一事务表现的多种形态。特点接口重用。

　　　　　（举例：父类定义人会说话，子类分黄种人说汉语，白种人说英语）这就是多态。实现是改写父类的talk方法

举例：python中多态的写法

 class Animal(object):
     def __init(self,name):
         self.name = name
     def talk(self):
         raise NotImplementedError('Subclass must implement abstrace method') #提示一个需要子类重写的错误
 class Cat(Animal):
     def talk(self):  # 子类重写
         return 'miao'
 class dog(Animal):
     def talk(self):  # 子类重写
         return 'wang'
 d = dog()
 c = Cat()
 def animal_talk(arg):  # 这里使用单独一个函数实现多态功能
     return arg.talk()
 print(animal_talk(d))
 print(animal_talk(c))

类的属性分如下：

　　-- 公有属性（静态字段）：所有属于这个类的对象都可以访问的属性，（在类里直接定义的属性，class下一行定义的）

　　　　　　　修改方法：1：通过对象修改，只改变该对象的属性值，相当于在对象本地内存新创建一个属性值（默认是引用类里的全局变量）

　　　　　　　　　　　　2：通过“类.公有属性名”修改，将改变的是全局属性值。

　　　　　　　　　　　　（疑问解释：类中的构造函数不都可以访问么，说的是实例对象，一个实例对象赋给的参数值在其他对象是无法访问的。所以构造函数不属于公有属性。

　　　　　　　　　　　　　　　　　　比如：实例化了2个对象a,b，其中实例化a的参数值（a=fun(1,2,3）)，对象b就无法访问a的参数值。）

　　--成员属性（普通字段）：构造函数中的self变量。

　　--私有属性：在类中以“__字符串”，双下划线开始的变量名即为私有属性。正常情况下私有属性在类外部是无法访问的。

　　　　　访问方法有2种：1：通过在类里定义普通方法来return返回私有属性。2：强制访问写法：实例名._类名__私有属性名。

　　　　　　　　　　举例：使用第一个方法对外提供私有属性访问接口

　　　　　　　　　　　　　　def get_hart():

　　　　　　　　　　　　　　　　return self.__heart  #这里就直接返回私有属性值

类的方法分如下：

　　-- 普通方法：类中定义的常用方法。def定义的

　　　　　　小知识（如何将普通方法变为私有方法，1：单独写一个函数，比如名为fun2，然后重写对象的方法名，如d1.fun = fun2，最后执行此对象的方法d1.fun(d1)）

　　-- 析构方法：语法：def __del__(self)，在引用的变量被清空的时候或者通过手工del删除引用的变量后就会自动调用此方法进行内存回收。

　　　　　　一般用于程序的收尾，比如服务器端要停止服务，这时就需要它来清空客户端的连接。（另说明，只要类被实例化了就算是使用中，将不会自动回收）

　　-- 类方法：只能访问类变量（公有属性），不能访问实例变量，一般用在实例化对象后，无法对本身限定好的数据进行修改。

　　　　　　　　举例说明：　　　　　　　　　　

　　　　　　　　　　　　class f1:
　　　　　　　　　　　　　　name = 'jack'  #类变量
　　　　　　　　　　　　　　@classmethod #类方法
　　　　　　　　　　　　　　def fun(self):
　　　　　　　　　　　　　　　　print('classmethod %s' % self.name) # 这里数据只用使用name的值，无法修改

　　-- 静态方法：类里定义的方法，当不需要通过self往里传值的时候，就可以将此方法定义为静态方法。

　　　　　　　　举例说明：

　　　　　　　　　　　　class f1:
　　　　　　　　　　　　　　@staticmethod  # 静态方法写法
　　　　　　　　　　　　　　def fun():     # 注意 静态方法是不需要self传值，这里不写self
　　　　　　　　　　　　　　print('staticmethod')
　　　　　　　　　　　　调用方法为： f1.fun()

　　-- 属性方法：把一个方法变成一个静态属性，属性就不需要加括号调用，一般用于最终展示给用户看得结果　　

　　　　　　　　举例说明：

　　　　　　　　　　　　class f1:
　　　　　　　　　　　　　　def __init__(self):
　　　　　　　　　　　　　　　　self.__food = None # 为属性方法设置的私有属性（用于传值的，如果不使用setter方法，就可以不写）
　　　　　　　　　　　　　　@property #属性方法 （静态属性）默认这里只能打印固定数据，无法赋值
　　　　　　　　　　　　　　def fun(self): # 方法名
　　　　　　　　　　　　　　　　print('property: %s' % self.name,self.__food)
　　　　　　　　　　　　　　@fun.setter # 实现对属性方法赋值功能（注意这里的fun要和上面的方法名一致）
　　　　　　　　　　　　　　def fun(self,food):
　　　　　　　　　　　　　　　　print('set to food:',food)
　　　　　　　　　　　　　　　　self.__food = food    # 实现对私有属性的赋值
　　　　　　　　　　　　　　@fun.deleter # 实现删除属性方法的赋值
　　　　　　　　　　　　　　def fun(self):
　　　　　　　　　　　　　　　　del self.__food # 删除私有变量

　　　　　　　　　　　　调用方法：d = f1() ; d.fun # 打印属性方法
　　　　　　　　　　　　赋值方法：d.fun = 'baozi' # 赋值
　　　　　　　　　　　　删除赋值：del d.fun #删除

　　-- 内置方法：类里以：__名称__  这样结构的方法称为类的内置方法。

　　　　　　　　1：__doc__：类的描述信息，就是打印类名下的注释信息
　　　　　　　　2：__module__：表示当前操作的对象在哪个模块
　　　　　　　　　  __class__：表示当前操作的对象的类名
　　　　　　　　3:__init__：构造函数，通过类创建对象时，自动触发执行。
　　　　　　　　4：__del__：析构函数，当对象在内存中被释放时，自动触发。
　　　　　　　　5：__call__：对象后面加括号，触发执行。

　　　　　　　　　　　　举例说明：

　　　　　　　　　　　　　　class cla1(object):
　　　　　　　　　　　　　　　　def __call__(self, *args, **kwargs):
　　　　　　　　　　　　　　　　　　print(args,kwargs)
　　　　　　　　　　　　　　ins = cla1()
　　　　　　　　　　　　　　ins('jace','vivi',name='jack',age=22)  # 这里执行对象直接返回
　　　　　　　　　　　　　　返回：('jace', 'vivi') {'name': 'jack', 'age': 22}　　　　　　　　

　　　　　　　　6：__dict__：查看类或对象中的所有成员
　　　　　　　　　　　　print(类名.__dict__)：打印类里的所有属性，不包括实例属性。print(实例名.__dict__)：打印实例里所有的属性，不包括类属性
　　　　　　　　7：__str__：如果一个类中定义了此方法，那么在打印实例对象时，默认输出该方法的返回值

 class Person(object):
     def __init__(self, name, gender):
         self.name = name
         self.gender = gender
     def __str__(self):
         return '(Person: %s, %s)' % (self.name, self.gender)
 现在，在交互式命令行下用 print 试试：

 >>> p = Person('Bob', 'male')
 >>> print p
 (Person: Bob, male)

　　　　　　　　8：__repr__：在python3里发现直接运行实例和使用pring 输出的状态和__str__ 相同。没看出有什么区别。但是通过sqlalchemy的创建表结构里可以看出区别，

　　　　　　　　　　　　　　   通过在表结构里定义__str__返回来的数据是内存对象，通过在表结构里定义__repr__返回来的是转换后的字符串。

　　　　　　　　9：__getitem__ / __setitem__ / __delitem__ ：用于索引操作，分别表示获取，设置，删除数据。

　　　　　　　　　　　　举例说明：

 class cla1(object):
     def __init__(self):
         self.data = {}
     def __getitem__(self, key):
         print("__getitem__: %s" % key)
         return self.data.get(key)
     def __setitem__(self, key, value):
         print('__setattr__:%s,%s' % (key,value))
         self.data[key] = value
     def __delitem__(self, key):
         print('__delitem__:%s' % (key))
 ins = cla1()
 ins['name'] = 'jack'  #调用setitem赋值
 print(ins['name']) # 调用getitem打印
 print(ins.data)   # 打印实例属性

　　　　　　　　

　　　　　　　　10:__new__：先于构造函数执行，构造函数是通过New来自动执行的。所以new是用来创建实例的，默认不用写
　　　　　　　　　　　  用处：可以在类进行实例化之前，通过new进行定制

 class foo(object):
     def __init__(self,name):
         self.name = name
         print('foo --init--')
     def __new__(cls, *args, **kwargs):
         print('foo --new--')
         return object.__new__(cls) # 继承父类的new方法，如果注销这个，将不会自动执行构造函数，
         #以上这行解释，类foo也是一个对象，这里的cls就是foo对象本身，也就相当于self概念。
 f = foo('jack')

　　　　　　　　11：__metaclass__ ： 指定当前类的原类名称，可以修改原类对当前类进行重新设置。在上面的new执行之前，
　　　　　　　　　　执行顺序为：第一步执行metaclass的init方法，第二步执行metaclass的call方法，第三步执行foo函数的new方法，第四步执行foo的initd方法，

　　　　　　　　　　　　　　　　这就是实例化整个路线图。
　　　　　　　　　　　　看代码：

 class Mytype(type):
     def __init__(self):                #第一步
         super(Mytype.self).__init__(what,bases,dict)
     def __call__(self,*args,**kwargs):        #第二步
         .....
 class foo(object):
     __metaclass__ = 'Mytype'
     def __init__(self,..):            # 第四步 实例化完成
         .....
     def __new__(cls,*args,**kwargs):
         return object.__new__(cls)        #第三步

　　　　　　　　　　　　看图：

类的 分类：有2种，第一种是：新式类。第二种是：经典类

　　-- 他们的区别：1：新式类需要在类名后加(object),经典类不需要，直接定义类名。2：继承方式写法不同。

　　-- 继承方式：在Python3中全部（新式类/经典类）为广度优先，在Python2中经典为深度优先，新式类为广度优先。

　　-- 继承写法：新式类使用super，经典类直接使用父类名初始化。

　　　　　　　　举例说明：

　　　　　　　　　　　　class A(object):
　　　　　　　　　　　　　　def __init__(self):
　　　　　　　　　　　　　　　　self.n = 'A'
　　　　　　　　　　　　class B(A):
　　　　　　　　　　　　　　def __init__(self):
　　　　　　　　　　　　　　　　self.n = 'B'
　　　　　　　　　　　　class C(A):
　　　　　　　　　　　　　　　　def __init__(self):
　　　　　　　　　　　　　　　　self.n = 'C'
　　　　　　　　　　　　class D(B,C):
　　　　　　　　　　　　　　pass

　　　　　　　　　　　　mess = fun4() ； print(mess.n)
解释：在python3中，无论是新式类还是经典类，继承顺序都是广度优先，以上顺序为：B->C-A
　　   在python2中，新式类继承顺序为广度优先，如上，经典类是深度优先为：B->A->C

举例单独说明类中的self。（self == 实例对象）

class dog(object):
　　def __init__(self,name):
　　　　self.NAME = name
　　def sayhi(self):
　　　　print('wang wang wang , dog name %s' % (self.NAME))

dg1 = dog('jinba')  # 相当于:dog(dg1,'jinba') 注意：self == dg1（实例对象）
dg1.sayhi() 　　　　#  就相当于：dg1.sayhi(dg1)，因为self在类中默认是传入的。