包和一些常用模块

Posted 2022-04-27 buzaiyicheng

• 包
  • 回顾调用一个模块的过程：
    1、运行执行文件，创建一个执行文件的名称空间
    2、创建模块文件的名称空间
    3、执行模块文件中的代码，将产生的名字放入模块的名称空间中
    4、在执行文件中拿到一个指向模块名称空间的名字
  • 定义：
    包是一种通过使用 .模块名 来组织python模块名称空间的方式，包的本质还是一个模块
  • 具体的：
    包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来
  • 需要强调的是：
    1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，
    ?而在python2中，包下一定要有该文件，否则import 包报错
    2. 创建包的目的不是为了运行，而是被导入使用，?记住，包只是模块的一种形式而已，包的本质就是一种模块
  • 首次导入包的执行过程：
    1、先运行执行文件，创建一个执行文件的名称空间
    2、创建包下面的__init__.py文件的名称空间
    3、执行包下面的__Init__.py文件中的代码，将产生的名字放入包下面的__init__.py文件得我名称空间中
    4、在执行文件中拿到一个指向包下面的__init__.py文件名称空间的名字
  • 包的导入之注意事项：
  • 1、包的导入可以使用import和from...import...两种。
    但是无论在什么位置，导入时都要遵循一个原则：凡是导入时带点的，点的左边必须是一个包，就是 .包名 的形式，否则非法。可以带有一连串的点，如 item.subitem.subsubitem 但是导入后，在使用时就没有这种限制了，点的左边可以使包，函数，模块，类（她们都可以用点的方式调用自己的属性）
  • 2、import导入文件是，产生名称空间中的名字来源于文件，“ import 包 ”产生的名称空间的名字同样来源于文件，即包下__init__.py，导入的本质就是导入该文件
  • 3、包A和包B下有同名模块也不会冲突，如A.a和B.b来自两个命名空间
  • 4、调用包，有时候要用到环境变量，注意一下环境变量是以执行文件为准的
  • 包的开发之注意事项：
    1、当模块的功能特别多的情况下，应该分文件管理
    2、每个模块之间为了避免后期模块改名的问题，可以使用相对导入（包里边的文件都应该是被导入的模块）
  • 环境变量注意事项：
    1、站在包的开发者。如果使用绝对路径来管理自己的模块，那么它是需要永远以包的路径为基准依次导入模块
    2、站在包的使用者。必须将包所在的那个文件夹路径添加到system path中（******）
• logging模块（日志模块）
  • 如何使用

    import logging
    logging.debug(‘调试debug‘)?
    logging.info(‘消息info‘)
    logging.warning(‘警告warn‘)
    logging.error(‘错误error‘)
    logging.critical(‘严重critical‘)
    ?
    ‘‘‘打印结果
    WARNING:root:警告warn
    ERROR:root:错误error
    CRITICAL:root:严重critical
    ‘‘‘

    
    
  • 可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为

    import logging
    logging.basicConfig(filename=‘access.log‘,
                        format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s‘,
                        datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
                        level=30,
                        )
    ?
    logging.debug(‘debug日志‘)  # 10
    logging.info(‘info日志‘)  # 20
    logging.warning(‘warning日志‘)  # 30
    logging.error(‘error日志‘)  # 40
    logging.critical(‘critical日志‘)  # 50

    
    
  • 日志形成的内部机制和步骤

    1.logger对象:负责产生日志
    2.filter对象:过滤日志(了解)
    3.handler对象:控制日志输出的位置(文件/终端)
    4.formmater对象:规定日志内容的格式

    
    
  • 举例说明日志形成过程

    import logging
    ?
    # 1.logger对象:负责产生日志
    logger = logging.getLogger(‘转账记录‘)
    ?
    # 2.filter对象:过滤日志(了解)
    ?
    # 3.handler对象:控制日志输出的位置(文件/终端)
    hd1 = logging.FileHandler(‘a1.log‘,encoding=‘utf-8‘)  # 输出到文件中
    hd2 = logging.FileHandler(‘a2.log‘,encoding=‘utf-8‘)  # 输出到文件中
    hd3 = logging.StreamHandler()  # 输出到终端
    ?
    # 4.formmater对象:规定日志内容的格式
    fm1 = logging.Formatter(
            fmt=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s‘,
            datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
    )
    fm2 = logging.Formatter(
            fmt=‘%(asctime)s - %(name)s:  %(message)s‘,
            datefmt=‘%Y-%m-%d‘,
    )
    ?
    # 5.给logger对象绑定handler对象
    logger.addHandler(hd1)
    logger.addHandler(hd2)
    logger.addHandler(hd3)
    ?
    # 6.给handler绑定formmate对象
    hd1.setFormatter(fm1)
    hd2.setFormatter(fm2)
    hd3.setFormatter(fm1)
    ?
    # 7.设置日志等级
    logger.setLevel(20)
    ?
    # 8.记录日志
    logger.debug(‘写了半天 好累啊 好热啊 好想释放‘)

• • hashlib模块
  • 定义
    hash是一种算法（3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法），该算法接受传入的内容，经过运算得到一串hash值
  • hash值的特点是：

    1、只要传入的内容一样，得到的hash值必然一样=====>要用明文传输密码文件完整性校验
    2、不能由hash值返解成内容=======》把密码做成hash值，不应该在网络传输明文密码
    3、只要使用的hash算法不变，无论校验的内容有多大，得到的hash值长度是固定的

  • 关于加密

    1.不同的算法 使用方法是相同的
    密文的长度越长 内部对应的算法越复杂
    但是
        1.时间消耗越长
        2.占用空间更大
    通常情况下使用md5算法 就可以足够了

  • hashlib模块应用场景
    1.密码的密文存储
    2.校验文件内容是否一致
  • 加盐处理
    • 定义：在每一个需要加密的数据之前 先手动添加一些内容

      # 加盐处理
      # import hashlib
      #
      # md = hashlib.md5()
      # # 公司自己在每一个需要加密的数据之前 先手动添加一些内容
      # md.update(b‘oldboy.com‘)  # 加盐处理
      # md.update(b‘hello‘)  # 真正的内容
      # print(md.hexdigest())  # 返回摘要，作为十六进制数据字符串值

    • 加盐的原因：
      为了避免用户的简单密码可以被轻易识别, ?
      在生成摘要时, 我们可以加点作料.作料可以是一个固定的字符串, ?
      也可以是一个根据用户不同的随机字符串.?
      如果是随机字符串的话, 这个随机字符串也需要被存储在服务器中.
  • 动态加盐
    • 定义：就是将加盐操作写成函数，每次加盐操作的时候，直接调用函数

      import hashlib
      def get_md5(data):
          md = hashlib.md5()
          md.update(‘加盐‘.encode(‘utf-8‘))
          md.update(data.encode(‘utf-8‘))
          return md.hexdigest()
      password = input(‘password>>>:‘)
      res = get_md5(password)
      print(res)

• openpyxl模块
  • office版本常识
    03版本之前，Excel文件后缀名叫
  • 操作Excel的模块
    xlwd 写；excelxlrt 读
    excelxlwd和xlrt既支持03版本之前的excel文件，也支持03版本之后的excel文件
    openpyxl 只支持03版本之后的
  • 使用流程
    • 安装

      pip install openpyxl

    • 创建

      from  openpyxl import  Workbook 
      # 实例化
      wb = Workbook()
      # 激活 worksheet
      ws = wb.active

    • 打开已有

      >>> from openpyxl  import load_workbook
      >>> wb2 = load_workbook(‘文件名称.xlsx‘)

    • 存储数据

      # 方式一：数据可以直接分配到单元格中(可以输入公式)
      ws[‘A1‘] = 42
      # 方式二：可以附加行，从第一列开始附加(从最下方空白处，最左开始)(可以输入多行)
      ws.append([1, 2, 3])
      # 方式三：Python 类型会被自动转换
      ws[‘A3‘] = datetime.datetime.now().strftime("%Y-%m-%d")

    • 创建表

      # 方式一：插入到最后(default)
      >>> ws1 = wb.create_sheet("Mysheet") 
      # 方式二：插入到最开始的位置，第二个参数是索引号
      >>> ws2 = wb.create_sheet("Mysheet", 0)

    • 选择表

      # sheet 名称可以作为 key 进行索引
      >>> ws3 = wb["New Title"]
      >>> ws4 = wb.get_sheet_by_name("New Title")
      >>> ws is ws3 is ws4
      True

    • 查看表

      # 显示所有表名
      >>> print(wb.sheetnames)
      [‘Sheet2‘, ‘New Title‘,  ‘Sheet1‘]
      # 遍历所有表
      >>> for sheet in  wb:
      ... 	print(sheet.title)

    • 访问单元格（call）
      • 单一单元格访问

        # 方法一
        >>> c = ws[‘A4‘]
        # 方法二：row 行；column 列
        >>> d = ws.cell(row=4, column=2, value=10)
        # 方法三：只要访问就创建
        >>> for i in  range(1,101):
        ...         for j in range(1,101):
        ...            ws.cell(row=i, column=j)

    • 保存数据

      >>> wb.save(‘文件名称.xlsx‘)

    • 删除工作表

      # 方式一
      wb.remove(sheet)
      # 方式二
      del wb[sheet]

• 深浅拷贝
  • 字面理解
    浅拷贝指仅仅拷贝数据集合的第一层数据，
    深拷贝指拷贝数据集合的所有层。
    ?所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，?比如字符串，数字，还有仅仅一层的字典、列表、元祖等
  • 内部原理
    深浅拷贝的本质是对于可变不可变类型，到底指的是原来还是自己
  • 方法
    导入模块：import copy
    浅拷贝：copy.copy
    深拷贝：copy.deepcopy