python标准库学习8

import sys

import string

class Redirect:

    def _ _init_ _(self, stdout):

        self.stdout = stdout

    def write(self, s):

        self.stdout.write(string.lower(s))

# redirect standard output (including the print statement)

# 重定向标准输出(包括print语句)

old_stdout = sys.stdout

sys.stdout = Redirect(sys.stdout)

print "HEJA SVERIGE",

print "FRISKT HUM\303\226R"

# restore standard output

# 恢复标准输出

sys.stdout = old_stdout

print "M\303\205\303\205\303\205\303\205L!"

heja sverige friskt hum\303\266r

M\303\205\303\205\303\205\303\205L!

import sys

print "hello"

sys.exit(1)

print "there"

hello

import sys

print "hello"

try:

    sys.exit(1)

except SystemExit:

    pass

print "there"

hello

there

import sys

def exitfunc():

    print "world"

sys.exitfunc = exitfunc

print "hello"

sys.exit(1)

print "there" # never printed # 不会被 print

hello

world

import atexit

def exit(*args):

    print "exit", args

# register two exit handler

atexit.register(exit)

atexit.register(exit, 1)

atexit.register(exit, "hello", "world")

exit ('hello', 'world')

exit (1,)

exit ()

import time

now = time.time()

print now, "seconds since", time.gmtime(0)[:6]

print

print "or in other words:"

print "- local time:", time.localtime(now)

print "- utc:", time.gmtime(now)

937758359.77 seconds since (1970, 1, 1, 0, 0, 0)

or in other words:

- local time: (1999, 9, 19, 18, 25, 59, 6, 262, 1)

- utc: (1999, 9, 19, 16, 25, 59, 6, 262, 0)

import time

now = time.localtime(time.time())

print time.asctime(now)

print time.strftime("%y/%m/%d %H:%M", now)

print time.strftime("%a %b %d", now)

print time.strftime("%c", now)

print time.strftime("%I %p", now)

print time.strftime("%Y-%m-%d %H:%M:%S %Z", now)

# do it by hand...

year, month, day, hour, minute, second, weekday, yearday, daylight = now

print "%04d-%02d-%02d" % (year, month, day)

print "%02d:%02d:%02d" % (hour, minute, second)

print ("MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN")[weekday], yearday

Sun Oct 10 21:39:24 1999

99/10/10 21:39

Sun Oct 10

Sun Oct 10 21:39:24 1999

09 PM

1999-10-10 21:39:24 CEST

1999-10-10

21:39:24

SUN 283

import time

# make sure we have a strptime function!

# 确认有函数 strptime

try:

    strptime = time.strptime

except AttributeError:

    from strptime import strptime

print strptime("31 Nov 00", "%d %b %y")

print strptime("1 Jan 70 1:30pm", "%d %b %y %I:%M%p")

import re

import string

MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",

          "Sep", "Oct", "Nov", "Dec"]

SPEC = {

    # map formatting code to a regular expression fragment

    "%a": "(?P<weekday>[a-z]+)",

    "%A": "(?P<weekday>[a-z]+)",

    "%b": "(?P<month>[a-z]+)",

    "%B": "(?P<month>[a-z]+)",

    "%C": "(?P<century>\d\d?)",

    "%d": "(?P<day>\d\d?)",

    "%D": "(?P<month>\d\d?)/(?P<day>\d\d?)/(?P<year>\d\d)",

    "%e": "(?P<day>\d\d?)",

    "%h": "(?P<month>[a-z]+)",

    "%H": "(?P<hour>\d\d?)",

    "%I": "(?P<hour12>\d\d?)",

    "%j": "(?P<yearday>\d\d?\d?)",

    "%m": "(?P<month>\d\d?)",

    "%M": "(?P<minute>\d\d?)",

    "%p": "(?P<ampm12>am|pm)",

    "%R": "(?P<hour>\d\d?):(?P<minute>\d\d?)",

    "%S": "(?P<second>\d\d?)",

    "%T": "(?P<hour>\d\d?):(?P<minute>\d\d?):(?P<second>\d\d?)",

    "%U": "(?P<week>\d\d)",

    "%w": "(?P<weekday>\d)",

    "%W": "(?P<weekday>\d\d)",

    "%y": "(?P<year>\d\d)",

    "%Y": "(?P<year>\d\d\d\d)",

    "%%": "%"

}

class TimeParser:

    def _ _init_ _(self, format):

        # convert strptime format string to regular expression

        format = string.join(re.split("(?:\s|%t|%n)+", format))

        pattern = []

        try:

            for spec in re.findall("%\w|%%|.", format):

                if spec[0] == "%":

                    spec = SPEC[spec]

                pattern.append(spec)

        except KeyError:

            raise ValueError, "unknown specificer: %s" % spec

        self.pattern = re.compile("(?i)" + string.join(pattern, ""))

    def match(self, daytime):

        # match time string

        match = self.pattern.match(daytime)

        if not match:

            raise ValueError, "format mismatch"

        get = match.groupdict().get

        tm = [0] * 9

        # extract date elements

        y = get("year")

        if y:

            y = int(y)

            if y < 68:

                y = 2000 + y

            elif y < 100:

                y = 1900 + y

            tm[0] = y

        m = get("month")

        if m:

            if m in MONTHS:

                m = MONTHS.index(m) + 1

            tm[1] = int(m)

        d = get("day")

        if d: tm[2] = int(d)

        # extract time elements

        h = get("hour")

        if h:

            tm[3] = int(h)

        else:

            h = get("hour12")

            if h:

                h = int(h)

                if string.lower(get("ampm12", "")) == "pm":

                    h = h + 12

                tm[3] = h

        m = get("minute")

        if m: tm[4] = int(m)

        s = get("second")

        if s: tm[5] = int(s)

        # ignore weekday/yearday for now

        return tuple(tm)

def strptime(string, format="%a %b %d %H:%M:%S %Y"):

    return TimeParser(format).match(string)

if _ _name_ _ == "_ _main_ _":

    # try it out

    import time

    print strptime("2000-12-20 01:02:03", "%Y-%m-%d %H:%M:%S")

    print strptime(time.ctime(time.time()))

(2000, 12, 20, 1, 2, 3, 0, 0, 0)

(2000, 11, 15, 12, 30, 45, 0, 0, 0)

import time

t0 = time.time()

tm = time.localtime(t0)

print tm

print t0

print time.mktime(tm)

(1999, 9, 9, 0, 11, 8, 3, 252, 1)

936828668.16

936828668.0

import time

def _d(y, m, d, days=(0,31,59,90,120,151,181,212,243,273,304,334,365)):

    # map a date to the number of days from a reference point

    return (((y - 1901)*1461)/4 + days[m-1] + d +

        ((m > 2 and not y % 4 and (y % 100 or not y % 400)) and 1))

def timegm(tm, epoch=_d(1970,1,1)):

    year, month, day, h, m, s = tm[:6]

    assert year >= 1970

    assert 1 <= month <= 12

    return (_d(year, month, day) - epoch)*86400 + h*3600 + m*60 + s

t0 = time.time()

tm = time.gmtime(t0)

print tm

print t0

print timegm(tm)

(1999, 9, 8, 22, 12, 12, 2, 251, 0)

936828732.48

936828732

import time

def procedure():

    time.sleep(2.5)

# measure process time

t0 = time.clock()

procedure()

print time.clock() - t0, "seconds process time"

# measure wall time

t0 = time.time()

procedure()

print time.time() - t0, "seconds wall time"

0.0 seconds process time

2.50903499126 seconds wall time

import types

def check(object):

    print object,

    if type(object) is types.IntType:

        print "INTEGER",

    if type(object) is types.FloatType:

        print "FLOAT",

    if type(object) is types.StringType:

        print "STRING",

    if type(object) is types.ClassType:

        print "CLASS",

    if type(object) is types.InstanceType:

        print "INSTANCE",

    print

check(0)

check(0.0)

check("0")

class A:

    pass

class B:

    pass

check(A)

check(B)

a = A()

b = B()

check(a)

check(b)

0 INTEGER

0.0 FLOAT

0 STRING

A CLASS

B CLASS

<A instance at 796960> INSTANCE

<B instance at 796990> INSTANCE

import gc

# create a simple object that links to itself

class Node:

    def _ _init_ _(self, name):

        self.name = name

        self.parent = None

        self.children = []

    def addchild(self, node):

        node.parent = self

        self.children.append(node)

    def _ _repr_ _(self):

        return "<Node %s at %x>" % (repr(self.name), id(self))

# set up a self-referencing structure

root = Node("monty")

root.addchild(Node("eric"))

root.addchild(Node("john"))

root.addchild(Node("michael"))

# remove our only reference

del root

print gc.collect(), "unreachable objects"

print gc.collect(), "unreachable objects"

12 unreachable objects

0 unreachable objects