python学习代码

Posted 2020-10-30 在左手

#!/bin/python
#example 1.1
#applay
def function(a,b):
    print(a,b)
def example1():
    apply(function, ("whither","cannada?"))
    apply(function, (1,2+3))
    apply(function, (32,),{"b":"hello world"})
    apply(function, (), {"a":"hello world","b":"new world, new way"})

class Rectangle:
    def __init__(self, color="white", width=10, height=10):
        print("create a", color, self, "sized", width, "x", height)

class RoundedRectangle(Rectangle):
    def __init__(self, **kw):
        apply(Rectangle.__init__, (self,), kw)
def example2():
    rect = Rectangle(color="green", height=100, width=100)
    rect = RoundedRectangle(color="blue", height=20,width=10)

def function2(**kwargs):
    print(kwargs)
    apply(function,(),kwargs)
def function3(*args):
    print(args)
    apply(function, args)
def example3():
    function3(1,2)
    function2(a="ddd",b=3)

#exmaple 4
def getfunctionbyname(module_name, function_name):
    module = __import__(module_name)
    return getattr(module, function_name)
def example4():
    print(repr(getfunctionbyname("dumbdbm","open")))


#example 5
class LazyImport:
    def __init__(self, module_name):
        self.module_name = module_name
        self.module = None
    def __getattr__(self, item):
        if self.module is None:
            self.module = __import__(self.module_name)
        return getattr(self.module, item)
def example5():
    string = LazyImport("string")
    print(string.lowercase)
    print(string.module_name)

#example 6
def dump(value):
    print(value,"=>",dir(value))
def example6():
    import sys
    dump(0)
    dump(1.0)
    dump(0.0j)
    dump([])
    dump({})
    dump("string")
    dump(len)
    dump(sys)

#example 7
class A:
    def a(self):
        pass
    def b(self):
        pass
class B(A):
    def c(self):
        pass
    def d(self):
        pass
def getmembers(kclass, members=None):
    #get a list of all class members, ordered by class
    if members is None:
        members=[]
    for k in kclass.__bases__:
        getmembers(k, members)
    for m in dir(kclass):
        if m not in members:
            members.append(m)
    return members

def example7():
    print(getmembers(A))
    print(getmembers(B))
    print(getmembers(IOError))

#example 8
def example8():
    book = "library2"
    pages = 250
    scripts = 350
    print("the %(book)s book contains more than %(scripts)s scripts" % vars())

#example 9
def example9():
    def dump(value):
        print(type(value),value)
    dump(1)
    dump(1.0)
    dump("one")
#example 10
def example10():
    def load(file):
        if isinstance(file, type("")):
            file = open(file, "rb")
            return file.read()
    print(len(load("./__builtin__.py")),"bytes")
    #print(len(load(open("./main.py","rb"))),"bytes")

#example 11
def example11():
    def dump(function):
        if callable(function):
            print(function, "is callable")
        else:
            print(function, "is not callable")
    class A:
        def method(self,value):
            return value
    class B(A):
        def __call__(self,value):
            return value
    a = A()
    b = B()
    dump(0) #simple object
    dump("string")
    dump(callable)
    dump(dump)
    dump(A)
    dump(B)
    dump(B.method)
    dump(a)
    dump(b)
    dump(b.method)

#example 12
def example12():
    class A:
        pass
    class B:
        pass
    class C(A):
        pass
    class D(A, B):
        pass
    def dump(object):
        print(object,"=>",)
        if isinstance(object, A):
            print("A")
        if isinstance(object, B):
            print("B")
        if isinstance(object, C):
            print("C")
        if isinstance(object, D):
            print("D")
    a = A()
    b = B()
    c = C()
    d = D()
    dump(a)
    dump(b)
    dump(c)
    dump(d)
    dump(0)
    dump("string")

#example 13
def example13():
    class A:
        pass
    class B:
        pass
    class C(A):
        pass
    class D(A, B):
        pass
    def dump(object):
        print(object,"=>")
        if issubclass(object, A):
            print("A")
        if issubclass(object, B):
            print("B")
        if issubclass(object, C):
            print("C")
        if issubclass(object, D):
            print("D")
    dump(A)
    dump(B)
    dump(C)
    dump(D)
    #dump(0)
    #dump("string")

#example 14
def example14():
    def dump(expression):
        result = eval(expression)
        print(expression, "=>", result, type(result))
    dump("1")
    dump("1.0")
    dump("‘string‘")
    dump("1.0+2.0")
    dump("‘*‘*10")
    dump("len(‘world‘)")

#example 15
def example15():
    BODY = """print(‘the ant, an introduction‘)"""
    code = compile(BODY, "<script>","exec")
    print(locals())
    print(code)
    exec(code)

#example 16
#import sys,string
import string
class CodeGeneratorBackend:
    "Simple code generator for Python"
    def begin(self, tab ="\t"):
        self.code = []
        self.tab = tab
        self.level = 0
    def end(self):
        self.code.append("")#make sure there‘s a newline at the end
        return compile(string.join(self.code,"\n"),"<code>","exec")
    def write(self,string):
        self.code.append(self.tab * self.level + string)
    def indent(self):
        self.level = self.level + 1
    def dedent(self):
        if self.level == 0:
            raise SystemError,"internal error in  code generator"
        self.level = self.level -1
def example16():

    c = CodeGeneratorBackend()
    c.begin()
    c.write("for i in range(5):")
    c.indent()
    c.write("print(‘code generation made easy!‘)")
    c.dedent()
    exec(c.end())

#example 17
def example17():
    def open(filename, mode="rb"):
        import __builtin__
        file = __builtin__.open(filename, mode)
        if file.read(5) not in ("GIF87", "GIF89"):
            print("hello world")
            raise IOError, "not a GIF file"
        file.seek(0)
        return file
    fp = open("__builtin__.py")
    print(len(fp.read()),"bytes")

#example 18
class HTTPError(Exception):
    def __init__(self, url, errcode, errmsg):
        self.url = url
        self.errcode = errcode
        self.errmsg = errmsg
    def __str__(self):
        return ("<HTTPError for %s :%s %s> % (self.url, self.errcode, self.errmsg))")
def example18():
    try:
        raise HTTPError("http://www.python.org/foo", 200, "Not Found")
    except HTTPError, error:
        print("url =>",error.url)
        print("errcode =>",error.errcode)
        print("errmsg =>", error.errmsg)

#example 19
def example19():
    import os , string
    def replace(file, search_for, replace_with):
        back = os.path.splitext(file)[0] + ".bak"
        temp = os.path.splitext(file)[0] + ".tmp"
        try:
            os.remove(temp)
        except os.error:
            pass
        fi = open(file)
        fo = open(temp, "w")
        for s in fi.readlines():
            fo.write(string.replace(s, search_for, replace_with))
        fi.close()
        fo.close()
        try:
            os.remove(back)
        except os.error:
            pass
        os.rename(file, back)
        os.rename(temp, file)
    print("replace string .")

#example 20
def example20():
    import  os
    cwd = os.getcwd()
    print(repr(cwd))
    for file in os.listdir(cwd):
        print(file)
    pass
    path = "C:\\"
    os.chdir(path)
    print(os.getcwd())
    for file in os.listdir(path):
        print(file)

#example 21
def example21():
    import os ,time
    currentPath = os.getcwd()
    print(currentPath)
    file = currentPath +"/__builtin__.py"
    print("file is %s" % file)
    def dump(st):
        mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime = st
        print("-size: %s bytes" % size)
        print("-owner: %s %s" % (uid, gid))
        print("-owner_s: %(hh)s %(uu)s" % {"hh":uid, "uu":gid})
        print("-created:", time.ctime(ctime))
        print("-last accessed:", time.ctime(atime))
        print("-last modified:", time.ctime(mtime))
        print("-mode:", oct(mode))
        print("-inode/dev:", ino,dev)
    st = os.stat(file)
    print("stat")
    print(st)
    dump(st)

#example 22
def example22():
    import os
    if os.name == "nt":
        command = "dir"
    else:
        command = "ls -l"
    os.system(command)

#example 23
def example23():
    import os, sys
    program = "python"
    currentPath = os.getcwd()
    arguments = ["%s/main.py" % currentPath]
    print(arguments)
    result =os.execvp(program, (program,) + tuple(arguments))
    print(result)
    print("goodbye")

#example 24 without windows system!
#only for unix
def example24():
    import os, sys
    currentPath = os.getcwd()
    scriptPath = "%s/main.py" % currentPath
    def run(program, *args):
        pid = os.fork()
        if not pid:
            os.execvp(program, (program,) + args)
        return os.wait()[0]
    run("python",scriptPath)
    print("goodbye")

#example 25
#only for linux
import os, string

def run(program, *args):
    #find executable
    for path in string.split(os.environ["path"], os.pathsep):
        print(path)
        file = os.path.join(path, program) + ".exe"
        try:
            if os.path.exists(file):
                return os.spawnv(os.P_WAIT, file, (file,)+args)
            else:
                raise os.error ,"the path is not exist"
        except os.error,e:
            print(e)
            pass
    raise os.error, "cannot find exectuable"

def example25():
    run("python", "main.py")

#example 26
#only for windows
def example26():
    import os, string
    def run(program, *args, **kw):
        mode = kw.get("mode", os.P_WAIT)
        for path in string.split(os.environ["path"], os.pathsep):
            file = os.path.join(path, program)+".exe"
            try:
                return os.spawnv(mode, file, (file,)+args)
            except os.error:
                pass
        raise os.error, "cannot find excutable"
#exmaple 27
def example27():
    import os, string
    if os.name in ("nt", "dos"):
        exefile = ".exe"
        print("this os is windows or dos")
    else:
        exefile = ""
    def spawn(program, *args):
        try:
            return os.spawnvp(program, (program,)+args)
        except AttributeError:
            pass
        try:
            spawnv = os.spawnv
        except AttributeError:
            #assume it‘s unix
            pid = os.fork()
            if not pid:
                os.execvp(program, (program,)+args)
                return os.wait()[0]
        else:
            #got sapwnv but no sapwnp: to look for an executable
            for path in string.split(os.environ["PATH"], os.pathsep):
                file = os.path.join(path, program) + exefile
                if os.path.exists(file):
                    print("the file is %s" % file)
                    try:
                        return spawnv(os.P_WAIT, file , (file,)+args)
                    except os.error:
                        pass
                else:
                    print("the file is no exist.")
            raise IOError, "cannot find executable"
    spawn("python", "main.py")

#example 28
#only for unix
def example28():
    #daemon processes
    import os, time
    pid = os.fork()
    if pid:
        os._exit(0) #kill original
        print("daemon started")
        time.sleep(10)
        print("daemon terminated")

#example 29
def example29():
    import  os, sys
    try:
        sys.exit(1)
    except SystemExit, value:
        print("caught exit(%s)" % value)
    try:
        print("try excute the code.")
        os._exit(2)
    except SystemExit, value:
        print("caught exit(%s)" % value)
    print("bye!")

#example 30
def example30():
    import os
    filename = "my/little/pony.txt"
    #filename = "my/little/pony"
    print("the filename:%s" % filename)
    print("using %s ... " % os.name)
    print("split =>", os.path.split(filename))
    print("splitext =>", os.path.splitext(filename))
    print("dirname =>", os.path.dirname(filename))
    print("basename =>", os.path.basename(filename))
    print("join =",os.path.join(os.path.dirname(filename), os.path.basename(filename)))

#example 31
def example31():
    import os
    FILES = (os.curdir, "/", "file", "/file", "samples", "samples/sample.jpg",
             "directory/file", "../directory/file", "/directory/file"
             )
    for file in FILES:
        print(file,"=>")
        if os.path.exists(file):
            print("EXISTS")
        if os.path.isabs(file):
            print("ISABS")
        if os.path.isdir(file):
            print("ISDIR")
        if os.path.isfile(file):
            print("ISFILE")
        if os.path.islink(file):
            print("ISLINK")
        if os.path.ismount(file):
            print("ISMOUNT")
        print("######end######")


#exmaple 32
def example32():
    import os
    print(os.path.expanduser("~/.pythonrc"))

#example 33
def example33():
    import os
    for i in os.environ:
        print(i)
    os.environ["USER"] = "user"

    print(os.path.expandvars("/home/$USER/config"))
    print(os.path.expandvars("/$USER/folders"))

#example 34
def example34():
    import os
    def callback(arg, directory, files):
        print("#######")
        print(directory,"the files number is %d" % len(files))
        for file in files:
            print(os.path.join(directory, file), repr(arg))
    os.path.walk(".", callback, "secret message")

#example 35
def example35():
    import os
    def index(directory):
        # like os.listdir, but traverses directory trees
        stack = [directory]
        files = []
        while stack:
            directory = stack.pop()
            for file in os.listdir(directory):
                fullname = os.path.join(directory, file)
                files.append(fullname)
                if os.path.isdir(fullname) and not os.path.islink(fullname):
                    stack.append(fullname)
        return files
    for file in index("."):
        print(file)

#example 36
def example36():
    import os
    class DirectoryWalker:
        # a  forward iterator that traverses a directory tree
        def __init__(self, directory):
            self.stack = [directory]
            self.files = []
            self.index = 0

        def __getitem__(self, index):
            while 1:
                try:
                    file = self.files[self.index]
                    self.index = self.index + 1
                except IndexError:
                    # pop next directory from stack
                    self.directory = self.stack.pop()
                    self.files = os.listdir(self.directory)
                    self.index = 0
                else:
                    # got a filename
                    fullname = os.path.join(self.directory, file)
                    if os.path.isdir(fullname) and not os.path.islink(fullname):
                        self.stack.append(fullname)
                    return fullname
    for file in DirectoryWalker("."):
        print(file)


#example 37
def example37():
    import os , stat
    class DirectoryStatWalker:
        def __init__(self, directory):
            self.stack = [directory]
            self.files = []
            self.index = 0
        def __getitem__(self, index):
            while 1:
                try:
                    file = self.files[self.index]
                    self.index = self.index + 1
                except IndexError:
                    self.directory = self.stack.pop()
                    self.files = os.listdir(self.directory)
                    self.index = 0
                else:
                    fullname = os.path.join(self.directory, file)
                    st = os.stat(fullname)
                    mode = st[stat.ST_MODE]
                    if stat.S_ISDIR(mode) and not stat.S_ISLNK(mode):
                        self.stack.append(fullname)
                    return fullname,st
    for file, st in DirectoryStatWalker("."):
        print(file, st[stat.ST_SIZE])


#example 38
def example38():
    import stat
    import os, time
    st = os.stat("./main.py")
    print("mode => ", oct(stat.S_IMODE(st[stat.ST_MODE])))
    print("type => ")
    if stat.S_ISDIR(st[stat.ST_MODE]):
        print("DIRECTORY")
    if stat.S_ISREG(st[stat.ST_MODE]):
        print("REGULAR")
    if stat.S_ISLNK(st[stat.ST_MODE]):
        print("LINK")
    pass
    print("size => ", st[stat.ST_SIZE])
    print("last accessed => ", time.ctime(st[stat.ST_ATIME]))
    print("last modified => ", time.ctime(st[stat.ST_MTIME]))
    print("inode changed => ", time.ctime(st[stat.ST_CTIME]))


#example 39
def example39():
    import string
    text = "Monty Python‘s Flying Circus"
    print("upper => %s" % string.upper(text))
    print("lower => %s" % string.lower(text))
    print("split => %s" % string.split(text))
    print("join => %s" % string.join(text, ‘+‘))
    print("replace => %s" % string.replace(text, "Python", "Java"))
    print("find => ", string.find(text, "Python"), string.find(text, "Java"))
    print("count => ", string.count(text, ‘n‘))


#example 40
def example40():
    text = "Monty Python‘s Flying Circus"
    print("upper => %s" % text.upper())
    print("lower => %s" % text.lower())
    print("split => %s" % text.split())
    print("join => %s" % text.join(‘+‘))
    print("replace => %s" % text.replace("Python", "Java"))
    print("find => ", text.find("Python"), text.find("Java"))
    print("count => ", text.count(‘n‘))

#example 41
def example41():
    import string
    print(int("4711"))
    print(string.atoi("4711"))
    print(string.atoi("11147", 8)) #octal
    print(string.atoi("1267", 16)) #hexadecimal
    print(string.atoi("3mv", 36)) #whatever...

    print(string.atoi("4711", 0))
    print(string.atoi("04711", 0))
    print(string.atoi("0x4711", 0))

    print float("4711")
    print(string.atof("1"))
    print(string.atof("1.23e5"))


#example 42
def example42():
    import re
    text = "the Attila the Hun Show"

    # a single character
    m = re.match(".", text)
    if m:
        print(repr("."), "=>", repr(m.group(0)))

    #any string fo characters
    m = re.match(".*", text)
    if m:
        print(repr(".*"), "=>", repr(m.group(0)))

    #a string of letters (at least one)
    m = re.match("\w+", text)
    if m:
        print(repr("\w+"), "=>", repr(m.group(0)))

    # a string of digits
    m = re.match("\d+", text)
    if m:
        print(repr("\d+"), "=>", repr(m.group(0)))

#example 43
def example43():
    import re
    text = "10/15/99"
    m = re.match("(\d{2})/(\d{2})/(\d{2,4})", text)
    if m:
        print(m.group(1, 2, 3))
        print(m.group())
        print(m.group(1))
        print(len(m.group()))

#example 44
def example44():
    import re
    text = "Example 3: There is 1 date 10/25/95 in here!"
    m = re.search("(\d{1,2})/(\d{1,2})/(\d{2,4})", text)
    print(m.group(1), m.group(2), m.group(3), "group")

    month, day, year = m.group(1, 2, 3)
    print(month, day, year)

    date = m.group(0)
    print(date)

#example 45
def example45():
    import re
    text = "you‘re no fun anymore..."

    #literal replace (string.replace is faster)
    print(re.sub("fun", "entertaining", text))

    #collapse all non-letter sequences to a single dash
    print(re.sub("[^\w]+", "-", text))

    #convert all words to beeps
    print(re.sub("\S+", "-BEEP-", text))

#example 46
def example46():
    import re, string
    text = "a line of text\\012another line of text\\012etc..."
    def octal(match):
        #replace octal code with corresponding ASCII character
        return chr(string.atoi(match.group(1), 8))
    octal_pattern = re.compile(r"\\(\d\d\d)")
    print(text)
    print octal_pattern.sub(octal, text)

#example 47
def example47():
    import re, string
    def combined_pattern(patterns):
        p = re.compile(string.join(map(lambda x: "("+x+")", patterns), "|"))
        def fixup(v, m = p.match, r = range(0, len(patterns))):
            try:
                regs = m(v).regs
                #print(regs)
            except AttributeError:
                return None # no match, so m.regs will fail
            else:
                for i in r:
                    if regs[i+1] != (-1, -1):
                        return i
        return fixup
    patterns = [r"\d+",
                r"abc\d{2,4}",
                r"p\w+"
                ]
    p = combined_pattern(patterns)

    print(p("129391"))
    print(p("abc800"))
    print(p("abc1600"))
    print(p("python"))
    print(p("perl"))
    print(p("tcl"))

#example 48
def example48():
    import math
    print("e => ", math.e)
    print("pi => ", math.pi)
    print("hypot => ", math.hypot(3.0, 4.0))

#example 49
def example49():
    import cmath
    print("pi => ", cmath.pi)
    print("sqrt(-1) => ", cmath.sqrt(-1))

#example 50
def example50():
    import operator
    sequence = 1, 2, 4

    print("add => ", reduce(operator.add, sequence))
    print("sub =>", reduce(operator.sub, sequence))
    print("mul =>", reduce(operator.mul, sequence))
    print("concat =>", operator.concat("spam", "egg"))
    print("repeat =>", operator.repeat("spam", 5))
    print("getitem =>", operator.getitem(sequence, 2))
    print("indexOf =>", operator.indexOf(sequence, 2))
    print("sequenceIncludes =>", operator.sequenceIncludes(sequence, 3))

#example 51
def example51():
    import operator, UserList
    def dump(data):
        print(type(data), "=>")
        if operator.isCallable(data):
            print("CALLABLE")
        if operator.isMappingType(data):
            print("MAPPING")
        if operator.isNumberType(data):
            print("NUMBER")
        if operator.isSequenceType(data):
            print("SEQUENCE")
        print("---")
    dump(0)
    dump("string")
    dump("string"[0])
    dump([1, 2, 3])
    dump((1, 2, 3))
    dump({"a": 1})
    dump(len)
    dump(UserList)
    dump(UserList.UserList)
    dump(UserList.UserList())


#example 52
def example52():
    import copy
    a = [[1], [2], [3]]
    b = copy.copy(a)

    print("before a=>", a)
    print("before b=>", b)

    if a is b:
        print("a is b")
    else:
        print("a is not b")


    #modify original
    a[0][0] = 0
    a[1] = None

    if a[0][0] is b[0][0]:
        print("a[0][0] is b[0][0]")
    else:
        print("a[0][0] is not b[0][0]")

    print("after a=>", a)
    print("after b=>", b)


#example 53:
def example53():
    import  copy
    a = [[1], [2], [3]]
    b = copy.deepcopy(a)

    print("before a=>", a)
    print("before b=>", b)

    if a is b:
        print("a is b")
    else:
        print("a is not b")

    # modify original
    a[0][0] = 0
    a[1] = None

    if a[0][0] is b[0][0]:
        print("a[0][0] is b[0][0]")
    else:
        print("a[0][0] is not b[0][0]")

    print("after a=>", a)
    print("after b=>", b)

#example 54:
def example54():
    import sys
    print("script name is: ", sys.argv[0])

    if len(sys.argv) > 1:
        print("there are ", len(sys.argv) - 1, "arguments:")
        for arg in sys.argv[1:]:
            print(arg)
    else:
        print("there are no arguments!")


#example 55:
def example55():
    import sys
    print("path has", len(sys.path), "members")
    #add the sample directory to the path

    sys.path.insert(0, "samples")
    import sample
    sys.path = []
    import random

#example 56:
def example56():
    import sys
    def dump(module):
        print("module => ")
        if module in sys.builtin_module_names:
            print("<BUILTIN>")
        else:
            module = __import__(module)
            print(module.__file__)

    dump("os")
    dump("sys")
    dump("string")
    dump("strop")
    dump("zlib")

#example 57:
def example57():
    import sys, pprint
    moduleKeys = sys.modules.keys()
    print(len(moduleKeys))
    print(moduleKeys)
    pprint.pprint(moduleKeys)

#example 58:
def example58():
    import sys
    variable = 1234
    print(sys.getrefcount(0))
    print(sys.getrefcount(variable))
    print(sys.getrefcount(None))

#example 59:
def example59():
    import sys
    if sys.platform == "win32":
        import ntpath
        pathmodule = ntpath
    elif sys.platform == "mac":
        import macpath
        pathmodule = macpath
    else:
        import posixpath
        pathmodule = posixpath

    print(pathmodule)

#example 60
def example60():
    import sys
    def test(n):
        j = 0
        for i in range(n):
            j = j + 1
        return n
    def profiler(frame, event, arg):
        print(event, frame.f_code.co_name, frame.f_lineno, "->", arg)

    sys.setprofile(profiler)
    test(1)

    sys.setprofile(None)
    test(2)

#example 61:
def example61():
    import sys
    def test(n):
        j = 0
        for i in range(n):
            j = j + i
        return n

    def tracer(frame, event, arg):
        print(event, frame.f_code.co_name, frame.f_lineno, "->", arg)
        return tracer

    sys.settrace(tracer)
    test(1)
    sys.settrace(None)
    test(2)

#example 62:
def example62():
    import sys, string
    class Redirect:
        def __init__(self, stdout):
            self.stdout = stdout
        def write(self, s):
            self.stdout.write(string.lower(s))
    old_stdout = sys.stdout
    sys.stdout = Redirect(sys.stdout)
    print("HEJA SVERIGE")
    print("FRISKT HUM\303\226R")
    sys.stdout = old_stdout
    print("M\303\205\303\205\303\205\303\205L!")

#example 63:
def example63():
    import sys
    print("hello")
    sys.exit(1)
    print("there")

#example 64:
def example64():
    import sys
    print("hello")
    try:
        sys.exit(1)
    except SystemExit, e:
        pass
        print("get the except:SystemExit %s" % e)
    print("there")

#example 65:
def example65():
    import sys
    def exitfunc():
        print("world")

    sys.exitfunc = exitfunc
    print("hello ")
    sys.exit(1)
    print("there")

#example 66:
def example66():
    import atexit
    def exit(*args):
        print("exit", args)

    #register two exit handler
    atexit.register(exit)
    atexit.register(exit, 1)
    atexit.register(exit, "hello", "world", "!")

#example 67:
def example67():
    import  time
    now = time.time()
    print(now, "Seconds since ", time.gmtime(0)[:6])
    print("-local time:", time.localtime(now))
    print("-utc:", time.gmtime(now))

#example 68:
def example68():
    import  time
    now = time.localtime(time.time())

    print(time.asctime(now))
    print(time.strftime("%y/%m/%d %H:%M", now))
    print(time.strftime("%c", now))
    print(time.strftime("%I %p", now))
    print(time.strftime("%Y-%m-%d %H:%M:%S %Z", now))

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

    print("%04d-%02d-%02d" % (year, month, day))
    print("%02d:%02d:02%d" % (hour, minute, second))
    print(("MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN")[weekday], yearday)

#example 69
def example69():
    import  time
    try:
        strptime = time.strptime
    except AttributeError:
        print("exception about the function: strptime")
        from _strptime import strptime
    print(strptime("31 Nov 00"), "%d %b %y")

#example 70
def example70():
    import time
    t0 = time.time()
    tm = time.localtime(t0)
    print(tm)
    print(t0)
    print(time.mktime(tm))

#example 71
def example71():
    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")

if __name__ == "__main__":
    print("process %s section start" % "__builtin__")
    print("---")
    boolWhichWay = True
    if boolWhichWay:
        for i in xrange(1, 1000):
            strFunctionName = "example%d" % i
            if strFunctionName in globals():
                pass
            else:
                strFunctionName = "example%d" % (i-1)
                strExcuteFunctionName = "%s()" % strFunctionName
                print("#excute function %s:" % strFunctionName)
                eval(str(strExcuteFunctionName), globals())
                print("---")
                break
    else:
        for i in xrange(1, 1000):
            strFunctionName = "example%d" % i
            if strFunctionName in globals():
                strFunctionName = "example%d" % i
                strExcuteFunctionName = "%s()" % strFunctionName
                print("#excute function %s:" % strFunctionName)
                eval(str(strExcuteFunctionName), globals())
                print("---")
            else:
                break
    print("process end")