No.14

今日概要

• 带参数的装饰器：flask框架 + Dijango缓存 + 写装饰器实现被装饰的函数要执行N次
• 模块
  • os
  • sys
  • time（三种类型）
  • datetime 和 timezone（了解）

内容回顾和补充

1.函数

写代码的方式：面向过程 → 函数式编程 → 面向对象

1.1函数基础

def fun(a,b):
    pass
result = func(1,2)

1.2参数

补充：对于函数默认值慎用可变类型。

#如果想要给value设置默认空列表
#不推荐
def func(data,value=[]):
    pass
#推荐
def func(data,value=None):
    if not value:
        value = []

def func(data,value=[]):
    value.append(data)
    return value
    
v1 = func(1)  # [1]
v2 = func(2)  # [1,2]默认列表的指向未变
v3 = func(1,[11,22,33]) # [11,22,33,1]
#参数设定了默认值后，就开辟了内存对默认数据存储，永远不会变。

面试题

• def func(a,b=[]) 有什么陷阱？

• 看代码写结果

  def func(a,b=[]):
      b.append(a)
      return b
  l1 = func(1)
  l2 = func(2,[11,22])
  l3 = func(3)
  print(l1,l2,l3)

  def func(a,b=[]):
      b.append(a)
      print(b)
  
  func(1)
  func(2,[11,22,33])
  func(3)

1.3返回值

分析函数执行的内存

def func(name):
    def inner():
        print(name)
        return 123
    return inner
v1 = func('alex')
v2 = func('eric')
v1()
v2()

闭包

#不是闭包
def func(arg):
    def inner():
        return 666
    return inner
#是闭包：封装值 + 内层函数需要使用
def func(arg):
    def inner():
        print(arg)
        return 666
    return inner

1.4作用域

1.5递归

函数自己调自己（效率低，内存消耗大）

def func():
    print(1)
    func()    
func()

def func(i):
    print(i)
    func(i+1)
func(1)

def func(a,b):
    # 1
    # 1
    # 2
    # 3
    # 5
    print(b)
    func(b,a+b)   
func(0,1)

def func(a):
    if a == 5:
        return 100000
    result = func(a+1) + 10
    return result
v = func(1)

2.模块

• hashlib 不常用
• random 不常用
• getpass 不常用
• time 常用

内容详细

1.装饰器

1.1基本格式

def x(func):
    def inner():
        return func()
    return inner
@x
def index():
    pass

1.2关于参数

def x(func):
    def inner(a1):
        return func(a1)
    return inner
@x
def index(a1):
    pass

def x(func):
    def inner(a1,a2):
        return func(a1,a2)
    return inner
@x
def index(a1,a2):
    pass
# func = 原来的index
# index = inner
index(1,2)
# 参数统一的目的是为了给原来的index函数传参

给多个函数写一个统一的装饰器

def x(func):
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner
@x
def f1():
    pass
@x
def f2(a1):
    pass
@x
def f3(a1,a2):
    pass    

1.3关于返回值

def x(func):
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner
@x
def f1():
    print(123)
    
v1 = f1()  # 此时的f1是inner，inner返回值是None。

def x(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return 666
    return inner
@x
def f1():
    print(123)
    
v1 = f1()

def x(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
    return inner
@x
def f1():
    print(123)
    return 666
    
v1 = f1()

装饰器建议写法：

def x(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return data
    return inner

1.4关于前后

def x(func):
    def inner(*args,**kwargs):
        print('调用原函数前')
        data = func(*args,**kwargs) # 执行原函数并获取返回值。
        print('调用原函数后')
    return inner
@x
def index():
    print(123)
    
index()

1.5带参数的装饰器

#第一步：执行x(index)       
#第二步：将返回值赋值给index
@x
def index()
    pass

#第一步：执行 v1 = y(9) 执行函数y(9)得到返回值v1，v1需要是个函数名
#第二步：@v1 → return = v1(index) 执行v1(index)函数
#第三步：index = return 把执行v1(index)函数的返回值给index
@y(9)
def index()v1
    pass

#普通装饰器
def x(func):
    def inner(*args,**kwargs):
        print('调用原函数前')
        data = func(*args,**kwargs) # 执行原函数并获取返回值。
        print('调用原函数后')
    return inner
@x
def index():
    pass

#带参数装饰器
def y(counter):
    def x(func):
        def inner(*args,**kwargs):
            print('调用原函数前')
            data = func(*args,**kwargs) # 执行原函数并获取返回值。
            print('调用原函数后')
            retutn inner
        return inner
    return x
@y(9) #等价于@x
def index():
    pass

上述又套一层意义何在？

#写一个带参数的装饰器，实现参数是多少被装饰的函数就要执行多少次，把每次结果添加到列表中，并返回最终列表。
def y(counter):
    #print('语法调用执行y')
    def x(func):
        #print('语法调用执行x')
        def inner(*args,**kwargs):
            lst = []
            for i in range(counter):
                result = func(*args,**kwargs)
                lst.append(data)
            return lst
        return inner
    return x
#@y → index = y(9)(index)
@y(5) # 这个语法会先执行y函数形成闭包保存参数，再执行x函数形成闭包保存原index函数。此时的index=inner函数。
def index():
    return 8

v = index()
print(v)

#有1000个函数，其中990个添加功能1，10个添加功能2，用1个装饰器实现。
def y(counter):
    def x(func):
        def inner(*args,**kwargs):
            if counter:
                print('添加功能1')
                data = func(*args,**kwargs)
                return data
            print('添加功能2')
            return func(*args,**kwargs)
        return inner
    return x

@y(True)
def func990():
    return 990
@y(False)
def func10():
    return 10

v1 = func990()
print(v1)
v2 = func10()
print(v2)

1.6总结

基本装饰器 ▲▲▲

def x(func):
    def inner(*args,**kwargs):
        data = func(*args,**kwargs)
        return data
    return inner
@x
def inndex():
    print(123)
   
index()

带参数的装饰器 ▲

def y(a):
    def x(func):
        def inner(*args,**kwargs):
            data = func(*args,**kwargs)
            return data
        return inner
    return x
@y(9)
def index():
    pass

index()

2.模块

2.1sys

Python解释器相关的数据

• sys.getrefcount
• sys.getrecursionlimit
• sys.stdout.write → print
  • \r 回到当前行起始位置 → 进度条

#获取一个值的引用计数
import sys
a = [1,2,3]
b =a
print(sys.getrefcount(a))

#获取Python默认支持的递归数量
v = sys.getrecursionlimit()
print(v)

#输出 → 默认不换行，print()内部会调用它
sys.stdout.write('中国')
sys.stdout.write('加油')

补充：\r 回到当前行起始位置

print('123\r',end='')
print('你好',end='')
#进度条
import time
for i in range(1,101):
    msg = '%s%%\r'%i
    print(msg,end='')  #print()第二个参数默认\n
    time.sleep(0.05)

import os
data = os.stat('文件路径')  #读取文件所有相关属性
total_size = data.st_size  #读取文件总字节大小

read_size = 0
with open('文件路径', mode='rb') as f1, open('新文件路径', mode='wb') as f2:
    while read_size < total_size:
        data = f1.read(1024)  #每次最多读1024个字节
        f2.write(data)        #把读取的字节写入新文件
        read_size += len(data)
        val = int(read_size / total_size * 100)
        print('%s%%\r'%val,end='')  #显示读取的进度条

• sys.argv ▲

'''
模块传参：
让用户执行脚本并传入要删除文件的路径，在脚本内部帮助用户将目录删除。
执行脚本时最后传入参数：解释器路径 脚本路径 要删除文件路径
'''
#脚本其实就是一个.py文件，也就是模块。
#解释器执行.py文件：解释器路径+脚本路径+参数

脚本内容：
import sys            #获取用户执行脚本时传入的参数
path = sys.argv[1]    #sys.argv = ['脚本路径', '要删除文件路径']

import shutil             
shutil.rmtree(path)    #删除文件

2.2os

操作系统相关的数据

• os.path.exists(path) ▲ 如果文件地址存在返回True，不存在返回False。

• os.stat(path).st_size 获取文件字节大小

• os.path.abspath() 获取文件绝对路径

  #获取绝对路径
  path = '文件操作练习.txt'   
  import os
  v = os.path.abspath(path)
  print(v)
  #结果：D:\Py_Learn\文件操作练习.txt

• os.path.dirname(path) ▲ 获取文件的上级目录

  import os
  v = r'D:\Py_Learn\文件操作练习.txt'
  print(os.path.dirname(v))
  #结果：D:\Py_Learn

• os.path.join ▲ 路径的拼接

  import os
  path = 'D:\录制视频\行情分析'
  path2 = '文件操作练习.txt'
  
  result = os.path.join(path,path2,'n1','n2','n3')
  print(result)

• os.listdir 面试题

  • 查看一个目录下的文件(第一层)

    #查看一个目录下所有文件，只有一层。
    import os
    result = os.listdir('D:\录制视频')
    print(result)

• os.walk 面试题

  • 查看一个目录下的所有文件(所有层)

    import os
    result = os.walk('D:\录制视频')
    for a,b,c in result:
        # a:正在查看的目录 b:此目录下的文件夹 c:此目录下的文件
        # print(a,b,c)
        for item in c:
            path = os.path.join(a,item)
            print(path)

2.3shutil

• shutil.rmtree(path)

  #强制删除，无论权限。
  import shutil
  shutil.rmtree('要删除文件路径')

3.补充

• 转义符 r

  v1 = r'D:\录制视频\行情分析\2019.3.31.mp4'
  print(v1)
  v2 = 'D:\\录制视频\\行情分析\\2019.3.31.mp4'
  print(v2)

总结

• 普通装饰器 ▲▲▲
  • 参数
  • 返回值
  • 前后
• 带参数装饰器 ▲
• 模块
  • random
  • hashlib
  • getpass
  • time ▲
  • os ▲
  • sys
  • shutil

原文：https://www.cnblogs.com/elliottwave/p/12521830.html