[Python]-9-对象与类

引言

这篇文章介绍Python如何将函数与数据整合成类,并通过一个对象名称来访问它们。

文章目录

0×1.什么是python中的对象

Python中每条数据都是对象,每个对象都由三部分组成:标识,数据,类型;

标识是对象的名称,也储存了该对象的内存地址(对象引用),类型规定了这个对象所能储存的值的类型,内存中的某块区域保存了对象的数据值;

在之前的文章中,我们定义的字符串,列表,字典等,都是对象,每个对象都有其内置的一些方法,例如对字符串对象使用len()方法可以求出字符串的长度,我们可以在IDLE中使用dir()方法来查看某个对象可以使用的方法,如下:

					>>> s="www.qingsword.com"
					>>> dir(s)
					['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

					#上面中括号中的所有输出,以逗号分隔,每一个都是字符串对象可以使用的方法,其中带双下划线的为"内部方法",不带下划线的为"外部方法"也叫"接口函数","内部方法"通常对用户是不可见的,但这并不意味着内部方法就是不可调用的,实际上我们对某个字符串对象使用len()函数的时候,就是调用了其内部的__len__方法,通过下面的实例可以看到,两者的输出是相同的
					>>> print(len(s))
					17
					>>> print(s.__len__())
					17
					

在定义一个字符串对象的时候,python在其内部初始化了一个str类,这个类中包含了python提供的对字符串处理的内置方法,等大家看完本文第2部分,自己手动创建了一个类之后,就自然会明白上面这些内部方法和接口函数的工作原理了。

0×2.python中如何创建类

python中的类,实际上是完成某个工作的对象和函数的集合,当一个类被调用时,它创建了绑定到一个名称的对象,请看下面的实例,这是一个经典的电冰箱实例,我们假设要创建一个类,用于将食物放入冰箱,查询冰箱中有哪些食物,然后提供取出食物的一系列方法:

					#!/usr/bin/env python3
					#coding=utf-8

					########
					class Fridge:
					    """电冰箱类实例"""

					    #--------
					    def __init__(self,items={}):
					        """类初始化"""
					        if type(items)!=type({}):
					            raise TypeError("传入参数错误:%s"%items)
					        self.items=items
					########

					#python使用class关键字来定义一个类,本例定义了一个Fridge类,在这个类中有一个内部方法__init__,每个类都可以包含这个方法,也可以不包含,这个方法的作用是,当使用名称初始化一个Fridge对象时,自动执行__init__函数中的代码,相当于类的初始化操作

					#注意def __init__(self,items={})部分中的self参数,这是python独有的语法,self总是代表类对象本身,这段初始化代码初始化了一个空字典对象,如果不好理解self,可以尝试着将代码中的self省去,然后观察这段函数,实际上__init__就接收一个参数,这个参数必须是一个字典对象,如果省去这个参数,那么默认初始化一个空自字典,并且在Fridge内部使用items对象保存这个字典的数据,但实际情况下self参数不能省略

					#现在我们已经有了一个Fridge类,可以通过下面的方法创建这个类的对象实例,下面的语法没有给Fridge传递参数,所以将初始化一个空的字典,如果想要传递参数,可以这么写p=Fridge({"apple":1,"orange":3}),如果这样,那么Fridge中的items对象就将保存{"apple":1,"orange":3}这个字典
					p=Fridge()

					#现在有一个新的对象p,他是一个完整的Fridge类对象,在上面的创建过程中,Fridge类执行了__init__方法,这将创建一个空的字典对象,可以通过"类实例名称.类对象名称"来访问到这些数据
					print(p.items)

					#输出
					{}
					

现在,可以给Fridge类添加一系列方法来提供必要的功能了,在Fridge类中补充下面的内容,用于添加查询或删除食物:

					#!/usr/bin/env python3
					#coding=utf-8

					########
					class Fridge:
					    """电冰箱类实例"""

					    #--------
					    def __init__(self,items={}):
					        """类初始化"""
					        if type(items)!=type({}):
					            raise TypeError("传入参数错误:%s"%items)
					        self.items=items
					    
					    #--------
					    def __add_multi(self,food_name,quantity):
					        """内部方法,向items字典添加键值,如果food_name不在items字典的键列表中,说明这是一个新添加的食物,将数量初始化为0,然后加上传递给这个函数的quantity的值(可能是一个或者多个)"""
					        if (not food_name in self.items.keys()):
					            self. items[food_name]=0
					        self.items[food_name]+=quantity
					    
					    #--------
					    def add_one(self,food_name):
					        """向items字典添加单个食物,这就是一个接口函数,通过调用内部方法__add_multi完成添加食物到冰箱的工作"""
					        if type(food_name)!=type(""):
					            raise TypeError("食物名称类型错误:%s,正确的数据类型:%s"\
					                            %(type(food_name),type("")))
					        else:
					            self.__add_multi(food_name,1)
					        return True
					    
					    #--------
					    def add_many(self,food_dict):
					        """像items字典添加多个食物,这个接口函数接收一个字典参数food_dict,使用for循环遍历这个传递过来的字典中的键名,然后将名称和数量传递给__add_multi函数"""
					        if type(food_dict)!=type({}):
					            raise TypeError("食物名称和数量必须使用字典,错误的数据输入:%s"%food_dict)
					        else:
					            for food_name in food_dict.keys():
					                self.__add_multi(food_name,food_dict[food_name])
					                
					    #--------
					    def has(self,food_name,quantity=1):
					        """查看items中是是否还有某个食物,如果只向这个接口函数传递一个食物名称,那么quantity默认为1,他将调用下面的has_various函数,将食物名称和食物数量传递过去,用于判断冰箱中还有没有这么多的食物"""
					        return self.has_various({food_name:quantity})
					    
					    #--------
					    def has_various(self,foods):
					        """查看食物是否低于输入值,这个接口函数接受一个字典类型的传入参数,通过遍历这个传入的字典中的键名,判断Fridge的items字典中对应键的值是否小于传递进来的这个列表中的每个食物的值,如果小于就返回False,代表冰箱中没有那么多食物了,如果传入的食物名称不存在,会产生一个KeyError异常,同样返回False"""
					        try:
					            for food in foods.keys():
					                if self.items[food]<foods[food]:
					                    return False
					                return True
					        except KeyError:
					            return False
					            
					    #--------
					    def __get_multi(self,food_name,quantity):
					        """取出食物的内部方法,这个方法接受两个值,一个为食物名称,一个为食物数量,首先if判断冰箱中是否存在这种食物,如果有将其从类实例的items字典中减去对应数量,减去数量后再判断这种食物库存是否为0,如果为0,将其从items字典中删除,如果冰箱中没有这种食物或者库存不足(这些都在has_various方法中判断),跳转到else语句,判断是库存不足还是根本没有这种食物"""
					        if self.has(food_name,quantity):
					            self.items[food_name]-=quantity
					            print("成功取出%s,数量%s"%(food_name,quantity))
					            if self.items[food_name]==0:
					                self.items.pop(food_name)    
					        else:
					            if not food_name in self.items.keys():
					                print("冰箱中并没有这种食物:%s"%food_name)
					            else:
					                print("食物'%s'库存不足,现有数量:%s"%(food_name,self.items[food_name]))
					     
					    #--------
					    def get_one(self,food_name):
					        """取出某个食物,调用内部方法__get_multi取出单个食物"""
					        if type(food_name)!=type(""):
					            raise TypeError("食物名称类型错误:%s,正确的数据类型:%s"\
					                                        %(type(food_name),type("")))
					        else:
					            self.__get_multi(food_name, 1)
					        return True
					     
					    #--------
					    def get_many(self,food_dect):
					        """取出多个食物,这个函数接收一个字典参数,for循环遍历这个传入的字典中的键列表,调用__get_multi取出这些食物和对应的数量"""
					        if type(food_dect)!=type({}):
					            raise TypeError("食物名称和数量必须使用字典,错误的数据输入:%s"%food_dict)
					        for food in food_dect.keys():
					            self.__get_multi(food,food_dect[food])
					########       
					
					#初始化Fridge类
					p=Fridge()

					#添加食物
					p.add_one("orange")
					p.add_many({"apple":2,"banana":5})
					print(p.items)
					#输出
					{'apple': 2, 'orange': 1, 'banana': 5}

					#判断食物是否存在
					print(p.has("orange"))  #True
					print(p.has("apple",3)) #False

					#取出食物
					if p.has("orange"):
					    p.get_one("orange")
					p.get_mulit({"banana":4,"apple":4})
					p.get_one("www.qingsword.com")
					print(p.items)
					#输出
					成功取出orange,数量1
					成功取出banana,数量4
					食物'apple'库存不足,现有数量:2
					冰箱中并没有这种食物:www.qingsword.com
					{'apple': 2, 'banana': 1}
					

0×3.类私有属性访问限制

在上面的电冰箱实例中,我们已经创建过了私有方法,python中所谓的私有方法和属性,就是在这些方法或属性名前添加两个"下划线"(例如__items),这样的属性或方法是不能用正常的方法访问到的,但不包括前后双下划线的那些(例如__len__),下面用一个实例来演示这些私有属性和方法的特性:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class Kitty(object):
					    """私有属性__name和__age的类"""
					    #--------
					    def __init__(self,name="hello",age=1):
					        """初始化"""
					        self.__name=name
					        self.__age=age
					    #私有属性可以通过接口函数来调用
					    #--------
					    def get_age(self):
					        """返回年龄"""
					        return self.__age
					    #--------
					    def set_age(self,age):
					        """设置年龄"""
					        self.__age=age
					    #--------
					    def get_name(self):
					        """返回名字"""
					        return self.__name
					    #--------
					    def set_name(self,name):
					        """设置名字"""
					        self.__name=name
					    #前后双下划线的方法,不是私有方法,外部可以直接访问,只有前置双下划线的属性或方法才是私有的,自能通过内部接口函数调用
					    #--------
					    def __get_name_len__(self):
					        return len(self.__name)
					
					#实例化      
					kt=Kitty()
					#通过接口函数设置年龄和姓名
					kt.set_age(2)
					kt.set_name("www.qingsword.com")
					#通过接口函数打印姓名和年龄
					print(kt.get_name())
					print(kt.get_age())
					#打印出名字长度
					print(kt.__get_name_len__())

					#程序输出
					www.qingsword.com
					2
					17

					#从这个实例可以看出,前后带双下划线的方法或属性,都能直接访问到,而如果我们输入下面这3句,发现并没有报错,不是说私有属性不能直接访问吗,为什么可以直接kt.__name设置私有属性的值呢?这是因为,实际上我们使用实例kt.__name这种语法的时候,是对kt这个类实例,创建了一个新的属性__name,这个属性和Kitty内部的私有属性并不是一个属性,内部的__name属性已经被python解释器自动改名为_Kitty__name了
					kt.__name="qingsword.com"
					print(kt.__name)
					print(kt._Kitty__name)

					#从下面的程序输出可以看到,两者保存的数据并不相同
					qingsword.com
					www.qingsword.com

					#这并不意味着外部就真的无法调用这些私有属性或方法,只是python解释器自动对这些私有数据添加了类名前缀,可以给私有属性添加带但下划线的类名前缀来直接访问他们,但并不推荐这么做
					kt._Kitty__name="www.qingsword.com"

					#可能大家会觉得很奇怪,为什么要添加这些私有的属性或方法,直接提供访问不好吗?实际上,可以通过创建接口函数,对私有数据进行过滤处理,例如
					    #--------
					    def set_age(self,age):
					        """设置年龄"""
					        if 0<=age<=150:
					            self.__age=age
					        else:
					            print("年龄不科学")
					

0×4.继承与多态

我们在创建类的时候,默认情况下都是继承了python的基类object,除此之外,我们还能让新建的类继承现有的类,继承后子类将拥有被继承的父类所有的属性和方法,下面用一个实例来演示这一特性:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class Parent(object):
					    """父类,继承了object类,如果一个类是继承基类object,可以省略(object)不写,但写上看起来更加的规范"""
					    #--------
					    def print_website(self):
					        """打印网址"""
					        print("www.qingsword.com")
					    #--------
					    def print_author(self):
					        """打印作者名称"""
					        print("QingSword")
					########
					class Sub_A(Parent):
					    """继承Parent的子类,将父类写在子类后面的括号中,表示继承其所有的方法和属性,Sub_A重写了父类的print_website方法"""
					    #--------
					    def print_website(self):
					        """打印网址"""
					        print("qingsword.com")
					########
					class Sub_B(Parent):
					    """继承Parent的子类,仅仅是一个空类,但却可以使用父类所有属性或方法(注意,对空类最好添加一个这样的注释,否则在某些编辑器下可能会出现缩进IndentationError错误)"""
					########
					class Sub_C(object):
					    """继承object的子类"""
					    #--------
					    def print_author(self):
					        print("qingsword")
					        
					#--------
					def print_info(x):
					    """打印作者信息"""
					    x.print_author()
					
					#首先实例化四个类
					p=Parent()
					a=Sub_A()
					b=Sub_B()
					c=Sub_C()

					#访问父类的两个方法
					p.print_website()
					p.print_author()
					#程序输出
					www.qingsword.com
					QingSword

					#访问子类A的两个方法,如果一个子类中有与父类同名的属性或方法,那么它将覆盖父类的属性或方法,A类中重写了父类的print_website(),所以会优先被调用,虽然A类并没有print_author()方法,但是它将从父类Parent中继承这个方法,除非重写这个方法,否则就将直接调用父类的方法打印出作者信息
					a.print_website()
					a.print_author()
					#程序输出
					qingsword.com
					QingSword

					#B类中什么都没写,但他继承了父类Parent
					b.print_author()
					b.print_website()
					#程序输出
					www.qingsword.com
					QingSword
					
					#再来看看这些对象他们的类型都是什么

					#Parent类是继承object的,所以它可以是object类型,也可以是Parent类型,但不能是其子类型
					print(isinstance(p,Parent))
					print(isinstance(p,object))
					print(isinstance(p,Sub_A))
					#程序输出
					True
					True
					False

					#所有的子类型,可以是其父类型或Python基类object,也可以是其自身,所以下面的输出都是True
					print(isinstance(a,Parent))
					print(isinstance(a,Sub_A))
					print(isinstance(b,Parent))
					print(isinstance(b,Sub_B))

					#像print_info()方法传递四个类,四个类可以是不同类型,甚至可以像print_info()传递其他方法名称,这是高级动态语言的一个最强大的地方——多态:print_info()方法接收一个变量,它不管接收的变量是什么类型,只关心这个变量能不能访问print_author()方法,这就是为什么C类虽然是继承了object,但它也有print_author()方法,所以程序不会报错
					print_info(p)
					print_info(a)
					print_info(b)
					print_info(c)
					#程序输出
					QingSword
					QingSword
					QingSword
					qingsword
					

0×5.获取对象信息

除了使用isinstance来匹配对象类型外,还能使用type来获取这些对象的类型,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					#types模块中定义的常量可用于判断函数类型
					import types
					
					#输出对象的类型
					print(type("www.qingsword.com"))
					#判断对象是否为字符串类型
					print(type("qingsword.com")==str)
					#程序输出
					<class 'str'>
					True

					#如果对象是一个函数,就需要借助types模块中定义的常量来判断了
					#--------
					def fx():
					    return 0

					#判断fx是否为函数类型
					print(type(fx)==types.FunctionType)

					#判断是否为lambda类型
					print(type(lambda :0)==types.LambdaType)

					#判断len是否为内置的函数类型
					print(type(len)==types.BuiltinFunctionType)

					#判断表达式是否为列表生成器类型
					print(type((x for x in range(10)))==types.GeneratorType)

					#程序输出都为True

					#isinstance同样能够完成这些操作,例如将判断fx函数的语句改成下面这样,返回值同样是True
					print(isinstance(fx,types.FunctionType))
					

除了上面的两种对象类型判断外,配合getattr()、setattr()以及hasattr(),我们可以直接操作一个对象的状态,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					class Ob_A(object):
					    #---------
					    def __init__(self,x=0):
					        if type(x)==int:
					            self.a=x
					        else:
					            raise TypeError("传入参数类型(%s)错误,正确的参数类型int"%type(x))
					    #---------
					    def sq(self):
					        return self.a*self.a

					oba=Ob_A(12)

					#判断oba对象中是否有属性(或方法)a,返回True
					print(hasattr(oba,"a"))

					#获取属性(或方法)a,本例中a是一个属性值12,所以被print直接打印了出来
					print(getattr(oba,"a"))

					#是否有属性(或方法)b,返回False
					print(hasattr(oba,"b"))

					#给对象设置一个属性b,值为13
					setattr(oba,"b",13)

					#因为已经给对象添加了属性b,再次判断,返回True,并且打印出b的值13
					print(hasattr(oba,"b"))
					print(getattr(oba,"b"))

					#判断oba对象中是否存在sq属性(或方法)
					print(hasattr(oba,"sq"))

					#使用sq对象指向oba对象的sq方法
					sq=getattr(oba,"sq")

					#从type可以看到sq是一个方法类型
					print(type(sq))

					#执行sq方法,返回144
					print(sq())

					#程序输出
					True
					12
					False
					True
					13
					True
					<class 'method'>
					144
					

这三个函数可用于探测对象中的信息,只有在不知道对象信息的时候,才会使用这三个函数,如果已经明确知道了一个对象中包含了哪些属性和方法,请直接调用他们。

0×6.实例属性与类属性

python是动态语言,在实例化后,还能给实例添加新的属性,但最好不要与类中的属性同名,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					#Ob_A类中定义了一个类属性x,并且配置了其值为2
					class Ob_A(object):
					    x=2
					
					#实例化Ob_A类
					oba=Ob_A()

					#给oba实例创建一个新属性x,因为和Ob_A类中的属性同名,所以会覆盖原有属性值
					oba.x=1

					#打印出1
					print(oba.x)

					#类中的属性保持不变,打印出2
					print(Ob_A.x)

					#此时如果手动删除oba实例的x对象,再次打印oba实例的x对象,就会打印出原类中绑定的属性x值,打印出2
					del oba.x
					print(oba.x)

					#程序输出
					1
					2
					2
					

类在实例化后,如果需要给实例新增属性,建议属性名不要使用与原类中已经存在的属性同名,因为相同名称的实例属性将屏蔽掉类属性。

0×7.属性和方法的动态绑定

Python属于高级动态语言,与静态语言不同,当我们实例化一个类对象后,可以动态的给这个类实例绑定属性或方法,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					from types import MethodType

					#定义一个类,仅包含一个age属性
					class Ob_A(object):
					    def __init__(self,age=0):
					        self.age=age
					
					#实例化Ob_A类
					a=Ob_A(23)
					#给Ob_A类的实例a新增一个name属性
					a.name="qingsword"

					#定义一个外部方法,稍后将它绑定到a实例
					def get_sex(self):
					    return "male"
					
					#使用types模块中的MethodType方法,将get_sex这个外部方法绑定到a实例的getsex变量上
					a.getsex=MethodType(get_sex,a)

					#执行a实例的getsex()就相当于执行了get_sex()
					print(a.getsex())

					#程序输出
					male

					#getsex名称仅限于a实例调用,如果此时再实例化一个Ob_A类,除非再次使用MethodType绑定一个新的get_sex方法,否则这个新的类实例是不能使用get_sex这个外部方法的
					

从上面这个实例可以看出,Python不会限制一个对象实例绑定多少外部属性和方法,但如果要限制他们,可以在类中使用__slots__属性,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					from types import MethodType
					########
					class Ob_A(object):
					    def __init__(self,age=0):
					        self.age=age
					    #定义了 __slots__属性后,Ob_A自身和所有实例,都只能使用这个元组中所包含的元素作为属性或方法名称
					    __slots__=("name","age","get_sex")
					########
					#但__slots__属性对继承它的子类无效,除非这个子类中也包含一个__slots__属性,那么这个子类可以定义的属性或方法名就是自己的__slots__元组中包含的元素加上父类__slots__元组中包含的元素的集合
					class Ob_B(Ob_A):
					    x=0
					########
					def get_sex(self):
					    return "male"
					a=Ob_A(23)
					a.name="qingsword"
					a.get_sex=MethodType(get_sex,a)
					print(a.get_sex())

					#Ob_B类虽然继承Ob_A,但它没有包含__slots__属性,所以实例b可以添加任何属性或方法名,本例添加了一个web属性,指向了本站网址这段字符串地址
					b=Ob_B()
					b.web="www.qingsword.com"
					print(b.web)
					

0×8.如何将类方法封装成属性

这一部分将使用python内置的@property装饰器,将类中的方法转换成属性,在外部看来,这个方法就像一个普通属性那样使用,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					from datetime import datetime 
					########
					class Ob_A(object):
					    def __init__(self,birth=2016):
					        """初始化配置出身年份"""
					        self.__birth=birth
					    #使用@property装饰器将birth方法转换成属性
					    @property
					    def birth(self):
					        """获取出身年份"""
					        return self.__birth
					    #使用@方法名.setter将这个方法设置成可写属性(一个方法名称必须先使用过property装饰器,才能使用setter)
					    @birth.setter
					    def birth(self,birth):
					        """设置出身年份"""
					        self.__birth=birth
					    #仅有一个@property没有setter的方法,相当于一个只读属性
					    @property
					    def age(self):
					        """返回年龄"""
					        y=datetime.now()
					        return y.year-self.__birth

					x=Ob_A(2008)
					print(x.birth)
					#可以像设置属性值那样复制(如果是方法语法应该是x.birth(2000))
					x.birth=2000
					print(x.birth)
					print(x.age)

					#程序输出
					2008
					2000
					16
					

虽然上面的实例中,并没有对年龄做进一步的检测(比如年龄范围,输入类型等),但也不难看出,将函数封装成属性的样式可以让调用者写出更直观代码(比如x.birth=2000,而不是x.birth(2000)),而对封装者而言,可以在函数中去做各种条件判断来保证逻辑的合理。

0×9.类的多重继承

python中的类提供了多重继承的功能,比如C类可以继承B类同时又能继承A类,C类能够使用B和A类所有属性和方法,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A(object):
					    def _Print_website(self):
					        print("www.qingsword.com")
					########
					class B(object):
					    def _Print_HelloWorld(self):
					        print("Hello World")
					########
					#多重继承只需要在子类括号中用逗号分隔需要继承的类即可
					class C(A,B):
					    def __init__(self):
					        self.name="qingsword"
					
					#因为C类同时继承了A和B类,所以它的实例可以使用A和B类所有方法和属性
					x=C()
					x._Print_website()
					x._Print_HelloWorld()
					print(x.name)

					#程序输出
					www.qingsword.com
					Hello World
					qingsword
					

0×10.定制类

当我们实例化一个类对象后,使用print打印这个类对象,往往会打印出一个类名称和内存地址,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A:
					    #--------
					    def __init__(self,name="qingsword"):
					        self.name=name

					x=A("www.qingsword.com")
					print(x)

					#程序输出
					<__main__.A object at 0x7f41d6039f28>
					

为了让打印输出更加的友好,python提供了两个函数__str__和__repr__,前者可以让print打印一个对象时,输出这个函数下定制的返回信息;后者是在调试过程中让调试程序(IDLE提示符环境等)在直接输入对象时,能够打印出我们定制的信息,这两者通常写入相同的返回信息,例如,将上面的实例更改如下:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A:
					    #--------
					    def __init__(self,name="qingsword"):
					        self.name=name
					    #--------
					    def __str__(self):
					        """定制对象返回信息"""
					        return "Class A Object self.name=%s"%self.name
					    #直接让repr函数等于str
					    __repr__=__str__

					x=A("www.qingsword.com")
					print(x)

					#程序输出
					Class A Object self.name=www.qingsword.com
					

除了定制对象的输出信息外,如果一个类要用作for循环,Python提供了一个__iter__方法,该方法返回一个迭代对象,可使用for循环迭代这个对象,for会不断调用该对象的__next__()方法拿到循环的下一个值,直到遇到StopIteration错误(或break)退出循环,可以将一个类定制成可迭代类,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class Fib(object):
					    #--------
					    def __init__(self):
					        self.a,self.b=0,1
					    #实例本身就是迭代对象,所以iter函数返回自己
					    def __iter__(self):
					        return self
					    #如果对象中的a属性值大于20,就停止循环,否则返回每次循环中得到的a值
					    def __next__(self):
					        self.a,self.b=self.b,self.a+self.b
					        if self.a>20:
					            raise StopIteration()
					        return self.a 

					x=Fib()
					for y in x:
					    print(y)

					#这是一个斐波拉契迭代类,程序输出如下
					1
					1
					2
					3
					5
					8
					13

					#如果删除类中的self.a>20的判断,可以将for循环更改成
					for y in x:
					    #可以手动指定一个迭代范围
					    if y<20:
					        print(y)
					    else:
					        break
					

上面的可迭代类看起来更像是一个生成器,但现在我们还无法像列表那样使用一个索引来取得单个值,为此python提供了一个__getitem__方法,用于实现取得单个值的类,修改上面的程序如下:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class Fib(object): 
					    #根据输入的n,返回x的值
					    def __getitem__(self,n):
					        #x和y只是函数中的一个局部变量,每次调用函数,都会被重新设置成1
					        x,y=1,1
					        while n>0:
					            x,y=y,x+y
					            n-=1
					        return x
					        
					x=Fib()
					print(x[2])
					print(x[12])

					#程序输出
					2
					233
					

如果想要给这个类添加一个切片功能,可以修改上面的代码如下:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class Fib(object):
					    def __getitem__(self,n):
					        #判断传入的是一个分片类型还是一个索引值
					        if isinstance(n,int):
					            x,y=1,1
					            while n>0:
					                x,y=y,x+y
					                n-=1
					            return x
					        elif isinstance(n,slice):
					            #获取分片的起始值
					            start=n.start
					            stop=n.stop
					            if start is None:
					                start=0
					            x,y=1,1
					            L=[]
					            for a in range(stop):
					                if a>=start:
					                    L.append(x)
					                x,y=y,x+y
					            return L
					        
					x=Fib()
					print(x[12]) 
					print(x[:12])
					print(x[6:12])

					#程序输出
					233
					[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]
					[13, 21, 34, 55, 89, 144]
					

上面这个简单的分片器并没有对负数和分片步长做处理,仅仅是提供一个思路,告诉大家,通过这种定制函数,可以将一个类定制成任何数据类型,可以是列表字典元组等等。

通常情况下,我们调用一个对象的某个属性和方法时,如果这个属性和方法不存在,就会报错,如下所示:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A(object):
					    def __init__(self):
					        self._path=""

					x=A()
					#调用_path没有问题
					print(x._path)
					#但调用一个不存在的sub属性就会报错,提示sub属性不存在
					print(x.sub)
					

python提供了一个__getattr__函数,它接收一个不存在的属性或方法名称,然后返回一个我们设定的值,如果我们没有定义返回值,它将返回一个None,这比直接抛出一个错误要友好的多,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A(object):
					    def __init__(self):
					        self._path=""
					    def __getattr__(self,attr):
					        if attr=="blog":
					            return "www.qingsword.com"
					        elif attr=="doit":
					            return "ok"
					        #一个函数返回值
					        elif attr=="age":
					            return lambda :23

					x=A()
					print(x.blog)
					print(x.doit)
					print(x.age())
					print(x.nothing)

					#程序输出
					www.qingsword.com
					ok
					23
					None
					

请注意__getattr__函数只有当类中没有定义这些属性值时才接收他们,并且根据我们自己的判断返回值,如果类中有这些属性或方法,则会优先使用它们,另外,如果这个函数接收到了一个没有定义返回值的名称,默认返回None,除非手动抛出一个AttributeError,比如,在if的末尾添加下面的代码,再次运行就会抛出一个异常,提示nothing不存在:

					else:
					raise AttributeError("错误的属性或方法名:%s"%attr)	
					

__getattr__最常见的应用就是链式调用,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A(object):
					    def __init__(self,path=""):
					        self._path=path
					        print('self._path is %s' % self._path)
					    def __getattr__(self,attr):
					        return A("%s/%s"%(self._path,attr))
					    def __str__(self):
					        return self._path
					    __repr__=__str__

					x=A()
					print(x.www.qingsword.com)

					#程序输出
					#x=A()初始化时的输出
					self._path is
					#x.www时因为没有www属性,调用了__getattr__函数,并且传递了一个www,然后递归调用A,这一步相当于A("/www")
					self._path is /www
					#x.www.qingsword会再次激活__getattr__函数,因为www并没有qingsword属性,以此类推
					self._path is /www/qingsword 
					self._path is /www/qingsword/com
					/www/qingsword/com
					

我们在实例化一个对象的时候,可以通过"对象名.属性名"来使用其中的属性,或者通过"对象名.方法名()"来调用其中的方法,除此之外,python提供了一个__call__函数,这个函数允许对象调用自身,请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A(object):
					    def __init__(self,name="qingsword"):
					        self.name=name
					    def __call__(self):
					        print("My name is %s"%self.name)

					x=A()
					#直接调用对象自身,就相当于执行了对象内的__call__函数,就好像x本身是一个函数而不是类对象一样
					x()  #输出"My name is qingsword"

					#我们可以通过callable()函数来判断一个对象是否可调用,这个函数返回一个布尔值,如果我们注释掉A类中的call函数,那么下面的第一句就会返回False,大家可以尝试一下
					print(callable(x))  #True
					print(callable(str))  #True
					print(callable([1,2,3]))  #False
					

0×11.枚举类

Python3.0之后,提供了一个枚举类型,弥补了Python2没有枚举的不足,首先来看一个简单的枚举实例:

					#!/usr/bin/env python
					#coding=utf-8
					#导入枚举模块
					from enum import Enum
					
					#定义一个枚举变量m
					m = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
					
					#使用不同的方法获取枚举中的名称和值,和列表不同,枚举的索引是从1开始的
					print(m(1))  #Month.Jan
					print(m.Mar)  #Month.Mar
					print(m["Oct"])  #Month.Oct
					print(m.Mar.value)  #3

					#打印出枚举中所有的名称
					x=len(m.__members__) #获得枚举个数
					for i in range(1,x+1):
					    print(m(i))

					#程序输出
					Month.Jan
					Month.Feb
					Month.Mar
					Month.Apr
					Month.May
					Month.Jun
					Month.Jul
					Month.Aug
					Month.Sep
					Month.Oct
					Month.Nov
					Month.Dec

					#获取枚举成员名称和全名,m.__members__.items()会将枚举分割成一个列表,每个元素都为一个元组,每个元组中又包含一个字符串和一个字典类型,分割后的列表大概是这个样子[("Jan",<Month.Jan:1>),("Feb",<Month.Feb:2>)....],然后使用name接收第一个参数(Jan),member接收第二个参数(<Month.Jan:1>),member可以访问键,用member.value可以访问值
					for name, member in m.__members__.items():
					    print(name,'=>',member,',',member.value)

					#程序输出
					Jan => Month.Jan , 1
					Feb => Month.Feb , 2
					Mar => Month.Mar , 3
					Apr => Month.Apr , 4
					May => Month.May , 5
					Jun => Month.Jun , 6
					Jul => Month.Jul , 7
					Aug => Month.Aug , 8
					Sep => Month.Sep , 9
					Oct => Month.Oct , 10
					Nov => Month.Nov , 11
					Dec => Month.Dec , 12
					

了解了枚举的创建和访问方法后,再来看看枚举类的创建方法:

					#!/usr/bin/env python
					#coding=utf-8
					from enum import Enum,unique
					@unique  #unique装饰器可以确保枚举中没有重复值
					class Week(Enum):
					    """继承枚举类,可以指定每个名称的值"""
					    Sun=0 #将起始索引设定成0
					    Mon=1
					    Tue=2
					    Wed=3
					    Thu=4
					    Fri=5
					    Sat=6
					
					#访问方法同枚举
					print(Week(0))
					print(Week.Sat.value)
					print(Week["Thu"])

					#程序输出
					Week.Sun
					6
					Week.Thu
					

在Python3中,枚举类经常用于定义常量,因为枚举中每个名称对应的值是不可变的,例如:

					#!/usr/bin/env python
					#coding=utf-8
					from enum import Enum,unique
					@unique
					class const(Enum):
					    """常量枚举类"""
					    website="www.qingsword.com"
					    author="qingsword"
					    pi=3.1415

					print(const.website.value)
					print(const("qingsword"))
					print(const["pi"].value)

					#程序输出
					www.qingsword.com
					const.author
					3.1415
					

0×12.动态类

动态语言和静态语言在创建类的时候也有所不同,动态语言类的创建是在程序执行后才依次执行类中的语句,动态化创建一个类,而静态语言是在编译时就已经创建了这些类;我们在使用type判断一个类的类型时,往往看到类的类型是type,这又与动态类的创建有什么关系呢?请看下面的实例:

					#!/usr/bin/env python
					#coding=utf-8
					########
					class A(object):
					    def Website(self):
					        print("www.qingsword.com")

					x=A()
					print(type(A))
					print(type(x))

					#程序输出,从输出中可以看到,x是A类的一个实例,但A类本身却是一个class type
					<class 'type'>
					<class '__main__.A'>
					

实际上type方法不仅可以判断对象的类型,python还可以使用它来动态创建类,而使用type动态创建的类与直接使用class创建的类效果是一样的,这就是为什么上面type判断A类的类型是class type的原因,实际上两者可以看做同一种类型,下面的实例演示了如何通过type动态创建一个类:

					#!/usr/bin/env python
					#coding=utf-8
					def Website(self):
					    print("www.qingsword.com")
					def SayHello(self,name="qingsword"):
					    print("Hello %s"%name)
					#B指向一个Type动态创建的类,所以B就代表这个类(A)本身
					#type的语法:
					#type("类名",(继承类列表,...),dict(类方法名=绑定的方法名,...))
					#使用这种方法我们就可以动态的将外部的方法绑定到一个类中,从而在运行时创建一个类
					B=type("A",(object,),dict(web=Website,hello=SayHello))
					x=B()
					print(x)
					print(type(B))
					x.web()
					x.hello("xxx")

					#程序输出
					<__main__.A object at 0x7f7d70821048>
					<class 'type'>
					www.qingsword.com
					Hello xxx