python核心编程2 第十三章 练习

13-3.对类进行定制。写一个类，用来将浮点型值转换为金额。

 class MoneyFmt(object):

     def __init__(self, value=0.0, flag='-'):

         self.value = float(value)
         self.flag = flag

     def dollarize(self):
         """转换"""
         val = round(self.value, 2)
         strvalue = str(val)
         if strvalue.startswith('-'):
             strvalue = strvalue[1:]
             len = strvalue.find('.')
             while (len-3) > 0:
                 strvalue = strvalue[:len-3] + ',' + strvalue[len-3:]
                 len -= 3
             return self.flag + '$' + strvalue

         len = strvalue.find('.')
         while (len-3) > 0:
             strvalue = strvalue[:len-3] + ',' + strvalue[len-3:]
             len -= 3
         return '$' + strvalue

     def update(self, newvalue=None):
         """更新"""
         if newvalue is not None:
             self.value = float(newvalue)

     def __nonzero__(self):
         "非零"
         if self.value == 0:
             return False
         return True

     def __str__(self):
         return self.dollarize()

     def __repr__(self):
         return repr(self.value)

13-4.用户注册。

建立一个用户数据库类，来管理一个系统，该系统要求用户在登录后才能访问某些资源。这个数据库类对用户进行管理，并在实例化操作时加载之前保存的用户信息，提供访问函数来添加或更新数据库的信息。在数据修改后，数据库会在垃圾回收时将新信息保存到磁盘。

 from datetime import datetime
 import shelve

 class Userdatabase(object):

     def __init__(self, dbfile):
         """创建数据库"""
         self.dbfile = dbfile
         self.db = shelve.open(self.dbfile, 'c')
         self.db.close()

     def newuser(self, user, pwd):
         """注册"""
         self.db = shelve.open(self.dbfile, 'r')
         if user in self.db:
             print("User already exists")
         self.db = shelve.open(self.dbfile, 'c')
         self.db[user] = [user, pwd, datetime.now()]
         self.db.close()
         self.flag = False

     def login(self, user, pwd):
         """登录"""
         self.db = shelve.open(self.dbfile, 'r')
         if user not in self.db:
             self.flag = False
         elif self.db[user][1] == pwd:
             self.flag = True
         self.db.close()

     def deluser(self, user):
         """删除"""
         self.db = {}
         if self.flag:
             self.db = shelve.open(self.dbfile, 'r')
             if user in self.db:
                 self.db.pop(user)
         else:
             print('login first')

     def updateuser(self, user, pwd):
         """更新"""
         if self.flag:
             self.db = shelve.open(self.dbfile, 'c')
             self.db[user] = [user, pwd, datetime.now()]
             self.db[user] = self.db[user]
         else:
             print('login first')

     def listall(self):
         """查看"""
         if self.flag:
             for user in self.db:
                 print(self.db[user][0], self.db[user][1])
         else:
             print('login first')

 if __name__ == '__main__':
     user = Userdatabase('shelve.data')
     user.newuser('admin', '')
     user.login('admin', '')
     user.updateuser('admin', '')
     user.updateuser('test', '')
     user.listall()
     user.deluser('test')
     user.listall()

13-5.几何。创建一个由有序数值对(x,y)组成的Point类，代表某个点的X和Y坐标。

 class Point(object):

     def __init__(self, x=0, y=0):
         self.x = x
         self.y = y

     def __str__(self):
         return '(%d, %d)' % (self.x, self.y)

 if __name__ == '__main__':
     p = Point(1, 1)
     print(p)

13-6.几何。创建一个直线类，除主要属性：一对坐标值外，它还具有长度和斜线属性。你需要覆盖__repr__()方法，使得代表那条直线的字符串表示形式是由一对元组构成的元组。

 from math import sqrt

 class Beeline(object):

     def __init__(self, x1=0, y1=0, x2=0, y2=2):
         self.x1 = x1
         self.y1 = y1
         self.x2 = x2
         self.y2 = y2
         self.length = 0
         self.slope = None

     def getLength(self):
         """长度"""
         if self.x1 == self.x2 and self.y1 == self.y2:
             self.length = 0
         elif self.x1 == self.x2:
             self.length = abs(self.y2 - self.y1)
         elif self.y1 == self.y2:
             self.length = abs(self.x2 - self.x1)
         else:
             self.length = sqrt((self.y2 - self.y1)**2 + (self.x2 - self.x1)**2)
         return self.length

     def getSlope(self):
         """斜率"""
         if self.length == 0:
             self.slope = None
         elif self.x1 == self.x2 or self.y1 == self.y2:
             self.slope = None
         else:
             self.slope = float(self.y2 - self.y1) / (self.x2 - self.x1)
         return self.slope

     def __str__(self):
         return '((%d, %d),(%d, %d))' % (self.x1, self.y1, self.x2, self.y2)

     __repr__ = __str__

 if __name__ == '__main__':
     b = Beeline(1, 2, 3, 4)
     print(b)
     print('Length is %f' % b.getLength())
     print('Slope is %s' % b.getSlope())

13-7.数据类。提供一个time模块的接口，允许用户按照自己给定的时间格式来查看日期。你的类应该维护一个日期值，并用给定的时间创建一个实例，如果没有给出时间值，程序执行时会默认采用当前的系统时间。

 import time

 class TimeFormat(object):

     def __init__(self, t=time.time()):
         self.mytime = t

     def update(self, t=time.time()):
         self.mytime = t

     def display(self, ft=None):
         fmt = {}
         fmt['MDY'] = '%m/%d/%y'
         fmt['MDYY'] = '%m/%d/%Y'
         fmt['DMY'] = '%d/%m/%y'
         fmt['DMYY'] = '%d/%m/%Y'
         fmt['MODYY'] = '%b %d,%Y'
         if ft in fmt:
             return (time.strftime(fmt[ft], time.localtime(self.mytime)))
         return time.ctime(self.mytime)

 if __name__ == '__main__':
     tf = TimeFormat()
     print(tf.display())
     print(tf.display('MDY'))
     print(tf.display('MDYY'))
     print(tf.display('DMY'))
     print(tf.display('DMYY'))
     print(tf.display('MODYY'))
     tf.update(time.time() + 60)
     print(tf.display())

13-8.堆栈类。

实现一个堆栈类，类中应该有push()和pop()方法，还有一个isempty()方法，如果堆栈是空的，返回布尔值1，否则返回0。

 class Stack(object):

     def __init__(self, l=[]):
         self.l = l

     def isempty(self):
         if len(self.l) == 0:
             return 1
         return 0

     def push(self, element):
         print('pushed [', element, ']')
         self.l.append(element)

     def peek(self):
         if self.isempty():
             print('can not peek from an empty stack')
         return self.l[0]

     def pop(self):
         if self.isempty():
             print('can not pop from an empty stack')
         else:
             print('removed [', self.l.pop(), ']')

     def viewstack(self):
         print(self.l)

 if __name__ == '__main__':
     s = Stack()
     s.viewstack()
     s.pop()
     s.viewstack()
     s.push(2)
     s.viewstack()

13-9.队列类。实现一个队列类，这个类必须支持下面几种方法：enqueue()在队列的尾部加入一个新的元素，dequeue()在队列的头部取出一个元素，返回它并且把它从列表中删除。

 class Queue(object):

     def __init__(self, l=[]):
         self.l = l

     def enqueue(self, element):
         print('enter queue [', element, ']')
         self.l.append(element)

     def dequeue(self):
         if self.l:
             print('removed [', self.l.pop(0), ']')
         else:
             print('can not pop from an empty stack')

     def viewstack(self):
         print(self.l)

 if __name__ == '__main__':
     q = Queue([1, 2, 3])
     q.viewstack()
     q.enqueue(4)
     q.dequeue()
     q.viewstack()

13-10.堆栈和队列。编写一个类，定义一个能够同时具有堆栈和队列操作行为的数据结构。这个类和Perl语言中数组相像。需要实现四个方法。

 class FifoLifo(object):

     def __init__(self, l=[]):
         self.l = l

     def shift(self):
         """删除头"""
         if self.l:
             print('removed [', self.l.pop(0), ']')
         else:
             print('can not pop from an empty stack')

     def unshift(self, element):
         """插入头"""
         print('inserted [', element, ']')
         self.l.insert(0, element)

     def push(self, element):
         """插入尾"""
         print('pushed [', element, ']')
         self.l.append(element)

     def pop(self):
         """删除尾"""
         if self.l:
             print('removed [', self.l.pop(), ']')
         else:
             print('can not pop from an empty stack')

     def viewstack(self):
         print(self.l)

 if __name__ == '__main__':
     f = FifoLifo([1, 2, 3, 4, 5])
     f.viewstack()
     f.shift()
     f.unshift(6)
     f.push(0)
     f.pop()
     f.viewstack()

13-11.电子商务。

你需要为一家B2C零售商编写一个基础的电子商务引擎。你需要写一个针对顾客的类User，一个对应存货清单的类Item，还有一个对应购物车的类叫Cart。货物放到购物车里，顾客可以有多个购物车。同时购物车里可以有多个货物，包括多个同样的货物。

 class Item(object):
     """物品价格清单"""
     def __init__(self, product, price):
         self.product = product
         self.price = price

     def __str__(self):
         return '(%s, %.2f)' % (self.product, self.price)

 class Cart(object):
     """购物车"""
     def __init__(self, cartname):
         self.cartname = cartname
         self.cartlist = {}

     def appenditem(self, item, count=1):
         """增加数量"""
         if item not in self.cartlist:
             self.cartlist[item] = count
         else:
             self.cartlist[item] += count

     def showcart(self):
         """查看"""
         for i in self.cartlist:
             print(self.cartname, i, self.cartlist[i])

     def deleteitem(self, item, count=1):
         """减少数量"""
         if item in self.cartlist and self.cartlist[item]>=count:
             self.cartlist[item] -= count
         if self.cartlist[item] == 0:
             self.cartlist.pop(item)

 class User(object):
     """顾客"""
     def __init__(self, name):
         self.name = name
         self.userdb = []

     def appendcart(self, cart):
         self.userdb.append(cart.cartname)

     def showuser(self):
         print(self.name, self.userdb)

 if __name__ == '__main__':
     i1 = Item('huawei', 15000)
     i2 = Item('iphone', 7000)
     print(i1, i2)
     c1 = Cart('cart1')
     c2 = Cart('cart2')
     c3 = Cart('cart3')
     c1.appenditem(i1, 1)
     c1.appenditem(i2, 1)
     c2.appenditem(i2, 2)
     c3.appenditem(i1, 2)
     c1.showcart()
     c2.showcart()
     c3.showcart()
     u1 = User('Tom')
     u2 = User('Jerry')
     u1.appendcart(c1)
     u2.appendcart(c2)
     u2.appendcart(c3)
     u1.showuser()
     u2.showuser()

13-12.聊天室。

你需要三个类：一个Message类，它包含一个消息字符串以及诸如广播、单方收件人等其他信息。一个User类，包含了进入你聊天室的某个人的所有信息。一个Room类，它体现了一个更加复杂的聊天系统，用户可以在聊天时创建单独的房间，并邀请其他人加入。

 class Message(object):

     def __init__(self, msg='', broadcast=False, froms='', to=''):

         self.msg = msg
         self.broadcast = broadcast
         self.froms = froms
         self.to = to

     def __str__(self):
         """广播"""
         if self.broadcast:
             return 'message: %s from %s send to everyone' % (self.msg, self.froms)
         else:
             return 'message: %s from %s send to %s' % (self.msg, self.froms, self.to)

 class User(object):

     hear = {'everyone': ''}

     def __init__(self, name, sex, age):

         self.name = name
         self.sex = sex
         self.age = age

     def __del__(self):

         User.hear.clear()

     def __str__(self):

         return 'user:%s ,sex:%s ,age:%d' % (self.name, self.sex, self.age)

     def talk(self, to='', msg=''):
         """发送广播"""
         if to == 'everyone':
             m = Message(msg, True, self.name)
             User.hear['everyone'] = m
         elif to:
             m = Message(msg, False, self.name, to)
             User.hear[to] = m
         else:
             print('receiver can not be empty')

     def hearmsg(self):
         """显示消息"""
         if self.name in User.hear:
             print(User.hear[self.name])
         elif User.hear['everyone']:
             print(User.hear['everyone'])
         else:
             print('no msg for %s' % self.name)

     def talkroom(self, room, to='', msg=''):
         """room广播"""
         if to == 'everyone':
             m = Message(msg, True, self.name)
             room.receive(m)
         elif to:
             m = Message(msg, False, self.name, to)
             room.receive(m)
         else:
             print('receiver can not be empty')

     def hearroom(self, m):
         """显示room消息"""
         print('room %s' % m)

     def createroom(self, name, count=3):
         """room人员"""
         return Room(name, count)

 class Room(object):

     def __init__(self, rname, count=3):

         self.rname = rname
         self.count = count
         self.userlist = []

     def adduser(self, user):
         """room用户邀请"""
         if len(self.userlist) <= self.count:
             self.userlist.append(user)
         else:
             print('user number limits')

     def receive(self, m):
         """room广播"""
         if m.broadcast:
             print('room %s' % m)
         else:
             for user in self.userlist:
                 if user.name == m.to:
                     user.hearroom(m)

 if __name__ == '__main__':
     u1 = User('bob', 'male', 33)
     u2 = User('jim', 'female', 31)
     u3 = User('Tom', 'female', 31)
     u1.talk('jim', 'hello')
     u2.hearmsg()
     u3.hearmsg()
     room1 = u2.createroom('girls', 2)
     room1.adduser(u2)
     room1.adduser(u3)
     u2.talkroom(room1, 'Tom', 'hello')
     u3.talkroom(room1, 'everyone', 'hello')

13-13. 股票投资组合类。你的数据库中记录了每个公司的名字、股票代码、购买日期、购买价格和持股数量。需要编写的方法包括：添加新代号、删除代号、根据当前价格计算出的YTD或年回报率。

 class Stock(object):

     def __init__(self, name, code, date, price, amount):

         self.name = name
         self.code = code
         self.date = date
         self.price = price
         self.amount = amount

     def __str__(self):
         return '%s %s %s %.2f %d' % (self.name, self.code, self.date, self.price, self.amount)

 class Operator(object):

     def __init__(self):

         self.db = {}

     def newcode(self, stock):

         self.db.setdefault(stock.code, [stock.name, stock.date, stock.price, stock.amount])

     def popcode(self, code):

         self.db.pop(code)

     def years(self, year):

         if (year % 4 == 0 and year % 100 != 0) or (year % 4 == 0 and year % 400 == 0):
             return True

     def months(self, str1, str2):

         month1 = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
         month2 = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
         bdate = str1.split('/')
         bdate[0], bdate[1], bdate[2] = int(bdate[0]), int(bdate[1]), int(bdate[2])
         edate = str2.split('/')
         edate[0], edate[1], edate[2] = int(edate[0]), int(edate[1]), int(edate[2])

         if bdate == edate:
             return 0

         elif bdate[1] == edate[1] and bdate[2] == bdate[2]:
             return abs(bdate[0]-edate[0])

         elif bdate[1] != edate[1] and bdate[2] == edate[2]:
             bdays = 0
             edays = 0
             if self.years(bdate[2]):
                 for i in range(1, bdate[1]):
                     bdays += month2[i]
                 bdays = bdays + bdate[0]
                 for i in range(1, edate[1]):
                     edays += month2[i]
                 edays = edays + edate[0]
                 return abs(edays - bdays)
             else:
                 for i in range(1, bdate[1]):
                     bdays += month1[i]
                 bdays = bdays + bdate[0]
                 for i in range(1, edate[1]):
                     edays += month1[i]
                 edays = edays + edate[0]
                 return abs(edays - bdays)

         elif bdate[2] != edate[2]:
             days = 0
             for i in range(bdate[2]+1, edate[2]):
                 if self.years(i):
                     days += 366
                 else:
                     days += 365
             if self.years(bdate[2]):
                 for i in range(bdate[1]+1, 13):
                     days += month2[i]
                 days += (month2[bdate[1]]-bdate[0])
             else:
                 for i in range(bdate[1]+1, 13):
                     days += month1[i]
                 days += (month1[bdate[1] - bdate[0]])
             if self.years(edate[2]):
                 for i in range(1, edate[1]):
                     days += month2[i]
                 days += edate[0]
                 return days
             else:
                 for i in range(1, edate[1]):
                     days += month1[i]
                 days += edate[0]
                 return days

     def YTD(self, stock, newprice, newdate):

         holddays = self.months(stock.date, newdate)
         costmoney = stock.price * stock.amount
         curmoney = newprice * stock.amount
         benifit = curmoney - costmoney

         if stock.code in self.db:
             print('YTD of %s is %.2f %%' %(stock.code, benifit/holddays*365/costmoney))
         else:
             print('Stock %s does not exists' % stock.code)

     def showdb(self):
         print(self.db)

 s1 = Stock('xx', '', '01/01/2019', 1.0, 1000)
 s2 = Stock('yy', '', '05/01/2019', 18.0, 1000)
 op1 = Operator()
 op1.newcode(s1)
 op1.newcode(s2)
 op1.showdb()
 op1.popcode('')
 op1.showdb()
 op1.YTD(s1, 1.01, '11/03/2019')

13-14.DOS。为DOS机器编写一个Unix操作界面的shell。你向用户提供一个命令行，使得用户可以在那里输入unix命令，你可以对这些命令进行解释，并把返回相应的输出。

 import os

 class Shell(object):

     def __init__(self):

         self.cmddict = {'ls': 'dir', 'more': 'more', 'cat': 'type', 'cp': 'copy', 'mv': 'ren', 'rm': 'del'}

     def translate(self, cmd):

         opt = cmd.split()
         if opt[0] in self.cmddict:
             opt[0] = self.cmddict[opt[0]]
         return ' '.join(opt)

     def start(self):

         while True:
             cmd = input('#')
             cmd = self.translate(cmd)
             if cmd == 'exit':
                 break

             output = os.popen(cmd).readlines()
             for out in output:
                 print(out)

 if __name__ == '__main__':
     s = Shell()
     s.start()

13-16.授权和函数编程。
(a)请为示例中的CanOpen类编写一个writelines()方法，这个新函数可以一次读入多行文本，然后将文本转化为大写的形式。
(b)在writelines()方法中添加一个参数，用这个参数来指明是否需要为每行文本加上一个换行符。此参数的默认值是False，表示不加换行符。

 import os

 class CapOpen(object):

     def __init__(self, fn, mode='r', buf=-1):

         self.file = open(fn, mode, buf)

     def __str__(self):

         return str(self.file)

     def __repr__(self):

         return 'self.file'

     def write(self, line):

         self.file.write(line.upper())

     def writelines(self, lines, enter=False):

         for line in lines:
             if enter:
                 line += os.linesep
             self.write(line)

     def __getattr__(self, attr):

         return getattr(self.file, attr)

 if __name__ == '__main__':
     f1 = CapOpen('test.txt')
     lines = f1.readlines()
     f1.close()

     f2 = CapOpen('newtest.txt', 'w')
     f2.writelines(lines, False)
     f2.close()

13-17. 数值类型子类化。在示例13.3中所看到的moneyfmt.py脚本基础上修改它，使得它可以扩展Python的浮点类型。请确保它支持所有操作，而且是不可变的。

 class MoneyFmt(float):

     def __new__(cls, value=0.0, flag='-'):

         cls.flag = flag
         cls.value = super(MoneyFmt, cls).__new__(cls, value)
         return cls.value

     def dollarize(cls):
         """转换"""
         val = round(cls.value, 2)
         strvalue = str(val)
         if strvalue.startswith('-'):
             strvalue = strvalue[1:]
             len = strvalue.find('.')
             while (len-3) > 0:
                 strvalue = strvalue[:len-3] + ',' + strvalue[len-3:]
                 len -= 3
             return cls.flag + '$' + strvalue

         len = strvalue.find('.')
         while (len-3) > 0:
             strvalue = strvalue[:len-3] + ',' + strvalue[len-3:]
             len -= 3
         return '$' + strvalue

     def __nonzero__(cls):
         "非零"
         if cls.value == 0:
             return False
         return True

     def __str__(cls):

         return cls.dollarize()

 if __name__ == '__main__':
     money = input('Money: ')
     moneyfmt = MoneyFmt(money)
     print(moneyfmt.dollarize())

13-18. 序列类型子类化。模仿前面练习13-4中的用户注册类的解决方案，编写一个子类。要求允许用户修改密码，但密码有效期是12个月，过期后不能重复使用。

 import time, shelve

 class Userdatabase(object):

     def __init__(self, dbfile):
         """创建数据库"""
         self.dbfile = dbfile
         self.db = shelve.open(self.dbfile, 'c')
         self.db.close()

     def newuser(self, user, pwd):
         """注册"""

         self.db = shelve.open(self.dbfile, 'r')
         if user in self.db:
             print("User already exists")
         self.db = shelve.open(self.dbfile, 'c')
         self.db[user] = [user, [pwd, time.time()], time.ctime()]
         self.db.close()
         self.flag = False

     def login(self, user, pwd):
         """登录"""
         self.db = shelve.open(self.dbfile, 'r')
         if user not in self.db:
             self.flag = False
         elif self.db[user][1][0] == pwd:
             if self.db[user][1][-1] - time.time() > 365*24*60*60:
                 print("Password has expired")
                 self.flag = False
             else:
                 self.flag = True
         self.db.close()

     def deluser(self, user):
         """删除"""
         self.db = {}
         if self.flag:
             self.db = shelve.open(self.dbfile, 'r')
             if user in self.db:
                 self.db.pop(user)
         else:
             print('login first')

     def updateuser(self, user, pwd):
         """更新密码"""
         newdb = {}
         if self.flag:
             self.db = shelve.open(self.dbfile, 'r')
             if pwd in self.db[user][1]:
                 print("The new password cannot be the same as the used password")
             else:
                 value = [user, self.db[user][1], time.ctime()]
                 value[1].insert(0, pwd)
                 value[1][-1] = time.time()
                 newdb[user] = value
                 self.db = shelve.open(self.dbfile, 'c')
                 self.db[user] = newdb[user]
                 print(self.db[user])
         else:
             print('login first')

     def listall(self):
         """查看"""
         if self.flag:
             for user in self.db:
                 print(self.db[user][0], self.db[user][1][0])
         else:
             print('login first')

 if __name__ == '__main__':
     user = Userdatabase('shelve.data')
     user.newuser('admin', '')
     user.newuser('test', '')
     user.login('admin', '')
     user.login('test', '')
     user.updateuser('admin', '')
     user.updateuser('test', '')
     user.listall()
     user.deluser('test')
     user.listall()

13-20.类的定制。改进脚本time60.py
(a)允许“空”实例化：如果小时和分钟的值没有给出，默认为0小时0分钟。
(b)用0占位组成两位数的形式，因为当前的时间格式不符合要求。
(c)除了用hours(hr)和minutes(min)进行初始化外，还支持以下时间输入格式：
一个由小时和分钟组成的元组，如(10,30)
一个由小时和分钟组成的字典，如{'hr':10, 'min':30}
一个代表小时和分钟的字符串，如"10:30"
(e)实现__repr__()。
(f)添加60进制的运算功能。

 class Time60(object):
     'Time60 - track hours and minutes'

     def __init__(self, *time):
         'Time60 constructor - takes hours and minutes'
         if len(time) == 1:
             if type(time[0]) == tuple:
                 self.hr = time[0][0]
                 self.min = time[0][1]
             elif type(time[0]) == dict:
                 self.hr = time[0]['hr']
                 self.min = time[0]['min']
             elif type(time[0]) == str:
                 all = time[0].split(':')
                 self.hr = int(all[0])
                 self.min = int(all[1])

         elif len(time) == 0:
             self.hr = 0
             self.min = 0

         else:
             self.hr = time[0]
             self.min = time[1]

     def __str__(self):
         'Time60 - string representation'
         return '%02d:%02d' % (self.hr, self.min)

     def __repr__(self):

         return repr('%02d:%02d' % (self.hr, self.min))

     def __add__(self, other):
         'Time60 - overloading the addition operator'
         hr = self.hr + other.hr
         min = self.min + other.min
         ahr = min // 60
         min %= 60
         hr += ahr
         if hr > 23: hr = 0
         return self.__class__(hr, min)

     def __iadd__(self, other):
         'Time60 - overloading in-place addition'
         self.hr += other.hr
         self.min += other.min
         return self

 print(Time60())
 print(Time60(10, 30))
 print(Time60("15:31"))
 print(Time60((10, 30)))
 print(Time60({'hr':11, 'min':15}))
 print(Time60(1, 5))
 print(Time60("15:31") + Time60(8,31))