python中的oop面向对象基本编程（类、实例、魔术）

OOP面向对象（老师说这玩意蕴含基本哲学哦！！）
面向对象编程――Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。数据封装、继承和多态是面向对象的三大特点。面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。______________________________________________________________

一.定义类和创建实例

#!/usr/bin/env python
class dog():
def __init__(self,name,age,s,color):
self.name = name
self.age = age
self.single = s
self.color = color
def walk(self):
self.a = 'aaa'
self.b = 100
print 'running dog'
def eat(self,food):
print 'eat..',food
def talk(self):
print 'w w w'
w = dog('heizi',1,True,'black')
l = dog('nana',3,True,'yellow')
l.money = 'bumai!'
print l.money
print w.name

1.class后面紧接着是类名，类的类型分为经典类和新式类，经典类后面括号不继承任何东西。新式类括号里面面一般最好添加(object),表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

2.由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，age等属性绑上去。

3.注意到__init__为初始化方法，第一个参数永远是self，表示创建的实例本身

4.变量w就是指向dog的类的实例变量，而dog本身就是一个类。（）里面的都是给他捆绑的属性。

5.有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去//另外和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数和关键字参数。

6.类的方法：在上面的dog类中，每个实例就拥有各自的name和age这些数据，因为dog的实例本身就有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在dog类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和dog类本身是关联起来的，我们称之为类的方法。要定义一个方法，除了第一个参数是

self

外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了

self

不用传递，其他参数正常传入

7.类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；
方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；
通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。
____________________________________________________________________________________
二。
1、实例变量:实例化之后，每个实例单独拥有的变量。(上一个例子已经提到过见 一。 4 )
2、类变量：定义在方法之外的变量，所有的实例共享一个变量（它们不是单独分配给每个实例的）。通过某个实例去修改某个类变量，不影响其他实例，不影响类本身。类方法禁止调用类的关键字。
//@classmethod 内置装饰器
//方法也有返回值，只有函数的返回值才能赋给一个变量.
3、静态方法：要在类中使用静态方法，需在类成员函数前面加上@staticmethod标记符，以表示下面的成员函数是静态函数。使用静态方法的好处是，不需要定义实例即可使用这个方法。另外，多个实例共享此静态方法。
4、类方法：前面已经提到过（见一、6）

#!/usr/bin/env python
class dog(object):
a = 100      #为类变量
def __init__(self,num):
self.n = num

@classmethod
def cls_m(cls):
print 'cls_m'

@staticmethod       #静态方法 该装饰器不再需要cls参数
def static_m(a,b):
print a,b

dog.static_m(3,4)   #调用静态函数
print Dog.a   #打印类变量
d = dog(200)
d.static_m(1,2)

____________________________________________________________________________________
三、魔术方法：

#!/usr/bin/env python
class Dog(object):
def __init__(self,num,m):        #初始化方法（最基本的一个魔术方法）
self.age = num
self.__money = m         #私有方法，在外面看不到。
def test(self):
return 100
def echo_info(self):
return self.test()
def __eq__(self,other):                  #以下都是魔术方法
return self.age == other.age
def __gt__(self,other):
return self.age > other.age
def __ne__(self,other):
return self.age != other.age
def __add__(self,other):
return self.age + other.age
def __del__(self):                       #析构函数，清理善后,在最后输出
print 'world'

d = Dog(2,888)
d2 = Dog(4,666）
print d + d2         #当出现  +  ，调用 __add__ 魔术方法，其余同理

用于比较的魔术方法__eq__(self, other) 定义了等号的行为, ==
__ne__(self, other) 定义了不等号的行为, !=
__lt__(self, other) 定义了小于号的行为， <
__gt__(self, other) 定义了大于等于号的行为， >=

一个类的两个对象相加或者进行其他运算 得到新的对象。
运算符重载是在进行操作的时候解释器调用相应的魔术方法，当出现 + ，调用 __add__ 魔术方法，其余同理。

#!/usr/bin/env python

class resurce(object):
def __init__(self):
print "call resource init"

def __new__(cls,*args,**kwargs):         ##只在新式类中出现
print 'resrouce new'
return object.__new__(DockerResource,*args,**kwargs)
#如果上面括号里的DockerResource为cls，则调用当前类的__init__

class DockerResource(object):
def __new__(cls,*args,**kwargs):
print 'call docker resource new'
return object.__new__(cls,*args,**kwargs)
def __init__(self):
print 'call docker resource init'
def test(self):
print 'call docker resource init'

r = resource()
print type(r)  # 打印的结果显示r其实是DockerResource类的实例

r.test()      #这里调用的肯定也是DockerResource类下的test

#如果DockerResource中没有定义__new__()方法，那么会自动调用其父类resurce的__new__()方法来制造实例，即 DockerResource.__new__(cls, *args, **kwargs)

输出结果：resrouce new <class '__main__.DockerResource'>
docker resource tes

构造和初始化：。

__ init__(self, *args, **kwargs) 创建完对象后调用，对当前对象的实例的一些初始化，无返回值,即在调用__new__之后，根据返回的实例初始化；注意，这里的第一个参数是self即对象本身。

2. __ new__(cls, *args, **kwargs) 创建对象时调用，返回当前对象的一个实例;注意：这里的第一个参数是cls即class本身，其他的参数是用来直接传递给 __init__ 方法。 __new__ 方法相当不常用,但是它有自己的特性，特别是当继承一个不可变的类型比如一个tuple或者string。3.因此可以这么描述__new__()和__ini__()的区别，在新式类中__new__()才是真正的实例化方法，为类提供外壳制造出实例框架，然后调用该框架内的构造方法__init__()使其丰满。

__________________________________________________________________四、继承在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
继承的好处就是，子类只可以继承父类的所有功能，甚至还可以改进（添加一些新的功能），更加方便使用。

#!/usr/bin/env python

class Phone(object):
def __init__(self,size,color,memory):
self.size = size
self.color = color
self.memory = memory
def call(self):
s = 'I can call'
return s
def sms(self):
s = 'Are you gua le mei?'
return s
class Phones(Phone):            #这里的Phones类为子类，继承了上面父类Phone的功能
def __init__(self,size,color,memory,pix):      #子类和父类都有__init__ ，为了重写，扩展功能
self.pix = pix
super(Phones,self).__init__(size,color,memory)  #这里继承了父类的哪些功能

def install_app (self,app):
s = 'install app ing.....'
return s
p = Phone(1.2,'black','4M')
sms = p.sms()
print sms
iphone = Phones(4.7,'rosegold','4G','1280*780')   #传入子类的新属性，覆盖父类。
s = iphone.install_app('wechat')                  #调用子类的方法
print s

本文出自 “zkl” 博客，请务必保留此出处http://herla.blog.51cto.com/11707971/1793475