zoukankan      html  css  js  c++  java
  • Python基础(十五)

    今日主要内容

    • 模块初识
      • 模块导入
      • 模块路径
      • 自定义模块
    • 内置模块(标准库)
      • time
      • datetime
      • random
      • sys
      • os
      • funtools

    一、模块初识

    (一)什么是模块

    • 其实我们创建的每一个py文件就是一个模块,模块是将不同功能的函数进行归类,划分,封装的集合体
    • 模块分类:
      • 内置模块(标准库)
      • 第三方模块(第三方库)
      • 自定义模块
    • 模块的特点:拿来主义
      • 开发效率高,没有必要了解其中原理
      • 减少重复代码
      • 分文件管理,有助于修改和维护

    (二)模块导入

    1. 导入模块关键字:import

    2. 模块只有在第一次导入才会执行,为了防止重复导入,python在第一次导入后就将模块名加载到内存,再次导入只是对加载到内存中的模块对象增加了一次引用,不会重复执行模块内的语句

      # text.py文件
      print("这是text.py文件中的语句")
      def func():
      	print("这是text.py文件中的函数")
      
      # target.py文件
      import text
      import text
      import text
      
      运行结果:
      这是text.py文件中的语句  # 只运行一次
      
    3. 第一次导入时发生的三件事:

      • 为源文件(被导入模块)创建新的名称空间,在被导入模块中定义的函数或者方法使用了global访问的就是这个名称空间
      • 在新创建的名称空间中执行模块中包含的代码
      • 创建同名的模块名来引用该名称空间
    4. 模块导入时的查找顺序

      • 内存 > 内置 > sys.path
      • 说明:解释器运行的时候,会将一部分常用的模块加载到内存,在我们导入模块的时候解释器会查找此模块是否已被加载到内存中,如果没有就去查找内置库中有无此模块,如果还没有最后查找sys.path中的路径中是否包含此模块,进行导入,如果还没有,解释器就会报错
      • 可以通过手动添加将模块的路径添加到sys.path中,sys.path返回的是一个列表,可以使用append()方法添加,供解释器搜索
      from sys import path
      path.append(r"C:Users11582Desktop")
      
      from text import ceshi
      ceshi()
      
    5. 模块导入的方法:

      • import XXX:将模块全部导入
      • from XXX import XXX:导入指定模块功能
      • 在后面使用as,两者都可给导入的模块或功能重新命名
      import time as a
      from time import sleep as s
      
      • 说明:

        • 使用import导入时可以一行导入多个模块,但不建议,建议每使用一个import只导入一个模块
        import time
        import random
        import sys
        
        • 使用from可以一行导入多个功能,导入的功能在使用时会将之前定义同名的变量覆盖掉
        def time():
        	print("123")
        	
        from time import time
        time()
        
        运行结果:
        123
        
        • from XXX import *:导入模块内全部功能,可以通过__all__限制导入的功能
        # 被导入文件:zxd.py
        def name():
        	print("zxd")
        	
        def age():
        	print("age")
        	
        __all__ = ["name"]
        
        # 运行文件:target.py
        from zxd import *
        
        age()
        
        运行结果:
        NameError: name 'age' is not defined
        
    6. 模块的两种用法

      • 当作普通模块执行
      • 当作脚本执行
    7. 如何使用模块中的功能

      • 万能的.
      • 如果利用import导入整个模块,使用时要利用模块名.功能
      import time 
      
      t = time.time()
      
      • 如果使用from,则可以直接使用该功能,注意这样会覆盖之前定义的功能
      def time():
      	print("123")
      	
      from time import time
      time()
      
      运行结果:
      123
      
    8. 避免循环导入模块

      • 三个模块,模块1导入模块2,模块2导入模块3,模块3导入模块1(避免

    (三)自定义模块

    • 注意:自定义模块时千万不要定义与内置模块相同的模块名

    • 自己创建的py文件就是一个自定义模块

      # zxd.py  # 自定义模块
      def name():
      	print("zxd")
      	
      def age():
      	print("age")
      
      # target.py
      import zxd
      
      zxd.name()
      zxd.age()
      
      运行结果:
      zxd
      23
      
      
    • 定义模块私有部分(无法通过导入使用)

      if __name__ == "__main__":
      	"""私有部分"""
      
      
      • 原理:如果__name__在本文件运行返回的是__main__,如果被导入返回的是被导入的文件名。
      # zxd.py文件
      print(__name__)
      if __name__ == "__main__":
      	"""私有部分"""
      
      运行结果:
      __main__
      
      
      # zxd.py文件
      print(__name__)
      if __name__ == "__main__":
      	"""私有部分"""
      
      # target.py文件
      import zxd
      
      print(__name__)
      
      运行结果:
      zxd
      __main__
      
      

    二、内置模块(标准库)

    (一)time模块

    1. time模块在python中是和时间相关的模块,python中的时间分为三种形式:

      • 时间戳:从1970-01-01 00:00:00到现在一共经历了多少秒,用float表示

      • 结构化时间:以元组的形式,以固定结构输出时间

        • 固定结构:年,月,日,时,分,秒,一年中第几周,一年中第几天,是否是夏令时(1是夏令时;0是非夏令时,-1表示不确定是否是夏令时)
        time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=-1)
        
        
      • 格式化时间:根据我们的需要对时间任意格式化

        • 格式化标准:
        %y 两位数的年份表示(00-99)
        %Y(常用) 四位数的年份表示(000-9999)
        %m(常用) 月份(01-12)
        %d(常用) 月内中的一天(0-31)
        %H(常用) 24小时制小时数(0-23)
        %I 12小时制小时数(01-12)
        %M(常用) 分钟数(00=59)
        %S(常用) 秒(00-59)
        %a 本地简化星期名称
        %A 本地完整星期名称
        %b 本地简化的月份名称
        %B 本地完整的月份名称
        %c 本地相应的日期表示和时间表示
        %j 年内的一天(001-366)
        %p 本地A.M.或P.M.的等价符
        %U 一年中的星期数(00-53)星期天为星期的开始
        %w 星期(0-6),星期天为星期的开始
        %W 一年中的星期数(00-53)星期一为星期的开始
        %x 本地相应的日期表示
        %X 本地相应的时间表示
        %Z 当前时区的名称
        %% %号本身
    2. time模块部分方法介绍:

      time.time() 获取当前时间戳
      time.sleep() 睡眠(延时)
      time.localtime() 将时间戳转换为结构化时间
      time.mktime() 将结构化时间转换为时间戳
      time.strftime() 将结构化时间转换为格式化时间
      time.strptime() 将格式化时间转换为结构化时间
      • time.time()

        • 函数定义:time()
        • 函数说明:获取当前时间戳,距离1970-01-01 00:00:00到现在经过的时间,单位是秒,结果为浮点型
        import time
        
        print(time.time())
        
        运行结果:
        1569505356.1715019
        
        
      • time.sleep()

        • 函数定义:sleep(seconds)
        • 函数说明:参数为秒,将执行延时数秒,可以是亚秒级别的浮点数
        import time
        
        print(1)
        time.sleep(10)
        print(2)
        
        运行结果:
        1
        2  # 相隔10S 
        
        
      • time.localtime()

        • 函数定义:localtime([seconds])
        • 函数返回:(tm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)
        • 函数说明:参数为时间戳,将时间戳转换为表示本地时间的时间元组,当seconds没有传入时,转换当前的时间戳
        import time
        
        print(time.localtime())
        
        运行结果:
        time.struct_time(tm_year=2019, tm_mon=9, tm_mday=26, tm_hour=22, tm_min=2, tm_sec=38, tm_wday=3, tm_yday=269, tm_isdst=0)
        
        
        • 返回值取值:

          • 返回值可以通过索引取值
          import time
          
          print(time.localtime()[0])
          
          运行结果:
          2019
          
          
          • 返回值可以通过关键字取值
          import time
          
          print(time.localtime().tm_year)
          
          运行结果:
          2019
          
          
      • time.mktime()

        • 函数定义:mktime(p_tuple)
        • 函数说明:参数为结构化时间元组,将结构化时间元组转换为时间戳
        import time
        
        t = time.localtime()
        print(time.mktime(t))
        
        运行结果:
        1569506956.0
        
        
      • time.strftime()

        • 函数定义:strftime(format, p_tuple=None)
        • 函数说明:第一个参数为格式化规范,第二个参数为结构化时间元组,将结构化时间元组转换为字符串,若时间元组不存在时,使用localtime()当前时间返回字符串
        import time
        
        t = time.localtime()
        print(time.strftime("%Y-%m-%d %H:%M:%S", t))
        
        运行结果:
        2019-09-26 22:19:30
        
        
      • time.strptime()

        • 函数定义:strptime(string, format)
        • 函数说明:第一个参数为时间字符串,第二个参数为格式化规范,根据格式化规范将字符串解析成时间元组
        import time
        
        print(time.strptime("2019-09-26 22:19:30", "%Y-%m-%d %H:%M:%S"))
        
        运行结果:
        time.struct_time(tm_year=2019, tm_mon=9, tm_mday=26, tm_hour=22, tm_min=19, tm_sec=30, tm_wday=3, tm_yday=269, tm_isdst=-1)
        
        
    • 计算时间差

      import time
      
      time_msg = input("请输入时间:")
      def time_difference(args):
          tid = time.time() - time.mktime(time.strptime(args, "%Y-%m-%d %H:%M:%S"))
          return time.localtime(tid)
      
      t = time_difference(time_msg)
      print(f"过去了{t.tm_year-1970}年{t.tm_mon-1}月{t.tm_mday-1}天{t.tm_hour}小时{t.tm_min}分{t.tm_sec}秒")
      
      运行结果:
      请输入时间:2019-01-01 00:00:00
      过去了0年8月26天6小时39分17秒
      
      

    (二)datetime模块

    • datetime模块也是一个时间模块,功能较time模块更强一些
    1. datatime模块中的datatime类部分方法介绍:

      datetime() 获取指定时间
      datetime.now() 获取当前时间
      datetime.timestamp() 将时间对象转换为时间戳
      datetime.fromtimestamp() 将时间戳转换为时间对象
      datetime.strftime() 将时间对象转换为字符串
      datetime.strptime() 将字符串转换为时间对象
      • datetime()

        • 函数定义:datetime(year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ..., *, fold: int = ...)
        • 函数说明:传入年,月,日,时,分,秒,微秒,时区,fold(不明参数,3.6加入),返回一个时间对象
        from datetime import datetime
        
        print(datetime(2019,9,27))
        print(type(datetime(2019,9,27)))
        
        运行结果:
        2019-09-27 00:00:00
        <class 'datetime.datetime'>  # 对象类型
        
        
      • datetime.now()

        • 函数定义:now(tz=None)
        • 函数说明:参数为时区,通过datetime对象创建一个时间对象,可以选择时区信息
        from datetime import datetime
        
        print(datetime.now())
        print(type(datetime.now()))
        
        运行结果:
        2019-09-27 14:06:10.948891
        <class 'datetime.datetime'>
        
        
      • datetime.timestamp()

        • 函数定义:timestamp(obj)
        • 函数说明:参数为时间对象,将时间对象转换为时间戳
        from datetime import datetime
        
        print(datetime.timestamp(datetime.now()))
        print(type(datetime.timestamp(datetime.now())))
        
        运行结果:
        1569565460.237563
        <class 'float'>
        
        
      • datetime.fromtimestamp()

        • 函数定义:fromtimestamp(t, tz=None)
        • 函数说明:第一个参数为时间戳,第二个参数为时区,将传入的时间戳转换为时间对象
        from datetime import datetime
        
        print(datetime.fromtimestamp(0))
        print(type(datetime.fromtimestamp(0)))
        
        运行结果:
        1970-01-01 08:00:00
        <class 'datetime.datetime'>
        
        
      • datetime.strftime()

        • 函数定义:strftime(obj, format)
        • 函数说明:第一个参数为时间对象,第二个参数为格式化规范,按照格式化规范将时间对象转换为字符串
        from datetime import datetime
        
        print(datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S"))
        print(type(datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")))
        
        运行结果:
        2019-09-27 14:35:37
        <class 'str'>
        
        
      • datetime.strptime()

        • 函数定义:strptime(date_string, format)
        • 函数说明:第一个参数为时间字符串,第二个参数为格式化规范,将时间字符串按照格式化规范解析成时间对象
        from datetime import datetime
        
        print(datetime.strptime("2019-09-27 14:35:37", "%Y-%m-%d %H:%M:%S"))
        print(type(datetime.strptime("2019-09-27 14:35:37", "%Y-%m-%d %H:%M:%S")))
        
        运行结果:
        2019-09-27 14:35:37
        <class 'datetime.datetime'>
        
        
    2. datatime模块中的timedelta类部分方法介绍:

      • timedelta()

        • 函数定义:timedelta(days: float = ..., seconds: float = ..., microseconds: float = ..., milliseconds: float = ..., minutes: float = ..., hours: float = ..., weeks: float = ..., *, fold: int = ...)
        • 函数说明:函数用于对时间对象的增减,填入对应关键字参数为时间变化的数值
        from datetime import datetime, timedelta
        
        print(datetime(2019, 1, 2))
        print(datetime(2019, 1, 2) - timedelta(days=1))
        
        运行结果:
        2019-01-02 00:00:00
        2019-01-01 00:00:00
        
        

    (三)random模块

    • random是一个随机模块,任何随机的情况都需要随机模块协助完成
    1. random模块部分方法介绍:

      random.random() 随机生成0~1之间的小数
      random.randint() 随机生成数字
      random.randrange() 随机生成数字(可以设定步长)
      random.choice() 从一个可迭代对象中随机获取一个元素
      random.choices() 从一个可迭代对象中随机获取多个元素,会有重复
      random.sample() 从一个可迭代对象中随机获取多个元素,不会有重复
      rendom.shuffle() 随机打乱顺序
      • random.random()

        • 函数定义:random()
        • 函数说明:产生0到1之间的随机小数
        import random
        
        print(random.random())
        
        运行结果:
        0.8988729646775544
        
        
      • random.randint()

        • 函数定义:randint(a, b)
        • 函数说明:产生a到b之间的随机数
        import random
        
        print(random.randint(1, 10))
        
        运行结果:
        9
        
        
      • random.randrange()

        • 函数定义:randrange(start, stop=None, step=1, _int=int)
        • 函数说明:从起始到结束的范围内产生一个随机数,可以设定步长,若不填入结束位置则默认从0开始,若不填步长,默认为1
        import random
        
        print(random.randrange(5))  # 从0到5随机生成
        print(random.randrange(1, 10))  # 从1到10随机生成
        print(random.randrange(1, 10, 2))  # 从1到10
        
        运行结果:
        4
        3
        9
        
        
      • random.choice()

        • 函数定义:choice(seq)
        • 函数说明:从非空序列中随机选择一个元素
        import random
        
        print(random.choice(["a", "b", "c"])
        
        运行结果:
        b
        
        
      • random.choices()

        • 函数定义:choices(population, weights=None, *, cum_weights=None, k=1)
        • 函数说明:从非空序列中随机选择k个元素,会有重复选择的情况,以列表的形式返回
        import random
        
        print(random.choices(["a", "b", "c"], k=3))
        
        运行结果:
        ['b', 'b', 'a']
        
        
      • random.sample()

        • 函数定义:sample(population, k)
        • 函数说明:随机从非空序列中选择k个元素,不会重复选择,以列表的形式返回
        import random
        
        print(random.sample(["a", "b", "c"], k=3))
        
        运行结果:
        ['c', 'b', 'a']
        
        
      • rendom.shuffle()

        • 函数定义:shuffle(x, random=None)
        • 函数说明:将参数重新洗牌,结果返回None
        import random
        
        lst = [1, 2, 3, 4, 5]
        random.shuffle(lst)
        print(lst)
        
        运行结果:
        [2, 3, 5, 4, 1]
        
        

    (四)os模块

    • os模块中的内容全部与操作系统有关
    1. os模块部分方法介绍:

      os.makedirs('dirname1/dirname2') 递归创建目录**
      os.removedirs('dirname1') 递归删除目录
      os.mkdir('dirname') 生成单级目录;相当于shell中mkdir dirname
      os.rmdir('dirname') 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
      os.listdir(path) 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
      os.remove() 删除一个文件
      os.rename("oldname","newname") 重命名文件/目录
      os.stat('path/filename') 获取文件/目录信息
      os.system("bash command") 运行shell命令,直接显示
      os.popen("bash command").read() 运行shell命令,获取执行结果
      os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
      os.chdir("dirname") 改变当前脚本工作目录;相当于shell下cd
      os.path.abspath(path) 返回path规范化的绝对路径
      os.path.split(path) 将path分割成目录和文件名二元组返回
      os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
      os.path.basename(path) 返回path最后的文件名。如何path以/或结尾,那么就会返回空值。即os.path.split(path)的第二个元素
      os.path.exists(path) 如果path存在,返回True;如果path不存在,返回False
      os.path.isabs(path) 如果path是绝对路径,返回True
      os.path.isfile(path) 如果path是一个存在的文件,返回True。否则返回False
      os.path.isdir(path) 如果path是一个存在的目录,则返回True。否则返回False
      os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
      os.path.getatime(path) 返回path所指向的文件或者目录的最后访问时间
      os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
      os.path.getsize(path) 返回path的大小
      • 重点介绍常用15个方法

      • os.makedirs('dirname1/dirname2')

        • 函数定义:makedirs(dirname)
        • 函数说明:递归创建文件夹
        import os
        
        os.makedirs("dir1/dir2/dir3")  # 在当前目录递归创建文件夹
        
        运行结果:
        # 创建三层文件夹
        ◥dir1
        	◥dir2
            	◥dir3
        
        
      • os.removedirs('dirname1')

        • 函数定义:removedirs(dirname)
        • 函数说明:若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
        import os
        
        os.removedirs("dir1/dir2/dir3")
        
        运行结果:
        # 先判断dir3目录是否为空,若为空则删除,再一次向上判断,递归删除文件夹
        
        
      • os.mkdir('dirname')

        • 函数定义:mkdir(dirname)
        • 函数说明:创建单级目录
        import os
        
        os.mkdir("dir1")
        
        运行结果:
        # 创建dir1文件夹
        
        
      • os.rmdir('dirname')

        • 函数定义:rmdir(dirname)
        • 函数说明:删除单级目录,若目录不存在或不为空报错
        import os
        
        os.rmdir("dir1")
        
        运行结果:
        # 若dir1为空,删除dir1文件夹
        
        
      • os.listdir(path)

        • 函数定义:listdir(path)
        • 函数说明:返回该路径下的所有文件夹和文件,以列表的形式
        import os
        
        print(os.listdir("D:dir"))
        
        运行结果:
        ['dir1', 'dir2', 'dir3']
        
        
      • os.remove()

        • 函数定义:remove(filename)
        • 函数说明:删除文件
        import os
        
        os.remove("text.py")
        
        运行结果:
        # 直接删除"text.py"文件
        
        
      • os.rename("oldname","newname")

        • 函数定义:rename(oldname, newname)
        • 函数说明:重命名,第一个参数为旧文件名,第二个参数为新文件名
        import os
        
        os.rename("text1.py", "text2.py")
        
        运行结果:
        # 将文件名"text1.py"改为"text2.py"
        
        
      • os.getcwd()

        • 函数定义:getcwd(*args, **kwargs)
        • 函数说明:返回当前文件的工作路径,以Unicode字符串的形式(若被当作模块导入,则返回的是导入文件的工作路径)
        import os
        
        print(os.getcwd("text.py"))
        
        运行结果:
        D:	ext.py
        
        
      • os.path.abspath(path)

        • 函数定义:abspath(path)
        • 函数说明:返回当文件的绝对路径
        import os
        
        print(os.path.abspath("text.py"))
        
        运行结果:
        D:	ext.py
        
        
      • os.path.dirname(path)

        • 函数定义:dirname(path)
        • 函数说明:返回文件的目录
        import os
        
        path = r"D:dirdir1
        ame.py"
        print(os.path.dirname(path))
        
        运行结果:
        D:dirdir1
        
        
      • os.path.basename(path)

        • 函数定义:basename(path)
        • 函数说明:返回文件名
        import os
        
        path = r"D:dirdir1
        ame.py"
        print(os.path.basename(path))
        
        运行结果:
        name.py
        
        
      • os.path.isfile(path)

        • 函数定义:isfile(path)
        • 函数说明:判断路径是否是一个文件
        import os
        
        path = r"D:dirdir1
        ame.py"
        print(os.path.isfile(path))
        
        运行结果:
        True
        
        
      • os.path.isdir(path)

        • 函数定义:isdir(path)
        • 函数说明:判断路径是否是一个文件夹
        import os
        
        path = r"D:dirdir1"
        print(os.path.isdir(path))
        
        运行结果:
        True
        
        
      • os.path.join(path1[, path2[, ...]])

        • 函数定义:join(path, *paths)
        • 函数说明:将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
        import os
        
        path = r"D:dir"
        print(os.path.join(path, "dir1", "text.py"))
        print(os.path.join("text.py", path, "dir1", "text.py"))
        
        运行结果:
        D:dirdir1	ext.py
        D:dirdir1	ext.py
        
        
      • os.path.getsize(path)

        • 函数定义:getsize(filename)
        • 函数说明:返回文件的大小
        import os
        
        path = r"D:dirdir1
        ame.py"
        print(os.path.getsize(path))
        
        运行结果:
        7971
        
        

    (五)sys模块

    • sys模块是与python解释器交互的一个接口
    1. sys模块部分方法介绍:

      sys.argv 命令行参数List,第一个元素是程序本身路径
      sys.exit(n) 退出程序,正常退出时exit(0),错误退出sys.exit(1)
      sys.version 获取Python解释程序的版本信息
      sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
      sys.platform 返回操作系统平台名称
      sys.modules 获取所有的模块
      • sys.path

        • 方法说明:返回模块的搜索路径,以列表的形式,需要导入自定义模块时,向sys.path中添加路径
        import sys
        
        print(sys.path)
        
        运行结果:
        ['D:\python_S26\day15', 'D:\python_S26', 'D:\Software\Pycharm\pycharm\PyCharm 2019.2.1\helpers\pycharm_display', 'C:\Python3.6.8\python36.zip', 'C:\Python3.6.8\DLLs', 'C:\Python3.6.8\lib', 'C:\Python3.6.8', 'C:\Python3.6.8\lib\site-packages', 'D:\Software\Pycharm\pycharm\PyCharm 2019.2.1\helpers\pycharm_matplotlib_backend']
        
        

    (六)functools模块

    • funtools模块针对于一些函数的操作
    1. 之前介绍过的reduce()函数,用于累计算

      from functools import reduce
      
      print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5]))
      print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5], 5))
      print(reduce(lambda x, y: x * y, [], 5))
      
      运行结果:
      120
      600
      5
      
      
    2. wraps

      • 用于修改装饰器内层函数的函数名

      • 我们在执行被装饰器装饰过的函数时,其实真正执行的是装饰器内部的inner函数,我们通过__name__方法可查看函数调用真正调用的函数名

        def wrapper(fn):
        	def inner(*args, **kwargs):
        		print("扩展内容")
        		ret = fn(*args, **kwargs)
        		print("扩展内容")
        		return ret
        	return inner
        	
        @wrapper
        def target_func():
        	print("目标函数")
        
        print(target_func.__name__)
        
        运行结果:
        inner
        
        
      • 但对于调用方而言,会对函数产生疑问,所以使用warps可以修改内层inner函数的函数名

        from functools import wraps
        
        def wrapper(fn):
        	@wraps(fn)  # 装饰内层函数
        	def inner(*args, **kwargs):
        		print("扩展内容")
        		ret = fn(*args, **kwargs)
        		print("扩展内容")
        		return ret
        	return inner
        	
        @wrapper
        def target_func():
        	print("目标函数")
        
        print(target_func.__name__)
        
        运行结果:
        target_func
        
        
  • 相关阅读:
    C# 在RichTextBox根据内容自动调整高度
    C# TabControl 隐藏标签头(TabControl Hide Head)
    SQL Server Profiler的简单使用
    Entity Framework Code First 在Object Join Linq查询时出现全表查询的语句。
    传统if 从句子——以条件表达式作为if条件
    正向行为方法---解决问题
    Shell的特殊字符
    精进:如何成为一个很厉害的人---思维导图
    Linux下用于查看系统当前登录用户信息的4种方法
    有用户及目录判断的删除文件内容的Shell脚本
  • 原文地址:https://www.cnblogs.com/tianlangdada/p/11621367.html
Copyright © 2011-2022 走看看