python 核心编程第十三章

python面对对象

类和实例：类是对象的定义，实例是真真的实物。

创建一个类：

class AddrBookEnttry(object):def __init__(self, nm, ph):self.name = nmself.phone = phprint"Created instance for:", self.namedef updatePhone(self, newph):self.phont = newphprint "Update phone for:", self.name
john = AddrBookEnttry("John", "408-34324")
jane = AddrBookEnttry("Jane Doe", "42345423-32")
john.updatePhone("1376478763")
print john.phone
print john.name

定义类后，创建实例，可以查看实例的属性，以及调用实例的方法进行操作属性

创建子类：

class AddrBookEnttry(object):def __init__(self, nm, ph):self.name = nmself.phone = phprint"Created instance for:", self.namedef updatePhone(self, newph):self.phont = newphprint "Update phone for:", self.name
class EmplAddrBookEntry(AddrBookEnttry):def __init__(self, nm, ph, id, em):AddrBookEnttry.__init__(self, nm, ph)self.empid = idself.email = emdef updateEmail(self, newem):self.email = newemprint "Updated email address for:", self.namejohn = EmplAddrBookEntry("john Doe", "408-555-1212", 42,"Jojn@qq.com")
print john, john.name, john.phone
john.updatePhone("1376478763")
john.updateEmail("Join@163.com")
print john.phone, john.email

Created instance for: john Doe
<main.EmplAddrBookEntry object at 0x027B14F0> john Doe 408-555-1212
Update phone for: john Doe
Updated email address for: john Doe
408-555-1212 Join@163.com

子类继承了父类的方法，但不会继承构造器，需要显示的调用还需要传入self参数。

特殊类属性

对于类C
C.__name__ 类Ｃ的名字（字符串）
C.__doc__ 类Ｃ的文档字符串
C.__bases__ 类Ｃ的所有父类构成的元组
C.__dict__ 类Ｃ的属性
C.__module__ 类Ｃ定义所在的模块（1.5 版本新增）
C.__class__ 实例Ｃ对应的类（仅新式类中）

del()解构器方法：这个函数要直到该实例对象所有的引用都被清除掉后才会执行。

class C(object):def __init__(self):print"initialized"def __del__(self):print"deleted"
c1 = C()
c2 = c1
del c2
del c1
raw_input()

当清楚c1实例的全部引用后，就会执行__del__(),加上raw的原因是，程序运行结束会自动回收实例。
核心笔记：跟踪实例
Python 没有提供任何内部机制来跟踪一个类有多少个实例被创建了，或者记录这些实例是些什
么东西。如果需要这些功能，你可以显式加入一些代码到类定义或者__init__()和__del__()中去。
核心笔记：跟踪实例
Python 没有提供任何内部机制来跟踪一个类有多少个实例被创建了，或者记录这些实例是些什
么东西。如果需要这些功能，你可以显式加入一些代码到类定义或者__init__()和__del__()中去。
最好的方式是使用一个静态成员来记录实例的个数。靠保存它们的引用来跟踪实例对象是很危险的，
因为你必须合理管理这些引用，不然，你的引用可能没办法释放（因为还有其它的引用）！例子：

class InstCt(object):count = 0def __init__(self):InstCt.count += 1def __del__(self):InstCt.count -= 1def howMany(self):print InstCt.countreturn InstCt.counta = InstCt()
b = InstCt()
b.howMany()
a.howMany()
del b
a.howMany()
del a
print InstCt.count

2
2
1
0

类的静态方法和类方法

经典类创建静态方法和类方法：

class TestStaticMethod():def foo():print 'calling static method foo()'foo = staticmethod(foo)
class TestClassMethod:def foo(cls):print 'calling class method foo()'print 'foo() is part of class:', cls.__name__foo = classmethod(foo)
TestClassMethod.foo()

使用staticmethod()和classmethed()函数创建。

来看看另一种创建的方法（使用装饰器）：

class TestStaticMethod():@staticmethoddef foo():print 'calling static method foo()'
class TestClassMethod:@classmethoddef foo(cls):print 'calling class method foo()'print 'foo() is part of class:', cls.__name__
TestClassMethod.foo()
TestStaticMethod.foo()

类的继承覆盖方法：

class P(object):def foo(self):print "Hi, I am P-foo"class C(P):def foo(self):super(C, self).foo()print "Hi I am C-foo"c = C()
c.foo()

Hi, I am P-foo
Hi I am C-foo

这里子类C覆盖了基类的方法，但是使用super()可以调用已经被覆盖的基类的方法。

从标准类型派生

class RoundFloat(float):def __new__(cls, val):return super(RoundFloat, cls).__new__(cls, round(val, 2))
print RoundFloat(2.3333)

这里使用super()函数捕获对应的基类，并且调用__new__()

另一个例子，一个新的字典类型，他的keys()方法会自动排序结果

class SortedKey(dict):def keys(self):return sorted(super(SortedKey, self).keys())d = SortedKey((('zheng-cai', 67), ('hui-jun', 68),('xin-yi', 2)))
print 'By iterator:'.ljust(12), [key for key in d]
print 'By keys():'.ljust(24), d.keys()

多重继承

class P1(object):def foo(self):print"called P1-foo()"class P2(object):def foo(self):print"called P2-foo()"def bar(self):print"called P2-bar()"class C1(P1, P2):passclass C2(P2, P1):passclass GC(C1, C2):passtest = GC()
test.foo()

TypeError: Error when calling the metaclass bases
Cannot create a consistent method resolution
order (MRO) for bases P2, P1
产生了一个所谓的菱形效应，mrojiu错误了

这里有些看不太懂，不过如果删除object使用以前的继承方式就不会出现这个问题，还是想不通╮(╯▽╰)╭。

内建函数

表 13.3 类，实例及其它对象的内建函数
内建函数描述

issubclass(sub, sup) 如果类 sub 是类 sup 的子类，则返回 True，反之，为 False。
isinstance(obj1, obj2) 如果实例obj1是类obj2或者obj2子类的一个实例；或者如果obj1
是 obj2 的类型，则返回 True；反之，为 False。
hasattr(obj, attr) 如果 obj 有属性 attr（用字符串给出），返回 True，反之，返回
表 13.3 类，实例及其它对象的内建函数（续）
内建函数描述
getattr(obj, attr[, default]) 获取 obj 的 attr 属性；与返回 obj.attr 类似；如果 attr
不是 obj 的属性，如果提供了默认值，则返回默认值；不然，
就会引发一个 AttributeError 异常。
setattr(obj, attr, val) 设置obj的 attr 属性值为 val，替换任何已存在的属性值；
不然，就创建属性；类似于 obj.attr=val
delattr(obj, attr) 从 obj 中删除属性 attr（以字符串给出）；类似于 del
obj.attr。
dir(obj=None) 返回 obj 的属性的一个列表；如果没有给定 obj，dir()则
显示局部名字空间空间中的属性，也就是 locals().keys()
super(type, obj=None)
a
返回一个表示父类类型的代理对象；如果没有传入 obj，
则返回的 super 对象是非绑定的；反之，如果 obj 是一个
type ， issubclass(obj,type) 必为 True ；否则，
isinstance(obj,type)就必为 True。
vars(obj=None) 返回 obj 的属性及其值的一个字典；如果没有给出 obj，
vars()显示局部名字空间字典（属性及其值），也就是
locals()。

用特殊方法定制类

特殊方法描述
基本定制型

C.__init__(self[, arg1, ...]) 构造器（带一些可选的参数）
C.__new__(self[, arg1, ...])
a
构造器（带一些可选的参数）；通常用在设置不变数据类
型的子类。
C.__del__(self) 解构器
C.__str__(self) 可打印的字符输出；内建 str()及 print 语句
C.__repr__(self) 运行时的字符串输出；内建 repr() 和‘ ‘ 操作符
C.__unicode__(self)
b
Unicode 字符串输出；内建 unicode()
C.__call__(self, *args) 表示可调用的实例
C.__nonzero__(self) 为 object 定义 False 值；内建 bool() （从 2.2 版开始）
C.__len__(self) “长度” （可用于类）；内建 len()
一个修改默认输出的例子：

class RoundFloat(object):def __init__(self, val):self.value = round(val, 2)def __str__(self):return str(self.value)rfm = RoundFloat(4.5353535)
print rfm

4.54

__str()__方法,覆盖了默认的行为。

数值定制的例子

class Time60(object):def __init__(self, hr, min):self.hr = hrself.min = mindef __str__(self):return "%d:%d" % (self.hr, self.min)__repr__ = __str__def __add__(self, other):return self.__class__(self.hr + other.hr, self.min +other.min)def __iadd__(self, other):self.hr += other.hrself.min +=other.minreturn selfmon = Time60(10, 30)
tue = Time60(11, 15)
print mon + tue
mon += tue
print mon

21:45
21:45

这个例子我们重新定义了 + 和+=的方法，使它支持更有趣的操作。

练习

13-3. 对类进行定制。写一个类，用来将浮点数值转换为金额。
基本任务: 编写一个 dollarize()函数，它以一个浮点数值作为输入，返回一个字符串形式的金额数。

class MoneyFmt(object):def __init__(self, value=0.0):self.dollarize(value)def dollarize(self, valus):val = "$"valus = round(valus, 2)valus = str(valus)if valus[0] == "-":val = "-$"valus = valus[1:]strmoney = valus.split(".")valus = ""if (len(strmoney[0])) % 3:strHead = strmoney[0][0:(len(strmoney[0])) % 3]else:strHead = strmoney[0][0, 3]for i in range(0, (len(strmoney[0]) + 1) / 3 - 1):valus += "," + strmoney[0][len(strHead) + i * 3:len(strHead) + i * 3 + 3]valus = val + strHead + valus + "." + strmoney[1]self.value = valusdef update (self, value=None):if value:self.dollarize(value)def __str__(self):return self.valuedef __nonzero__(self):return int(self.value)def __repr__(self):return self.value
text = MoneyFmt(-11333311111.22)
print text-$11,333,311,111.2

13-7. 数据类。提供一个 time 模块的接口，允许用户按照自己给定时间的格式，比如:
“MM/DD/YY,” “MM/DD/YYYY,” “DD/MM/YY,” “DD/MM/ YYYY,” “Mon DD, YYYY,” 或是标准
的 Unix 日期格式： “Day Mon DD, HH:MM:SS YYYY” 来查看日期。你的类应该维护一个日期值，并
用给定的时间创建一个实例。如果没有给出时间值，程序执行时会默认采用当前的系统时间。还包
括另外一些方法：
update() 按给定时间或是默认的当前系统时间修改数据值
display() 以代表时间格式的字符串做参数，并按照给定时间的格式显示:
'MDY' ==> MM/DD/YY
'MDYY' ==> MM/DD/YYYY
'DMY' ==> DD/MM/YY
'DMYY' ==> DD/MM/YYYY
'MODYY' ==> Mon DD, YYYY

import datetime
class myTime(object):def __init__(self, year=2016, month=11, day=1, hour=0, minute=0, second=0 ):self.datas = {"MDY": "%M-%d-%y", "MDYY": "%M-%d-%Y", "DMY": "%d-%M-%y", "DMYY": "%d-%M-%Y", "MODYY": "%m-%d-%y"}if minute and second and hour:self.dt = datetime.datetime.now()else:self.dt = datetime.datetime(year, month, day, hour, minute, second)def update(self, year=2016, month=11, day=0, hour=0, minute=0, second=0 ):self.dt = datetime.datetime(year, month, day, hour, minute, second)def display(self,data=None):try:strtemp = self.datas[data]print self.dt.strftime((strtemp))except:print self.dt.ctime()text = myTime()
text.update(2016, 1, 1, 1, 1, 1)
text.display()Fri Jan  1 01:01:01 2016

13-10. 堆栈和队列。编写一个类，定义一个能够同时具有堆栈(FIFO)和队列(LIFO)操作行为
的数据结构。这个类和 Perl 语言中数组相像。需要实现四个方法：
shift() 返回并删除列表中的第一个元素，类似于前面的 dequeue()函数。
unshift() 在列表的头部"压入"一个新元素
push() 在列表的尾部加上一个新元素，类似于前面的 enqueue()和 push()方法。
pop() 返回并删除列表中的最后一个元素，与前面的 pop()方法完全一样。

class StackQueue(object):def __init__(self, sq=[]):self.sq = []+sqdef shift(self):str = self.sq[0]self.sq.pop(0)return strdef unshift(self,x):self.sq.insert(0, x)def push(self, x):self.sq.append(x)def pop(self):str = self.sq[-1]self.sq.pop()return strdef __str__(self):return str(self.sq)

13-20. 类的定制。改进脚本time60.py，见13.13.2 节，示例13.3.

(a) 允许“空”实例化: 如果小时和分钟的值没有给出，默认为零小时、零分钟。

(b) 用零占位组成两位数的表示形式,因为当前的时间格式不符合要求。如下面的示例，wed
应该输出为“12:05.”
(c)除了用hours (hr) 和minutes (min)进行初始化外，还支持以下时间输入格式：
一个由小时和分钟组成的元组(10, 30)
一个由小时和分钟组成的字典({'hr': 10, 'min': 30})
一个代表小时和分钟的字符串("10:30")
附加题: 允许不恰当的时间字符串表示形式，如 “12:5”.

(d) 我们是否需要实现__radd__()方法? 为什么? 如果不必实现此方法，那我们什么时候可
以或应该覆盖它?

(e) repr()函数的实现是有缺陷而且被误导的。我们只是重载了此函数，这样我们可以省
去使用print 语句的麻烦，使它在解释器中很好的显示出来。但是，这个违背了一个原则:对于可估
值的Python 表达式，repr()总是应该给出一个(有效的)字符串表示形式。12:05 本身不是一个合法
的Python 表达式，但Time60('12:05')是合法的。请实现它。

(f) 添加六十进制(基数是60)的运算功能。下面示例中的输出应该是19:15，而不是18:75:

class Time60(object):def __init__(self,  *args, **kwargs):if len(args) == 0:args = (None,None)if type(args[0]) is str:self.hr, self.min = args[0].split(":")elif type(args[0]) is tuple:self.hr, self.min = args[0]elif type(args[0]) is dict:self.hr = args[0]["hr"]self.min = args[0]["min"]elif type(args[0]) is int and type(args[1]) is int:self.hr = args[0]self.min = args[1]elif len(kwargs) == 2:self.hr = kwargs["hr"]self.min = kwargs["min"]else:self.hr, self.min = (0, 0)self.hr = int(self.hr)self.min = int(self.min)if self.min >= 60:self.hr += self.min/60self.min = self.min%60def __str__(self):return "%d-%d" % (self.hr, self.min)def __add__(self, other):hr = self.hr + other.hrmin = self.min + other.minif min >= 60:hr += min/60min = min%60return hr, mindef __iadd__(self, other):self.hr += other.hrself.min += other.minif self.min >= 60:self.hr += self.min/60self.min = self.min%60return selfs1 = Time60(hr=23, min=77)
s2 = Time60(33, 50)
s3 = Time60("6:22")
s4 = Time60({"hr": 43, "min": 27})
s5 = Time60((54, 46))
print s1, s2, s3, s4, s5
print s1 + s5
s1+=s2
print s124-17 33-50 6-22 43-27 54-46
(79, 3)
58-7

转载于:https://www.cnblogs.com/jikeboy/p/6021480.html