python第四周学习内容

‘‘‘
error
def foo():
    print("in the foo")
    bar()
foo()
‘‘‘‘‘‘
OK
def bar():
    print("in the bar")
def foo():
    print("in the foo")
    bar()
foo()
‘‘‘‘‘‘
OK
def foo():
    print("in the foo")
    bar()
def bar():
    print("in the bar")
foo()
‘‘‘‘‘‘
error
def foo():
    print("in the foo")
    bar()
foo()
def bar():
    print("in the bar")
‘‘‘

import time
‘‘‘
把一个函数名当做实参传给另一个函数(在不修改被装饰函数源代码的情况下为其添加功能)
def bar():
    time.sleep(3)
    print("in the bar")
def test1(func):
    start_time = time.time()
    func()
    stop_time = time.time()
    print("the func run time is %s"%(stop_time-start_time))
test1(bar)
‘‘‘‘‘‘
返回值中包含函数名(不修改函数的调用方式)
def bar():
    time.sleep(0.1)
    print("in the bar")
def test2(func):
    print(func)
    return func
bar = test2(bar) #==》@test2
bar()‘‘‘

import  time
#嵌套函数,在一个函数的函数体内定义另一个函数
#被嵌套函数的作用域是嵌套它的函数的内部
def foo():
    print("in the foo")
    def bar():
        print("in the bar")
    bar()
foo()
def auth(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        stop_time = time.time()
        print("the func run time is %s"%(stop_time-start_time))
    return wrapper
@auth #相当于test=auth(test)-->test=wrapper
def test():
    time.sleep(10)
    print("in the tset")
test()

import  time
def timer(func): #timer(test1) func = test1
    def deco():
        start_time = time.time()
        func() #func = test1
        stop_time = time.time()
        print("the func run time is %s"%(stop_time - start_time))
    return deco
@timer #test1=timer(test1)
def test1():
    time.sleep(3)
    print("in the test1")
@timer #test2=timer(test2)
def test2():
    time.sleep(2)
    print("in the test2")

#test1 = timer(test2)
#test2 = timer(test2)
test1()
test2()

import  time
user_name = "Mr Wu"
user_passwd = "187847"
def auth(auth_type):
    print("by the %s"%auth_type)
    def out_wrapper(func):
        def wrapper(*args,**kwargs):
            if auth_type == "local":
                name = input("input your usernmae:")
                passworld = input("input your passworld:")
                if name == user_name and passworld == user_passwd:
                    func(*args,**kwargs)
                else:
                    exit("invalid input!")
            elif auth_type == "ldt":
                print("老子不会！操！")
        return wrapper
    return out_wrapper
@auth(auth_type="local")#相当于@out_wrapper-->home = out_wrapper(home)-->home = wrapper
def home():
    print("welcome to home page!")
@auth(auth_type="ldt")
def bbs():
    print("welcome to bbs page!")
home()
bbs()

#第一种生成器方法==》通过列表生成式改造
counting = (i for i in range(100))
for i in counting:
    print(i)
#第二种成器方法==》通过函数生成
def counting(max):
    n = 0
    while n<max:
        yield n
        n += 1
count = counting(100)
print(count.__next__())
print("My name is Mr Wu")
print(count.__next__())
print("I am a man")
print(count.__next__())
print("I am 19 years old")
print(count.__next__())
print("I like Python")
print(count.__next__())
print("I like C")
for i in count:
    print(i)

for i in [1,2,3,4,5]:
    print(i)
#完全等价于以下程序:
it = iter([1,2,3,4,5])
while True:
    try:
        #获得下一个值
        x = next(it)
    except StopIteration:
        #遇到StopIteration就退出循环
        break

#吃包子--做包子--》生产--消费流程
import time
def consumer(name):
    print("%s 准备吃包子啦!"%name)
    while True:
        baozi = yield
        print("包子[%s]来了,被[%s]吃了!"%(baozi,name))
#c = consumer("alex")
#c.__next__()
#b1 = "韭菜馅"
#c.send(b1) #调用生成器，同时给yield传值
def producer(name):
    c = consumer("A")
    c2 = consumer("B")
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(0.5)
        print("做了两个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

print(all([0,-5,3])) #如果Iterable内部元素都为真，返回True，否则返回False
print(any([0,-4,5])) #如果Iterable内部有一个元素为真，返回True，否则(Iterable为空)返回False
a = ascii([1,2,"开外挂"]) #把列表变成了一个字符串
print(type(a),[a]) #<class ‘str‘> ["[1, 2, ‘\\u5f00\\u5916\\u6302‘]"]
print(bin(1)) #将数字转换为二进制
print(bool(0)) #判断真假 True、False
a = bytes("abcde",encoding="utf-8")#字节
print(a.capitalize(),a) #b‘Abcde‘ b‘abcde‘
b = bytearray("abcde",encoding="utf-8")#字节数组
print(b) #bytearray(b‘abcde‘)
b[1] = 50
print(b) #bytearray(b‘a2cde‘)
print(callable([])) #判断是否可以调用
print(chr(98)) #将ASCII码转换为字符
print(ord("a")) #将字符转换为ASCII码
print(divmod(5,2)) #返回商和余数(2, 1)
#filter:对每个值进行过滤后返回结果形成列表
rest = filter(lambda n:n<5,range(10))
for i in rest:
    print(i)
#map:对每个值进行处理后返回结果形成列表
res = map(lambda n:n*n,range(10))
for i in res:
    print(i)
import functools
res = functools.reduce(lambda x,y:x*y,range(1,10))#阶乘
print(res)
a = frozenset([1,2,3,4,5,6,3,3,3,3])#不可变集合
print(a)
print(globals())#把当前文件下的所有变量及其方法取出来形成一个字典
print(hash("alex")) #将字符串映射成数字(哈希)
#help("time") #查看模块的帮助文档
print(hex(123)) #将一个数字转换为十六进制
print(len("abc123"))#返回字符串的长度
def test():
    local_var = 333
    print(locals())
test() #locals()打印局部变量
print(globals().get("local_var")) #error,globals()打印全局变量
print(max([1,2,3,4,5])) #返回列表中的最大值
print(min([1,2,3,4,5])) #返回列表中的最小值
print(oct(10)) #将一个数字转为八进制
print(pow(3,4)) #计算某个数字的多少次幂
print(round(1.4321,4)) #保留多少位小数
a = {6:2,8:0,1:4,-5:6,99:11,4:22}
#print(sorted(a.items()))#排序
print(sorted(a.items(),key = lambda x:x[1]))
a = [1,2,3,4,5]
b = ["a","b","c","d"]
for i in zip(a,b):
    print(i)      #(1, ‘a‘)
                  #(2, ‘b‘)
                  #(3, ‘c‘)
                  #(4, ‘d‘)
__import__("decorator1")

#compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
‘‘‘
说明：
　　1. 将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
　　2. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。
　　3. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。
　　4. 参数mode：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，mode应指定为‘exec’；
       当source中只包含一个简单的求值表达式，mode应指定为‘eval’；当source中包含了交互式命令语句，mode应指定为‘single‘。
   5.当一个字符串被exec,eval(),或execfile()执行时,解释器会先将它们编译为字节代码，然后再执行.这个过程比较耗时,
     所以如果需要对某段代码执行很多次时,最好还是对该代码先进行预编译,这样就不需要每次都编译一遍代码，可以有效提高程序的执行效率。
‘‘‘
#exec:当source中包含流程语句时，mode应指定为‘exec’
code1 = "for i in range(10):print(i)"
compile1 = compile(code1,‘‘,‘exec‘)
exec(compile1)

#eval:当source中只包含一个简单的求值表达式，mode应指定为‘eval’
code2 = "3 + 5 -6*7"
compile2 = compile(code2,‘‘,‘eval‘)
print(eval(compile2))

#single:当source中包含了交互式命令语句，mode应指定为‘single‘
code3 = ‘name = input()‘
compile3 = compile(code3,‘‘,‘single‘)
exec(compile3)
print(name)

import json
info = {
    "name":"alex",
    "age":22,
}
f = open("test.txt","w",encoding="utf-8")
f.write(json.dumps(info))
f.close()
‘‘‘
def sayhi(name):
    print("hello,",name)
info = {
    "name":"alex",
    "age":22,
    "func":sayhi
}
f = open("test2","w",encoding="utf-8")
f.write(json.dumps(info)) 
#error, <function sayhi at 0x0000012217F211E0> is not JSON serializable
f.close()
‘‘‘

#dump一次就load一次，不能多次load；每dump一次就生成一个新的文件，再load一次
import json
info = {
    "name":"alex",
    "age":22,
}
f = open("test.txt","w",encoding="utf-8")
f.write(json.dumps(info))
info["age"] = 20
f.write(json.dumps(info))
data = json.loads(f.read())#error
f.close()

import json
f = open("test.txt","r",encoding="utf-8")
data = json.loads(f.read())
#data = json.load(f)
print(data)
f.close()

软件结构规范：
为什么要设计好目录结构
   “设计目录结构”就和“代码编写风格”一样，属于个人风格问题。
    设计一个层次清晰的目录结构，就是为了达到以下两点：
       1.可读性高：不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个，测试目录在哪儿，配置文件在哪儿等等
         从而快速的了解这个项目
       2.可维护性高：定义好组织规则后，维护者就能很明确的知道，新增的哪个文件和代码应该放在什么目录之下。这个好处是随着时间的推移，
         代码/配置的规模增加，项目结构不会混乱，仍然能组织良好
    因此保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录，其实是一个很简单的事儿
目录组织方式：
    关于如何组织一个较好的python工程目录结构，已经有一些得到了共识的目录结构。在StackOverflow的这个问题上，
    能看到大家对python目录结构的讨论。
    假设你的项目名为foo，我比较建议的最方便快捷目录结构这样就足够了：
    Foo/
    |-- bin/
    | |-- foo
    |
    |-- foo/
    | |-- test/
    | | |-- _init_.py
    | | |-- test_main.py
    | |
    | |-- _init_.py
    | |-- main.py
    |
    |-- docs/
    | |-- conf.py
    | |-- abc.rst
    |
    |-- setup.py
    |-- requirements.txt
    |-- README
    简单解释一下：
    1.bin/:存放项目的一些可执行文件，当然你可以起名script/之类的也行
    2.foo/:存放项目的所有源代码。(1)源代码中的所有模块、包都应该放在此目录，不要置于顶层目录。
                               (2)其子目录tests/存放单元测试代码
                               (3)程序的入口最好命名为main.py
    3.docs/:存放一些文档。
    4.setup.py:安装、部署、打包的脚本。
    5.requirements.txt:存放软件依赖的外部python包列表
    6.README:项目说明文件,目的是能简单描述该项目的信息，让读者快速了解这个项目
      它需要说明一下几个事项：
          1.软件定位，软件的基本功能
          2.运行代码的方法：安装环境、启动命令
          3.简要的使用说明
          4.代码目录结构说明，更详细点可以说明软件的基本原理。
          5.常见问题说明