Python之第二十一天的努力--模块1

标签：class   imp   右键   找不到   ret   har   本质   解释器   固定   

01内容回顾与练习

1. 装饰器：完美的呈现了开放封闭原则。装饰器的本质：闭包。

2. def wrapper(f):
       def inner(*args,**kwargs):
           ‘‘‘执行被装饰函数之前的操作‘‘‘
           ret = f(*args,**kwargs)
           ‘‘‘执行被装饰函数之后的操作‘‘‘
           return ret
       return inner
   

3. def wrapper(f):
       def inner(*args,**kwargs):
           print(111)
           ret = f(*args,**kwargs)
           print(222)
           return ret
       return inner
   
   @wrapper        # func = wrapper(func)
   def func():
       print(‘in func‘)
   func()
   
   # 111
   # in func
   # 222
   

4. 练习：

   • # 2.编写装饰器,在每次执行被装饰函数之前打印一句
     # ’每次执行被装饰函数之前都得先经过这里,这里根据需求添加代码’。
     def wrapper(f):
         def inner(*args,**kwargs):
             print(‘每次执行被装饰函数之前都得先经过这里,这里根据需求添加代码‘)
             ret = f(*args,**kwargs)
             return ret
         return inner
     

   • # 3.为函数写一个装饰器，把函数的返回值 +100 然后再返回。
     #
     
     def wrapper(f):
         def inner(*args,**kwargs):
     
             ret = f(*args,**kwargs)
     
             return ret + 100
         return inner
     
     @wrapper
     def func():
         return 7
     
     result = func()
     print(result)
     

   • # 4.请实现一个装饰器，通过一次调用是函数重复执行5次。
     
     def wrapper(f):
         def inner(*args,**kwargs):
             for i in range(5):
                 ret = f(*args,**kwargs)
             return ret
         return inner
     
     @wrapper        # func = wrapper(func)
     def func():
         print(‘in func‘)
     func()
     

   • # 5.请实现一个装饰器，每次调用函数时，将函数名以及调用此函数的时间节点写入文件中。
     #
     # 可用代码：
     # import time
     # struct_time = time.localtime()
     # print(time.strftime("%Y-%m-%d %H:%M:%S",struct_time)) # 当前时间节点
     # #
     # def wrapper():
     #     pass
     # def func1(f):
     #     print(f.__name__)
     # func1(wrapper)
     # 函数名通过： 函数名.__name__获取。
     
     import time
     
     
     def wrapper(f):
         def inner(*args,**kwargs):
             with open(‘log‘,encoding=‘utf-8‘,mode=‘a‘) as f1:
                 struct_time = time.localtime()
                 f1.write(f‘北京时间：{time.strftime("%Y-%m-%d %H:%M:%S",struct_time)}执行了{f.__name__}函数\n‘)
             ret = f(*args,**kwargs)
     
             return ret
         return inner
     
     @wrapper
     def nb():
         print(‘in nb‘)
     
     nb()
     time.sleep(2)
     nb()
     time.sleep(1)
     nb()
     

02 模块1

1. 自定义模块

   1. 什么是模块：本质就是 .py文件，封装语句的最小单位。

   2. 自定义模块：实际上就是定义：.py

      • 其中可以包括：变量定义，可执行语句，for循环，函数定义等...他们统称为模块的成员

      • ‘‘‘
        
        自定义模块
        模块中出现的变量：for循环，if结构，函数定义..... 称为模块的成员。
        
        ‘‘‘
        
        # 可执行语句
        a = 1
        print(a)
        
        for x in range(3):
            print(x)
        
        
        # 函数定义
        def f():
            print(‘hello world‘)
        
        f()
        

2. 模块的运行方式

   1. 脚本方式：直接用解释器执行。或者Pycharm中右键运行。
   2. 模块方式：被其他的模块导入。为导入他的模块提供资源（变量，函数定义，类定义等等...）。

3. __name__属性的使用

   1. 在脚本方式运行时，__name__是固定的字符串：__main__

   2. 在以模块方式被导入时，__name__就是本模块的名字。

   3. # 定义一个函数，包含测试语句
      def main():
          print(a)
          for x in range(3):
              print(x)
      
          f()
      
      
      if __name__ == ‘__main__‘:
          main()
      

4. 系统导入模块的路径

   1. 内存中：如果之前成功导入过某个模块，直接使用已经存在的模块

   2. 内置路径：安装路径：Lib

   3. PYTHONPATN：import时寻找模块路径。

   4. sys.path:是一个路径的列表。

   如果上面都找不到，就报错。

   动态修改sys.path。

   os.path.dirname():获取某个路径的父路径。通常用于获取当前模块的相对路径

   # 添加a.py所在的路径到sys.path中
   import sys
   # sys.path.append(r‘E:\pycharm\Python世界\从0开始学Python\day14\aa‘)
   
   
   # 使用相对位置找到aa文件夹
   # print(__file__)     # 当前文件的绝对路径
   
   # 使用os模块获取一个路径的父路径
   import os
   # print(os.path.dirname(__file__) + ‘/aa‘)
   sys.path.append(os.path.dirname(__file__) + ‘/aa‘)
   

Python之第二十一天的努力--模块1

标签：class   imp   右键   找不到   ret   har   本质   解释器   固定   

原文地址：https://www.cnblogs.com/szheng/p/13196481.html