python面对对象
类和实例：类是对象的定义，实例是真真的实物。
创建一个类：
class AddrBookEnttry(object):
def __init__(self, nm, ph):
self.name = nm
self.phone = ph
print"Created instance for:", self.name
def updatePhone(self, newph):
self.phont = newph
print "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 = nm
self.phone = ph
print"Created instance for:", self.name
def updatePhone(self, newph):
self.phont = newph
print "Update phone for:", self.name
class EmplAddrBookEntry(AddrBookEnttry):
def __init__(self, nm, ph, id, em):
AddrBookEnttry.__init__(self, nm, ph)
self.empid = id
self.email = em
def updateEmail(self, newem):
self.email = newem
print "Updated email address for:", self.name
john = 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 = 0
def __init__(self):
InstCt.count += 1
def __del__(self):
InstCt.count -= 1
def howMany(self):
print InstCt.count
return InstCt.count
a = 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():
@staticmethod
def foo():
print 'calling static method foo()'
class TestClassMethod:
@classmethod
def 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):
pass
class C2(P2, P1):
pass
class GC(C1, C2):
pass
test = 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 = hr
self.min = min
def __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.hr
self.min +=other.min
return self
mon = 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 = valus
def update (self, value=None):
if value:
self.dollarize(value)
def __str__(self):
return self.value
def __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 = []+sq
def shift(self):
str = self.sq[0]
self.sq.pop(0)
return str
def 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 str
def __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/60
self.min = self.min%60
def __str__(self):
return "%d-%d" % (self.hr, self.min)
def __add__(self, other):
hr = self.hr + other.hr
min = self.min + other.min
if min >= 60:
hr += min/60
min = min%60
return hr, min
def __iadd__(self, other):
self.hr += other.hr
self.min += other.min
if self.min >= 60:
self.hr += self.min/60
self.min = self.min%60
return self
s1 = 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 s1
24-17 33-50 6-22 43-27 54-46
(79, 3)
58-7