核心编程第十三章（下）

13-12

# -*- coding: utf-8 -*-
# 
# 
# 每个新建用户都会自动绑定到原始房间'origin'，以及配套的信息收发器'origin'。
# 信息收发器的绑定列表bindlist添加此用户实例，用于广播时通知消息。
# 用户信箱mymsg用于储存用户接收的信息。
# 用户只能给同一房间的其他用户发送消息及广播消息。


class Room(object):

    def __init__(self, roomname, creater=None, pwd=None):
        self.roomname = roomname
        self.creater = creater
        self.pwd = pwd

    def get_in(self, usr):
        if usr.mypwd[self.roomname] == self.pwd:
            usr.messager.unbindusr(usr)
            usr.messager = self.creater.messager
            usr.messager.bindusr(usr)
        else:
            return "You haven't agree to get in yet"

    @staticmethod
    def get_out(usr):
        if usr.messager.roomname == 'origin':
            return 'you are in origin room now'
        else:
            usr.messager.unbindusr(usr)
            usr.messager = usr.my_origin_messager
            usr.messager.bindusr(usr)

    def __str__(self):
        return self.roomname

    __repr__ = __str__


class Message(object):

    def __init__(self, roomname):
        self.room = origin_room
        self.roomname = roomname
        self.bindlist = []

    @staticmethod
    def send(other, string):
        receiver = other
        receiver.receive_msg(string)

    def broadcast(self, string):
        for usr in self.bindlist:
            usr.receive_msg(string)

    def bindusr(self, usr):
        self.bindlist.append(usr)

    def unbindusr(self, usr):
        self.bindlist.remove(usr)

    def newroom(self, roomname, creater, pwd):
        self.room = Room(roomname, creater, pwd)


class User(object):

    def __init__(self, usrname):
        self.messager = origin_messager
        self.messager.bindusr(self)
        self.usrname = usrname
        self.mymsg = []
        self.my_origin_messager = origin_messager
        self.mypwd = {}

    def friend_online(self):
        return self.messager.bindlist

    def send_msg(self, other, string):
        if other in self.messager.bindlist:
            self.messager.send(other, string)
        else:
            return 'The user is not in your room.'

    def receive_msg(self, string):
        self.mymsg.append(string)

    def broadcast(self, string):
        self.messager.broadcast(string)

    def create_room(self, roomname, pwd):
        self.messager.unbindusr(self)
        self.messager = Message(roomname)
        self.messager.newroom(roomname, self, pwd)
        self.messager.bindusr(self)

    def invite(self, other, roomname):
        other.mymsg.append('Welcome to a new room: ' + roomname)
        other.mymsg.insert(0, self.messager.room.pwd[roomname])
        other.mymsg.insert(1, self.messager.room)

    def get_in_agree(self, roomname):
        self.mypwd[roomname] = self.mymsg[0]
        self.mymsg[1].get_in(self)

    def __str__(self):
        return '''
room:{0}
usrname:{1}
'''.format(self.messager.room.roomname,
           self.usrname)

    __repr__ = __str__

origin_room = Room('origin')
origin_messager = Message('origin')

# 以下是用法实例
user1 = User('first') 
user2 = User('second')
user3 = User('third')  # 创建新用户

user1.send_msg(user3, 'hello!')  # 发送消息给另一用户
user1.broadcast('firstbroadcast')  # 广播一则消息

print user2.mymsg
print user3.mymsg  # 查看消息

print user1.friend_online()  # 查看房间内在线用户

user1.create_room('This is a newroom', 12345)  # 创建新房间
user1.invite(user2, 'This is a newroom')  # 邀请另一用户加入新房间

user2.get_in_agree('This is a newroom')  # 接受邀请同意加入新房间

user2.messager.room.get_out(user2)  # 退出当前房间回到原始房间
print user1.friend_online(), user3.friend_online()

13-13

from time import ctime


class Afirm(object):

    def __init__(self, companyname):
        self.companyname = companyname
        self.allstock = {}

    def buystock(self, stock, price, number):
        if stock in self.allstock:
            self.allstock[stock].append([ctime(), price, number])
        else:
            self.allstock[stock] = [[ctime(), price, number]]

    def sellstock(self, stock):
        del self.allstock[stock]

    def income(self, stock, rate):
        return self.allstock[stock][-1][1] * rate


class DataBase(object):

    def __init__(self):
        self.allfirm = []

    def updatefirm(self, afirm):
        self.allfirm.append(afirm)

    def delfirm(self, afirm):
        self.allfirm.remove(afirm)

13-16

import os


class CapOpen(object):

    def __init__(self, filename, mode='r', buf=-1):
        self.file = open(filename, mode, buf)

    def __str__(self):
        return str(self.file)

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

    def writelines(self, text, newline=False):
        if newline:
            self.file.writelines(line.upper() + os.linesep
                                 for line in text)
        else:
            self.file.writelines(line.upper() for line in text)

    def write(self, line):
        self.file.write(line.upper())

    def __getattr__(self, attr):
        return getattr(self.file, attr)

13-17

class MoneyFmt(float):

    def __new__(cls, val):
        return super(MoneyFmt, cls).__new__(cls, round(val, 1))

    def __init__(self, val):
        self.value = round(val, 1)
        super(MoneyFmt, self).__init__(round(val, 1))

    def update(self, value=None):
        if value is not None:
            return self.__class__(round(value, 2))

    def __str__(self):
        return '${:-.1f}'.format(self.value)

    __repr__ = __str__

    def __nonzero__(self):
        if self.value < 0:
            return False
        else:
            return True

13-18

import shelve
from time import time, localtime


class MyDataBase(object):
    def __init__(self, name, passwd):
        self.name = str(name)
        self.passwd = str(passwd)

        self.db = shelve.open('database')

        self.new_logintime = time()
        self.year = localtime()[0]
        self.month = localtime()[1]

    def sign_up(self):
        if self.name in self.db:
            return 'name taken, try another.'
        else:
            self.db[self.name] = [self.passwd, 0,
                                  self.year, self.month]

    def log_in(self):
        passwd = self.db.get(self.name, [None, 0])[0]
        pre_logintime = self.db.get(self.name, [None, 0])[1]

        pre_year = self.db[self.name][2]
        pre_month = self.db[self.name][3]

        if (self.year - pre_year) * 12 + \
                (self.month - pre_month) > 12:
            return 'your password is out of date, please chang it.'

        if (self.new_logintime - pre_logintime <= 14400) \
                and pre_logintime != 0:
            return 'logged in at: <{0}>'.format(localtime(pre_logintime))

        if passwd == self.passwd:
            print 'welcome back', self.name
            self.db[self.name][1] = self.new_logintime
        else:
            return 'wrong name or password.'

        return 'done'

    def change_psd(self, psd):
        if self.log_in() == 'done':
            self.db[self.name] = [psd, self.new_logintime,
                                  self.year, self.month]
        else:
            return 'log in first'

    def __del__(self):
        self.db.close()
        print 'done'

13-20

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

    def __init__(self, atime=None, btime=0):
        """Time60 constructor - takes hours and minutes"""
        if isinstance(atime, tuple):
            self.hr = atime[0]
            self.minute = atime[1]
        elif isinstance(atime, dict):
            self.hr = atime['hr']
            self.minute = atime['min']
        elif isinstance(atime, str):
            time = atime.split(':')
            self.hr = int(time[0])
            self.minute = int(time[1])
        else:
            self.hr = 0
            self.minute = btime

    def __str__(self):
        """Time60 - string representation"""
        return '{0:02d}:{1:02d}'.format(self.hr, self.minute)

    def __repr__(self):
        return "Time60('{0:02d}:{1:02d}')".format(self.hr, self.minute)

    def __add__(self, other):
        """Time60 - overloading the addition operator"""
        hour = self.hr + other.hr
        minutes = self.minute + other.minute
        if hour >= 24:
            hour -= 24
        if minutes >= 60:
            hour += minutes / 60
            minutes -= 60
        return self.__class__(hour, minutes)

    def __idd__(self, other):
        """Time60 - overloading in-place addition"""
        hour = self.hr + other.hr
        minutes = self.minute + other.min
        if hour >= 24:
            hour -= 24
        if minutes >= 60:
            hour += minutes / 60
            minutes -= 60

        self.hr = hour
        self.minute = minutes
        return self

完。

转载于:https://my.oschina.net/u/2519674/blog/683698