装饰器

本质是函数，用来装饰其他函数，就是为其他函数添加附加功能。

原则：

1. 不能去修改被装饰的原代码
2. 被装饰的函数的调用方式不能动

import time
def timmer(func):#本质是函数，函数即“变量”
    def warpper(*args,**kwargs):
        start_time=time.time()
        func()
        stop_time=time.time()
        print('the func run time is %s' %(stop_time-start_time))
    return warpper

@timmer#装器饰器的引用方法
def test1():
    time.sleep(3)
    print('in the test1')

test1()

运行如图：

in the test1
the func run time is 3.0006024837493896

故：实现装饰器知识储备

1. 函数即“变量”
2. 高阶函数
   高阶函数条件（2者有1个即可 ）：
   （1） 把1个函数当作实参传给另一个函数（实现不去修改被装饰的源代码）
   （2） 返回值中包含函数名（实现被装饰的函数的调用方式不改动）
3. 嵌套函数

高阶函数+嵌套函数=》装饰器

知识2-（1）：

import time
def bar():
	time.sleep(3)
	print('in the bar')
def test1(func):
	start_time=time.time()
	func()
	stop_time=time.time()#计算bar函数的运行时间
	print("the func run time is %s "%(stop_time-start_time))
#不修改被装饰的原代码bar(),为bar添加附加功能(计时) test1即装饰器
print(bar)#bar函数门号，内存地址，也就是说加括号就是调用 
test1(bar)

运行如下：

<function bar at 0x000000FD2E9AB9D8>
in the bar
the func run time is 3.000737428665161

知识2-（2）：

import time
def bar():
	time.sleep(3)
	print('in the bar')
def test2(func):
	print(func)
	return func#
bar=test2(bar)
#bar内存地址，交给Test2 ， 打印又返回bar内存地址，随后稪盖
bar()#运行Bar函数

运行如下：

<function bar at 0x000000FD2E9AB598>
in the bar

装饰器（无参数）

import time
def timer(func):
	def deco():
		start_time=time.time()
		func()#此地址是第一次给的bar1的内存，执行的是bar1()
		stop_time=time.time()
		print('the func run time is %s' %(stop_time-start_time))
	return deco
def bar1():
	time.sleep(3)
	print('in the bar')
@timer
#此句与bar1=timer(bar1)等同,想谁加上装饰器在哪加@+装饰器名
#只是这里是在bar2前，所有的bar1会成bar2
def bar2():
	time.sleep(3)
	print('in the bar2')
bar1=timer(bar1)
#把bar1的内存地址交给Timer，Deco函数就是“变量”，
#其接受Timer参数，故其地址就成了bar1的内存地址，并其返回赋值到了新bar1
bar1()#如此一来Bar1成了指向deco，加括号成了运行Deco（）
bar2()

运行如下：

in the bar
the func run time is 3.0003163814544678
in the bar2
the func run time is 3.0003561973571777

装饰器（有参数）

import time
def timer(func):#A:func=bar2
	def deco(*args,**kwargs):
		start_time=time.time()
		func(*args,**kwargs)#B:func=bar2
		stop_time=time.time()
		print('the func run time is %s' %(stop_time-start_time))
	return deco
def bar1():
	time.sleep(3)
	print('in the bar')
@timer
#bar2=timer(bar2),A,故：bar2()=deco(),当bar2()有参数，就可放到B处
#因不知道bar2有多少参数，故；用的是*args,**kwargs,用以接收不知数的参数
def bar2(name,age,sex):
	time.sleep(3)
	print('in the bar2：',name,age,sex)
bar1=timer(bar1)
bar1()
bar2("liang",18,"male")

运行如下：

in the bar
the func run time is 3.000230073928833
in the bar2： liang 18 male
the func run time is 3.000300645828247

装饰器（高级：装饰器带有参数）

网页登陆认证
Print(home()):打印home函数执行完所返回(return）的值
已往的【func(*args,**kwargs)#B:func=bar2】在源函数要求要有Return内容时，装饰器的【func(*args,**kwargs)#B:func=bar2】不加处理会导致源函数代码的Return内容丢失
故有下方：
res = func(*args, **kwargs) # from home
print("—after authenticaion ")
return res
登陆认证设本地和服务器认证。装饰器要改变升级–装饰器加上了参数
装饰器外嵌多一层函数

1. 引用装饰器语句的参数会传到第一层
2. 其他与上面两种大同小异
3. 断点运行视频 提取码: ydqs

__author__ = "Alex Li"
import time
user,passwd = 'alex','abc123'
def auth(auth_type):
    print("auth func:",auth_type)
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            print("wrapper func args:", *args, **kwargs)
            if auth_type == "local":
                username = input("Username:").strip()
                password = input("Password:").strip()
                if user == username and passwd == password:
                    print("\033[32;1mUser has passed authentication\033[0m")
                    res = func(*args, **kwargs)  # from home
                    print("---after authenticaion ")
                    return res
                else:
                    exit("\033[31;1mInvalid username or password\033[0m")
            elif auth_type == "ldap":
                print("搞毛线ldap,不会。。。。")

        return wrapper
    return outer_wrapper

def index():
    print("welcome to index page")
@auth(auth_type="local") 
# home = wrapper()，因为有了参数，有括号，其与上两种有区别。它会执行
def home():
    print("welcome to home  page")
    return "from home"

@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs  page")

index()
print(home()) #wrapper()
bbs()

生成器

列表生成式

a=[]
for i in range(10):
	a.append(i*2)
print (a)

运行如下：

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18

定义：

在Python中，一边循环一边计算的机制，称为生成器（generator）。

1. 只有在用到才生成相应数据，相对列表等省空间
2. 只记录当前位置
3. 只有一个__next__()方法。

b=(i*2 for i in range (10))
for i in b:
	print(i)

运行如下：

0
2
4
6
8
10
12
14
16
18

a=(i*5 for i in range(10))
for  i ,index  in enumerate(a):
	print(i,index)
	print(a.__next__())#寻找并打印下一个，for一共跳2步
#取生成器下一个数据

运行如下：

0 0
5
1 10
15
2 20
25
3 30
35
4 40
45

函数生成器

定义

斐波耶契数列：1，1，2，3，5，8，13，21，34，55…

def fib(max):
	n,a,b=0,0,1
	while n<max:
		print(b)
		a,b=b,a+b#a=1,b=1,n为次数
		n+=1
	return "done"
fib(10)	

运行如下：

1
1
2
3
5
8
13
21
34
55
Out[62]:'done'

def fib(max):
	n,a,b=0,0,1
	while n<max:
		#print(b)
		yield b#想返回什么yield谁
		a,b=b,a+b#a=1,b=1,n为次数
		n+=1
	return "done"
#此Return非函数的Return，生成器非函数，它可以不运行完而跳出来，即中断
print(fib(100))
fib_gen=fib(100)
print("-----------")
print(fib_gen.__next__())
#相当于停在yield b 那，可以出来
print(fib_gen.__next__())
print(fib_gen.__next__())
print(fib_gen.__next__())

#运行结果1，1，2，3

生成器并行运算

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield
       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
c = consumer("ChenRonghua")
c.__next__()#让其回到baozi = yield语句
b1= "韭菜馅"
c.send(b1)
#唤醒Yield并send个值给Yield，并让Yield返回该值，从而实现并行运算
b2= "猪肉馅"
c.send(b2)

运行如下:

ChenRonghua 准备吃包子啦!
包子[韭菜馅]来了,被[ChenRonghua]吃了!
包子[猪肉馅]来了,被[ChenRonghua]吃了!

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield
       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
def producer(name):
    c = consumer('A')#让其跳入生成器
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    #作用是让其都回到baozi = yield语句
    print("%s开始准备做包子啦!"%name)
    for i in range(5):
        time.sleep(1)
        print("做了1个包子,分两半!")
        c.send(i)
        c2.send(i)
producer("alex")

运行结果：

A 准备吃包子啦!
B 准备吃包子啦!
alex开始准备做包子啦!
做了1个包子,分两半!
包子[0]来了,被[A]吃了!
包子[0]来了,被[B]吃了!
做了1个包子,分两半!
包子[1]来了,被[A]吃了!
包子[1]来了,被[B]吃了!
做了1个包子,分两半!
包子[2]来了,被[A]吃了!
包子[2]来了,被[B]吃了!
做了1个包子,分两半!
包子[3]来了,被[A]吃了!
包子[3]来了,被[B]吃了!
做了1个包子,分两半!
包子[4]来了,被[A]吃了!
包子[4]来了,被[B]吃了!

迭代器

定义

可以直接作用于for循环的数据类型有：

1. 集合数据类型，如：List、Tuple、Dict、Set、Str等
2. generator，包括生成器和带Yield的generator function
   这种可直接作用于for循环的对象统称可迭代对象：Iterable
   可以 被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
   判断是否可迭代：

from collections import Iterable#导入
print (isinstance('abc',Iterable))#abc为判断对象
print (isinstance({
    },Iterable))
print (isinstance([],Iterable)) 

运行如下：

True
True
True

找出一个对象的所有可用操作：

a={
    }
dir(a)#a为对象

运行如下:

['__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'clear',
 'copy',
 'fromkeys',
 'get',
 'items',
 'keys',
 'pop',
 'popitem',
 'setdefault',
 'update',
 'values']

生成器都是Iterator对象，但List，Dict，Str虽然是Itearable，却不是Iterator
把List，Dict，Str等Iterable变成Itearator的方法是使用iter()函数

a=[1,2,3]
from collections import Iterator#导入
from collections import Iterable#导入
print (isinstance(a,Iterator))#判断对象是否为迭代器
b=iter(a)
print (isinstance(b,Iterator))#abc为判断对象

运行结果：

False
True

Iterator可以用以下代码抓取Iterator错误从而不使__next()__超范围报错

it=iter([1,2,3,4])
while True：
	try :
		x=next(a)
	except StopIteration:
		break#遇StopIteration退出来
	

所有的for ,in …:都是迭代器方法

内置函数

Pythoon自己本身带有的函数

更多详情，菜鸟教程

1. all(Iterable)
   如果所有可迭代对象都为真的 ，返回True，反之False

print (all([0,1,15,-5]))#0为False
print (all([3,1,15,-5]))

运行如下：

False
True

2. any()如果有可迭代对象为真的 ，返回True，反之False

print (any([0,1,15,-5]))#0为False
print(any([]))

运行如下：

True
False

3. ascii(object) 把数据对象返回一个可打印的字符串

a=ascii(["a",1,"我是谁"])
print(type(a),[a])

运行如下：

<class 'str'> ["['a', 1, '\\u6211\\u662f\\u8c01']"]
#注意双引号

4. bin(number)#十进制转二进制。

print(bin(2000))

运行如下：

0b11111010000#b是代表二进

5. bool () 判断列表，字典，元组，集合等的内容是否为空，空则False

print(bool([]))
print(bool([1,3]))

运行如图

False
True

6. bytes()，bytearray() 字节 字节数组

a=bytes("adcde",encoding="utf-8")
print('a')
print(a.capitalize(),a)
#字符串，二进字节，不可以直接更改，要应用，要放到另一个新的变量名
b=bytearray("abcde",encoding="utf-8")
print(b[1])#把b的Ascii码打印出来 
b[1]=101#把e放入到字节数组中，不可以直接b[1]=e,要赋值Ascii码
print (b)

运行如图

a
b'Adcde' b'adcde'#b是字节
98
bytearray(b'aecde')

7. callable() 是否可调用

print(callable({
    }))#集合不可调用 
def sa():
	pass
print(callable(sa))#凡是可加括号都可调用 

运行如下：

False
True

8. chr() 把数字的Ascii码转字母， ,ord ()与chr()相反

print(chr(98))
print(ord("a"))

#结果是b，97

9. classmethod() 类方法

10. compile底层字符串转源代码

code="for i in range(10):print(i)"
print(code)
c=compile(code,'',"exec")#exec把字符串转码
print(c)
exec(c)#执行C

运行如下：

for i in range(10):print(i)
<code object <module> at 0x0000002DEE2750C0, file "", line 1>
0
1
2
3
4
5
6
7
8
9

11. dict()生成字典，与直接{}一样
12. dir()查询对象用法有哪些
13. divmod(9,2)，相除并返回余数

print(divmod(9,2))

运行如下：

14. eval()，把字符串变字典
15. filter(function,iterable)从一组数据过滤你想要的值，如1-10，要1-5
    匿名函数：用完就释放

calc= lambda n:print(n)
#只可执行简单语句，for都不行，只能3圆运算，如
'''
calc= lambda n:3 if n<4 else n
#如果n<4，选3，否则是n
print(calc(2))#将打印3
print(calc(7))#将打印7
'''
calc(5)

运行如下：

res=filter(lambda n:n>5 ,range(10))
res1=map(lambda n:n*2,range(10))
import functools
#map（Function，Iterable），把迭代对像按function进行操作
res3=functools.reduce(lambda x,y:x*y,range(1,10))
#reduce() 函数会对参数序列中元素进行累积,x初值0，y为1,1加到10
for i in res: 
	print(i,"res1")
for i in res1: 
	print(i,"res1")
print(res3)

运行结果如下：

6 res1
7 res1
8 res1
9 res1
0 res1
2 res1
4 res1
6 res1
8 res1
10 res1
12 res1
14 res1
16 res1
18 res1
362880

16. frozenset()冻结
    集合可加元素，现冻结

a=frozenset(set([1,2,3,4]))
#a.add("a")#会出错
print(a)

17. globals()返回当前所有变量的keys,values
18. hash() 用于获取取一个对象（字符串或者数值等）的哈希值。

print(hash("liang"))#liang哈希值

运行如下：

19. hex()转16进制

hex(9999)

运行如下：

20. locals() 函数会以字典类型返回当前位置的全部局部变量。
    对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
21. max(),min()
22. next()
23. oct()十进转8进制
24. pow(a,b)a的b次方
25. round(i,j)保留j位i这个小数

print(round(1.234567,3))

运行如下：

26. sorted()排序

a={
    6:2,8:2,-5:6,99:6,88:99}
print(a)
print(sorted(a.items()))#按Key排
print(sorted(a.items(),key = lambda x: x[1]))
#按vaule排,x[1]为vaules，x[0]为key

运行如下：

{
    6: 2, 8: 2, -5: 6, 99: 6, 88: 99}
[(-5, 6), (6, 2), (8, 2), (88, 99), (99, 6)]
[(6, 2), (8, 2), (-5, 6), (99, 6), (88, 99)]

27. sum()
28. tuple()
29. type()
30. zip()把两个列表一一对应，zip为拉链之意

a=[1,2,3,4]
b=["a","b","c","d"]
c=zip(a,b)
for i in c:
	print(i)

运行如下：

(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')

30. import() 引入库的名称为字符串时，可以使用这个
    运行如下：
    

Json与pickle序列化

序列化：把内容从内存存到硬盘，反序列化与之相反

f=open("序列化1.txt","w")
info={
    
	"name":"liang",
	"age":18,
	"sex":"male"
	}
f.write(str(info))
f.close()
f=open("序列化1.txt","r")
data=eval(f.read())
print(data["sex"])

运行如下：

此种方法代码相对繁多，功能少，故有标准的序列化：

import json
f=open("序列化2.txt","w")
info={
    
	"name":"liang",
	"age":18,
	"sex":"male"
	}
f.write(json.dumps(info))#序列化
f.close()
f=open("序列化2.txt","r")
data=json.loads(f.read())#反序列化
print(data["sex"])

运行如下：

Json正在替换Xml这种信息交换文件，Java也认识此文件
pickle与Json是一样的，但Pickle是二进㓡文件 ，要用wb,rb，且Pickle只有在本Python语言可用

Pickle：

import pickle
f=open("序列化3.txt","wb")
info={
    
	"name":"liang",
	"age":18,
	"sex":"male"
	}
pickle.dump(info,f)#等同f.write(json.dumps(info))#序列化
f.close()
f=open("序列化3.txt","rb")
data=pickle.load(f)#等同data=json.loads(f.read())#反序列化
print(data["sex"])

运行结果：

软件开发目录结构规范

 项目名
k9/
|-- bin 存放脚本，执行文件等 
|   |-- k9 项目名
|
|-- k9/
|   |-- tests  /测试代码 
|   |   |-- __init__.py
|   |   |-- test_main.py 测试代码
|   |
|   |-- __init__.py
|   |-- main.py   主程序
|
|--  docs 文档和配置 
|   |--  conf.py 配置文件 
|   |-- abc.rst
|
|-- setup.py   安装，部署，脚本打包
|-- requirements.txt  存放依赖的外部Python包列表 
|-- README     项目说明文档 

引自科子–linux运维之路
绝对目录：

import os 
print(os.path.abspath("."))   #当前目录的绝对路径
print(os.path.abspath(r".."))  #上级目录的绝对路径
print(os.path.dirname(os.path.abspath(".")))
#找到不要当前文件名的路径,即也是文件上级目录的绝对路径
print(os.path.dirname(os.path.dirname(os.path.abspath("."))))
#比原来再退一级

运行如下；

相对目录（编软件用）：加入到系统中

import os ,sys
Base_path=os.path.dirname(os.path.abspath("."))
sys.path.append(Base_path)
from conf import settings#不同目录间进行模块调用
from core import main
main.loggin()

路径文件如下：

Settings.py无代码
main.py如图:

运行如下：

作业：