python类及其方法

一、介绍

在 Python 中，面向对象编程主要有两个主题，就是类和类实例
类与实例：
类与实例相互关联着：类是对象的定义，而实例是"真正的实物"，它存放了类中所定义的对象
的具体信息。

类有这样一些的优点：

1、类对象是多态的：也就是多种形态，这意味着我们可以对不同的类对象使用同样的操作方法，而不需要额外写代码。
2、类的封装：封装之后，可以直接调用类的对象，来操作内部的一些类方法，不需要让使用者看到代码工作的细节。
3、类的继承：类可以从其它类或者元类中继承它们的方法，直接使用。

二、类的定义

1.定义类（class）的语法

>>> class Iplaypython:
>>>     def fname(self, name):
>>>           self.name = name

一第行，语法是class 后面紧接着，类的名字，最后别忘记“冒号”，这样来定义一个类。
类的名字，首字母，有一个不可文的规定，最好是大写，这样需要在代码中识别区分每个类。
第二行开始是类的方法，大家看到了，和函数非常相似，但是与普通函数不同的是，它的内部有一个“self”，参数，它的作用是对于对象自身的引用。

2.初始化对象

创建类时，可以定义一个特定的方法，名为init(),只要创建这个类的一个实例就会运行这个方法。可以向init()方法传递参数，这样创建对象时就可以把属性设置为你希望的值init()这个方法会在创建对象时完成初始化

>>> class peo:
...     def __init__(self,name,age,sex):
...             self.Name = name
...             self.Age = age
...             self.Sex = sex
...     def speak(self):
...             print "my name" + self.Name
...

实例化这个类的对象时：

>>> zhangsan=peo("zhangsan",24,'man')
>>> print zhangsan.Age
24
>>> print zhangsan.Name
zhangsan
>>> print zhangsan.Sex
man

之前多次用到self这个形参类就好比是一张蓝图，使用一个类可以创建多个对象实例，speak()方法在被调用时，必须知道是哪个对象调用了它.

这里self参数就会告诉方法是哪个对象来调用的.这称为实例引用。

3.类的私有属性：

__private_attrs 两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs
类的方法
　　在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
私有的类方法
　　__private_method 两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用slef.__private_methods

4.classmethod类方法

1. 在python中.类方法 @classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。
2. 普通对象方法至少需要一个self参数，代表类对象实例
   3)类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。 对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法, 也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
class info(object):

　　@classmethod
　　def sayclassmethod(cls):

　　　　print 'say %s' % cls

　　def saymethod(self):

　　　　print 'say %s' % self


test = info()
test.saymethod()##实例调用方法
test.sayclassmethod()##实例调用类方法
info.saymethod(test)##类调用实例方法
info.sayclassmethod()##类调用类方法

大家对比运行下。

5.类的装饰器@property

class Pager:
    def __init__(self,all_count):
        self.all_count=all_count
    @property
    def all_pager(self):
        a,b=divmod(self.all_count,10)
        if a==0:
            return a
        else:
            return  a+1

    @all_pager.setter
    def all_pager(self,value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print('hehe')
p=Pager(101)
ret=p.all_count#以访问类属性的方法访问对象的方法
print(ret)

下面看第二种方法

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
class Pager:
    def __init__(self,all_count):
        self.all_count=all_count
    def f1(self):
        return 123
    def f2(self,value):
        print('======')
    def f3(self):
        print('+++++++')

    foo=property(fget=f1,fset=f2,fdel=f3)
p=Pager(101)
ret=p.foo
p.foo='alex'
print(p.foo)
del p.foo

在该类中定义三个函数，分别用作赋值、取值、删除变量

property函数原型为property(fget=None,fset=None,fdel=None,doc=None)，上例根据自己定义相应的函数赋值即可。

三、继承类定义：

1.单继承

class <类名>(父类名)
<语句>

 class childbook(book)
     age = 10

单继承示例

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
class student(people):  
        grade = ''  
        def __init__(self,n,a,w,g):  
            #调用父类的构函  
            people.__init__(self,n,a,w)  
            self.grade = g  
        #覆写父类的方法  
        def speak(self):  
            print("%s is speaking: I am %d years old,and I am in grade %d"%(self.name,self.age,self.grade))       

    s = student('ken',20,60,3)  
    s.speak()

2.类的多重继承
class 类名(父类1,父类2,....,父类n)
<语句1>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法

另一个类，多重继承之前的准备

class speaker():  
    topic = ''  
    name = ''  
    def __init__(self,n,t):  
        self.name = n  
        self.topic = t  
    def speak(self):  
        print("I am %s,I am a speaker!My topic is %s"%(self.name,self.topic))

多重继承

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
class sample(speaker,student):  
    a =''  
    def __init__(self,n,a,w,g,t):  
        student.__init__(self,n,a,w,g)  
        speaker.__init__(self,n,t)  

test = sample("Tim",25,80,4,"Python")  
test.speak()#方法名同，默认调用的是在括号中排前地父类的方法

四、类的专业方法

Python 类可以定义专用方法,专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的，而不是在代码中直接调用（象普通的方法那样）。

1 __ init__
类似于构造函数

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#!/usr/local/bin/python
class Study:
        def __init__(self,name=None):
                self.name = name
        def say(self):
                print self.name
study = Study("Badboy")
study.say()

2 __ del__
类似于析构函数

#!/usr/local/bin/python
class Study:
        def __init__(self,name=None):
                self.name = name
        def __del__(self):
                print "Iamaway,baby!"
        def say(self):
                print self.name
study = Study("zhuzhengjun")
study.say()

3__repr__
使用repr(obj)的时候，会自动调用repr函数，该函数返回对象字符串表达式，
用于重建对象，如果eval(repr(obj))会得到一个对象的拷贝。

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#!/usr/local/bin/python
class Study:
        def __init__(self,name=None):
                self.name = name
        def __del__(self):
                print "Iamaway,baby!"
        def say(self):
                print self.name
        def __repr__(self):
                return "Study('jacky')"
study = Study("zhuzhengjun")
study.say()
print type(repr(Study("zhuzhengjun"))) # str
print type(eval(repr(Study("zhuzhengjun")))) # instance

study = eval(repr(Study("zhuzhengjun")))

study.say()

4__str__
Python能用print语句输出内建数据类型。有时，程序员希望定义一个类，要求它的对象也能用print语句输出。Python类可定义特殊方法str，为类的对象提供一个不正式的字符串表示。如果类的客户程序包含以下语句：

print objectOfClass

那么Python会调用对象的str方法，并输出那个方法所返回的字符串。

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#!/usr/local/bin/python

class PhoneNumber:
        def __init__(self,number):
                 self.areaCode=number[1:4]
                 self.exchange=number[6:9]
                 self.line=number[10:14]

        def __str__(self):
                return "(%s) %s-%s"%(self.areaCode,self.exchange,self.line)

def test():
         newNumber=raw_input("Enter phone number in the form. (123) 456-7890: \n")
         phone=PhoneNumber(newNumber)
         print "The phone number is:"
         print phone

if__name__=="__main__":
         test()

方法init接收一个形如"(xxx) xxx-xxxx"的字符串。字符串中的每个x都是电话号码的一个位数。方法对字符串进行分解，并将电话号码的不同部分作为属性存储。

方法str是一个特殊方法，它构造并返回PhoneNumber类的一个对象的字符串表示。解析器一旦遇到如下语句：

print phone

就会执行以下语句：

print phone.__str__()

程序如果将PhoneNumber对象传给内建函数str(如str(phone)),或者为PhoneNumber对象使用字符串格式化运算符%(例如"%s"%phone),Python也会调用str方法。

5__cmp __
比较运算符，0：等于 1：大于 -1：小于

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
class Study:  
     def __cmp__(self, other):  
         if other > 0 :  
             return 1  
         elif other < 0:  
             return - 1  
         else:  
             return 0  
   
study = Study()  
if study > -10:print 'ok1'  
if study < -10:print 'ok2'  
if study == 0:print 'ok3'

打印：ok2 ok3
说明:在对类进行比较时，python自动调用cmp方法，如-10 < 0 返回 -1，也就是说study 应该小与 -10，估打印ok2

6__getitem__
__ getitem__ 专用方法很简单。象普通的方法 clear，keys 和 values 一样，它只是重定向到字典，返回字典的值。

class Zoo:  
     def __getitem__(self, key):  
         if key == 'dog':return 'dog'  
         elif key == 'pig':return  'pig'  
         elif key == 'wolf':return 'wolf'  
         else:return 'unknown'  
   
zoo = Zoo()  
print zoo['dog']  
print zoo['pig']  
print zoo['wolf']

打印 dog pig wolf

7__setitem__
setitem 简单地重定向到真正的字典 self.data ，让它来进行工作。

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333 
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
class Zoo:  
     def __setitem__(self, key, value):  
         print 'key=%s,value=%s' % (key, value)  
   
zoo = Zoo()  
zoo['a'] = 'a'  
zoo['b'] = 'b'  
zoo['c'] = 'c'
打印：
key=a,value=a
key=b,value=b
key=c,value=c

8 __ delitem__
delitem 在调用 del instance[key] 时调用 ，你可能记得它作为从字典中删除单个元素的方法。当你在类实例中使用 del 时，Python 替你调用 delitem 专用方法。

class A:  
     def __delitem__(self, key):  
         print 'delete item:%s' %key  
   
a = A()  
del a['key']