python之面向对象那点事

一、类与对象

１、什么是类？
类，顾名思义，就是具体相同属性的同一类事物的统称及抽象。
对象，指是就是具体的抽象类的实例

以上的说法是不是看起来有点云里来雾里去呢。没错，专业的解释总是让人难以理解，这就是专家。其实举个简单的例子大家就能理解了
如：牛马羊鸡鸭鹅，这些都是统称为　动物，没错吧。那动物就是上面所谓的类，而牛马羊鸡鸭鹅就是类中对应的实例，也就是对象。牛是对象，羊是对象，。。。现在明白了吧

python类是怎么定义和使用的，废话少说，上图，一目了然

 

２、类的成员：从上图可以看到，类包含了很多成员，那类中成员的分类是怎样的呢，看下图

３、类的三大特性：封装，继承，多态（python多态用得非常少）

何为封装：先来看个小问题，比如说要对数据库进行增删改查操作，那么我们可以定义４个函数用于实现这些功能。但每次调用这些函数时我们就必须给这些函数传参数，必须告诉这些函数要所边的数据库实例，用户名，密码，端口号等信息。这样一个，每一次的调用都是传这些相同的信息。１、是不是有更好的方法来使用这个重复的操作呢？２、另对于面向函数的调用，事实我们并不知道到底是谁用了函数。

对于面向对象来说，封装的概念实际上就是用于解决此类场景所产生的问题的。事实上我们可以这些公用的信息都放在构造函数中的参数中，即当实例化一个对象时就给这个对象赋予了这些信息，然后方法的调用就不用再重复在函数中传入这些参数了。调用方法时用指定的对象去调用这些方法，就知道是谁调用了，举个例子就清楚了

>>> #函数实现
... 
>>> def fetch(conn_info):
...     print "use %s conn to db for fetch" % conn_info
... 
>>> def modify(conn_info):
...     print "use %s conn to db for modify" % conn_info
... 
>>> #函数调用,每调用一次都需要传入参数
... fetch('scott 123 127.0.0.1')
use scott 123 127.0.0.1 conn to db for fetch
>>> modify('scott 123 127.0.0.1')
use scott 123 127.0.0.1 conn to db for modify
>>> 
>>> #类实现
... class A:
...     def __init__(self,conn_info):
...         self.conn_info = conn_info
...     def fetch(self):
...         print "use %s conn to db for fetch" % self.conn_info
...     def modify(self):
...         print "use %s conn to db for modify" % self.conn_info
... 
>>> #类调用
... #实例化一个对象,指明了谁（obj）调用，且公用参数只需要在实例化时传一次就行了
... obj = A('scott 123 127.0.0.1')
>>> obj.fetch()
use scott 123 127.0.0.1 conn to db for fetch
>>> obj.modify()
use scott 123 127.0.0.1 conn to db for modify
>>> 

 

４、类的继承

什么是继承？比如说两个人Ａ和Ｂ，Ａ可以行走吃喝，Ｂ也可以行走吃喝，且Ｂ还可以画画，而Ａ却不会，那么我们就可以说Ｂ继承于Ａ

#继承的定义
class A:
    def func1(self):
        print "func1"

class B(A):
    def func2(self):
        print "func2"

##实例化对象
obj2 = B()
##调用父类方法
obj2.func1()

以上代码就指明了Ｂ类继承于Ａ类，是不是很简单，且继承了Ａ类（父类后就可以通过对象调用你类的方法了）

 

５、多继承：那么一个类只能继承于另一个类吗，是否可以继承于多个类，答案是肯定了，这个是python特有，其它语言并没有这个特性。问题来了，如果一个类Ｄ继承于Ｂ，Ｃ两个类，Ｂ，Ｃ两个类均继承于Ａ类，Ｂ类没有方法func，Ｃ类有方法func,Ａ类也有方法func,那Ｄ类实例化后调用func方法到底是调用哪个类的方法呢？

举个例子就清楚了，在看例子之前，先说下python中类的分类（为什么？因为以上问题分两种情况，经典类与新式类是有所不同的），在python中类分为经典类和新式类，定义新式类只需要在定义指明该类继承于object类即可，如下　

#经典类
class A:
    pass

#新式类
class B(object):
    pass

##经典类的多继承
class A:
    def func(self):
        print "funcA"

class B(A):
    pass

class C(A):
    def func(self):
        print "funcC"

class D(B,C):
    pass

#实例化对象
obj = D()
#函数调用，打印funcA
obj.func()

##新式类的多继承
class A(object):
    def func(self):
        print "funcA"

class B(A):
    pass

class C(A):
    def func(self):
        print "funcC"

class D(B,C):
    pass

#实例化对象
obj = D()
#新式类函数调用，打印funcC
obj.func()

执行结果：

>>> ##经典类的多继承
... class A:
...     def func(self):
...         print "funcA"
... 
>>> class B(A):
...     pass
... 
>>> class C(A):
...     def func(self):
...         print "funcC"
... 
>>> class D(B,C):
...     pass
... 
>>> #实例化对象
... obj = D()
>>> #函数调用，打印funcA
... obj.func()
funcA
>>> 
>>> ##新式类的多继承
... class A(object):
...     def func(self):
...         print "funcA"
... 
>>> class B(A):
...     pass
... 
>>> class C(A):
...     def func(self):
...         print "funcC"
... 
>>> class D(B,C):
...     pass
... 
>>> #实例化对象
... obj = D()
>>> #新式类函数调用，打印funcC
... obj.func()
funcC

#从以上结果可以看出
经典类的查找是以深度优先为原则的，查询顺序:D->B->A，如果找不到，就报错，找到就调用
新式类的查询是以广度优先为原则的，查询顺序:D->B->C->A，如果找不到，就报错，找到就调用

 

６、类中常用的特殊成员
类名.__doc__ :打印类的注释信息（指用'''/"""引起来的注释信息）
类名/对象.__dict__:　返回类或对象包含的成员字典
__call__:在类中定义这个方法，事实上就是执行 对象() 调用的方法　
__str__:如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值　

７、其它相关
isinstance(obj, cls):检查是否obj是否是类 cls 的对象
issubclass(sub, super):检查sub类是否是 super 类的派生类

 ８、类的常用操作示例

class Person:
    class_v = 'beautiful' #静态字段／类变量
    salary = 10000
    __private_v = 'you can\'t read me from outside' #私有类变量
    def __init__(self,name,age):
        self.name = name ##普通字段
        self.age = age
        __male = 'girl' #静态私有字段
        self.favorite = 'cat'
    def speak(self,des): ##普通方法
        print "I'm {0},age {1},today is a {2} day!,so {3}".format(self.name,self.age,Person.class_v,des)
    @staticmethod
    def static_m(): #静态方法
        print "This is a static method!"
    @classmethod #类方法
    def class_m(cls,*args,**kwargs):
        print "This is a class method!"
    @property
    def attr_m(self): #属性，其实就是方法的变种
        return self.favorite #这里只是个例子，实际应用中一般是通过一定的逻辑处理得到相应的值
    @attr_m.setter #设置属性值
    def attr_m(self,value):
        self.favorite = value
        return self.favorite
    @attr_m.deleter #删除属性值
    def attr_m(self):
        del self.favorite
    def read_private(self): ##普通方法
        print Person.__private_v

class wo(Person): #继承
    def __init__(self,name):
        self.name = name
    def des(self):
        print "%s is a lovely girl!" % self.name

#类的实例化
obj = Person('min',18)
#访问类变量
print obj.salary
print Person.salary
obj.salary += 2000
print obj.salary
print Person.salary
Person.salary += 50000
print obj.salary
print Person.salary
##从上述结果可看出通过对象访问类变量并对其做修改并不影响在变量的值

#普通方法调用
obj.speak('nice')
#调用静态方法，必须通过类调用
Person.static_m()
#调用类方法，必须通过类调用
Person.class_m()
#访问属性
obj.attr_m
obj.attr_m = 'always cat!'
print obj.attr_m
del obj.attr_m
#测试私有类变量的打印　
obj.read_private()
#访问继承类的方法
min = wo('min')
min.des()

#访问类变量
Person.class_v
#访问私有类变量
Person.__private_v ##无法访问
obj._Person__private_v #强制访问私有成员

 执行结果：

>>> class Person:
...     class_v = 'beautiful' #静态字段／类变量
...     salary = 10000
...     __private_v = 'you can\'t read me from outside' #私有类变量
...     def __init__(self,name,age):
...         self.name = name ##普通字段
...         self.age = age
...         __male = 'girl' #静态私有字段
...         self.favorite = 'cat'
...     def speak(self,des): ##普通方法
...         print "I'm {0},age {1},today is a {2} day!,so {3}".format(self.name,self.age,Person.class_v,des)
...     @staticmethod
...     def static_m(): #静态方法
...         print "This is a static method!"
...     @classmethod #类方法
...     def class_m(cls,*args,**kwargs):
...         print "This is a class method!"
...     @property
...     def attr_m(self): #属性，其实就是方法的变种
...         return self.favorite #这里只是个例子，实际应用中一般是通过一定的逻辑处理得到相应的值
...     @attr_m.setter #设置属性值
...     def attr_m(self,value):
...         self.favorite = value
...         return self.favorite
...     @attr_m.deleter #删除属性值
...     def attr_m(self):
...         del self.favorite
...     def read_private(self): ##普通方法
...         print Person.__private_v
... 
>>> class wo(Person): #继承
...     def __init__(self,name):
...         self.name = name
...     def des(self):
...         print "%s is a lovely girl!" % self.name
... 
>>> #类的实例化
... obj = Person('min',18)
>>> #访问类变量
... print obj.salary
10000
>>> print Person.salary
10000
>>> obj.salary += 2000
>>> print obj.salary
12000
>>> print Person.salary
10000
>>> Person.salary += 50000
>>> print obj.salary
12000
>>> print Person.salary
60000
>>> ##从上述结果可看出通过对象访问类变量并对其做修改并不影响在变量的值
... 
>>> #普通方法调用
... obj.speak('nice')
I'm min,age 18,today is a beautiful day!,so nice
>>> #调用静态方法，必须通过类调用
... Person.static_m()
This is a static method!
>>> #调用类方法，必须通过类调用
... Person.class_m()
This is a class method!
>>> #访问属性
... obj.attr_m
'cat'
>>> obj.attr_m = 'always cat!'
>>> print obj.attr_m
always cat!
>>> del obj.attr_m
>>> #测试私有类变量的打印　
... obj.read_private()
you can't read me from outside
>>> #访问继承类的方法
... min = wo('min')
>>> min.des()
min is a lovely girl!
>>> 
>>> #访问类变量
... Person.class_v
'beautiful'
>>> #访问私有类变量
... Person.__private_v ##无法访问
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
AttributeError: class Person has no attribute '__private_v'
>>> obj._Person__private_v #强制访问私有成员
"you can't read me from outside"
>>>