zoukankan      html  css  js  c++  java
  • <笔记>第二篇:常用模块

    • 什么是模块?常见的场景:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。
    • 其实import加载的模块分为四个通用类别:
      • 使用python编写的代码(.py文件)  
      • 已被编译为共享库或DLL的C或C++扩展
      • 包好一组模块的包
      • 使用C编写并链接到python解释器的内置模块
    • 为什么要使用模块?之前定义的函数或变量,为了方便管理和后期的调用,现在将程序制作成一个模块,使它不仅能作为脚本执行,也可以导入到其他模块,实现功能的重复利用.  
    • 如何控制.py文件在不同的应用场景下执行不同的逻辑?if __name__ == '__main__': 
      • 我们可以通过模块的全局变量__name__来查看模块名:  
        • 当做脚本运行:__name__ 等于'__main__'  
        • 当做模块导入:__name__= 模块名   
    • 什么是包? 包是目录级的(文件夹级),文件夹是用来组成py文件(包的本质就是一个包含__init__.py文件的目录) 
      • 在python3中,即使包下没有__init__.py文件,import 包仍然不会报错,而在python2中,包下一定要有该文件,否则import 包报错 
      • 创建包的目的不是为了运行,而是被导入使用,记住,包只是模块的一种形式而已,包即模块  
      • 凡是在导入时带点的,点的左边都必须是一个包,否则非法 
    • 软件开发规范
      • 目录:bin,conf,core,lib,log 

        • #=============>bin目录:存放执行脚本
          #start.py
          import sys,os
          
          BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
          sys.path.append(BASE_DIR)
          
          from core import core
          from conf import my_log_settings
          
          if __name__ == '__main__':
              my_log_settings.load_my_logging_cfg()
              core.run()
          
          #=============>conf目录:存放配置文件
          #config.ini
          [DEFAULT]
          user_timeout = 1000
          
          [egon]
          password = 123
          money = 10000000
          
          [alex]
          password = alex3714
          money=10000000000
          
          [yuanhao]
          password = ysb123
          money=10
          
          #settings.py
          import os
          config_path=r'%s\%s' %(os.path.dirname(os.path.abspath(__file__)),'config.ini')
          user_timeout=10
          user_db_path=r'%s\%s' %(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
                               'db')
          
          
          #my_log_settings.py
          """
          logging配置
          """
          
          import os
          import logging.config
          
          # 定义三种日志输出格式 开始
          
          standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' 
                            '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字
          
          simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
          
          id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
          
          # 定义日志输出格式 结束
          
          logfile_dir = r'%slog' %os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # log文件的目录
          
          logfile_name = 'all2.log'  # log文件名
          
          # 如果不存在定义的日志目录就创建一个
          if not os.path.isdir(logfile_dir):
              os.mkdir(logfile_dir)
          
          # log文件的全路径
          logfile_path = os.path.join(logfile_dir, logfile_name)
          
          # log配置字典
          LOGGING_DIC = {
              'version': 1,
              'disable_existing_loggers': False,
              'formatters': {
                  'standard': {
                      'format': standard_format
                  },
                  'simple': {
                      'format': simple_format
                  },
              },
              'filters': {},
              'handlers': {
                  #打印到终端的日志
                  'console': {
                      'level': 'DEBUG',
                      'class': 'logging.StreamHandler',  # 打印到屏幕
                      'formatter': 'simple'
                  },
                  #打印到文件的日志,收集info及以上的日志
                  'default': {
                      'level': 'DEBUG',
                      'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
                      'formatter': 'standard',
                      'filename': logfile_path,  # 日志文件
                      'maxBytes': 1024*1024*5,  # 日志大小 5M
                      'backupCount': 5,
                      'encoding': 'utf-8',  # 日志文件的编码,再也不用担心中文log乱码了
                  },
              },
              'loggers': {
                  #logging.getLogger(__name__)拿到的logger配置
                  '': {
                      'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上,即log数据既写入文件又打印到屏幕
                      'level': 'DEBUG',
                      'propagate': True,  # 向上(更高level的logger)传递
                  },
              },
          }
          
          
          def load_my_logging_cfg():
              logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
              logger = logging.getLogger(__name__)  # 生成一个log实例
              logger.info('It works!')  # 记录该文件的运行状态
          
          if __name__ == '__main__':
              load_my_logging_cfg()
          
          #=============>core目录:存放核心逻辑
          #core.py
          import logging
          import time
          from conf import settings
          from lib import read_ini
          
          config=read_ini.read(settings.config_path)
          logger=logging.getLogger(__name__)
          
          current_user={'user':None,'login_time':None,'timeout':int(settings.user_timeout)}
          def auth(func):
              def wrapper(*args,**kwargs):
                  if current_user['user']:
                      interval=time.time()-current_user['login_time']
                      if interval < current_user['timeout']:
                          return func(*args,**kwargs)
                  name = input('name>>: ')
                  password = input('password>>: ')
                  if config.has_section(name):
                      if password == config.get(name,'password'):
                          logger.info('登录成功')
                          current_user['user']=name
                          current_user['login_time']=time.time()
                          return func(*args,**kwargs)
                  else:
                      logger.error('用户名不存在')
          
              return wrapper
          
          @auth
          def buy():
              print('buy...')
          
          @auth
          def run():
          
              print('''
          购物
          查看余额
          转账
              ''')
              while True:
                  choice = input('>>: ').strip()
                  if not choice:continue
                  if choice == '1':
                      buy()
          
          
          
          if __name__ == '__main__':
              run()
          
          #=============>db目录:存放数据库文件
          #alex_json
          #egon_json
          
          #=============>lib目录:存放自定义的模块与包
          #read_ini.py
          import configparser
          def read(config_file):
              config=configparser.ConfigParser()
              config.read(config_file)
              return config
          
          #=============>log目录:存放日志
          #all2.log
          [2017-07-29 00:31:40,272][MainThread:11692][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
          [2017-07-29 00:31:41,789][MainThread:11692][task_id:core.core][core.py:25][ERROR][用户名不存在]
          [2017-07-29 00:31:46,394][MainThread:12348][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
          [2017-07-29 00:31:47,629][MainThread:12348][task_id:core.core][core.py:25][ERROR][用户名不存在]
          [2017-07-29 00:31:57,912][MainThread:10528][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
          [2017-07-29 00:32:03,340][MainThread:12744][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
          [2017-07-29 00:32:05,065][MainThread:12916][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
          [2017-07-29 00:32:08,181][MainThread:12916][task_id:core.core][core.py:25][ERROR][用户名不存在]
          [2017-07-29 00:32:13,638][MainThread:7220][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
          [2017-07-29 00:32:23,005][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
          [2017-07-29 00:32:40,941][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
          [2017-07-29 00:32:47,222][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
          [2017-07-29 00:32:51,949][MainThread:7220][task_id:core.core][core.py:25][ERROR][用户名不存在]
          [2017-07-29 00:33:00,213][MainThread:7220][task_id:core.core][core.py:20][INFO][登录成功]
          [2017-07-29 00:33:50,118][MainThread:8500][task_id:conf.my_log_settings][my_log_settings.py:75][INFO][It works!]
          [2017-07-29 00:33:55,845][MainThread:8500][task_id:core.core][core.py:20][INFO][登录成功]
          [2017-07-29 00:34:06,837][MainThread:8500][task_id:core.core][core.py:25][ERROR][用户名不存在]
    • 常见模块

      • 时间模块:time

        • time.sleep(secs):延迟时间,单位是秒
          time.time():获取当前的时间戳
          time.strftime("%Y-%m-%d %X"):'2017-07-24 13:54:37'
          time.strftime("%Y-%m-%d %H-%M-%S"):'2017-07-24 13-55-04'
          
          time.localtime()
          time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
                    tm_hour=13, tm_min=59, tm_sec=37, 
                           tm_wday=0, tm_yday=205, tm_isdst=0)
      • 表达时间的三种方式

        • 时间戳:1970年1月1日0点开始按秒计算偏移量
          元祖:struct_time,一共9个元素(年,月,日,时,分,秒,一年中第几周,一年中第几天,是否是夏令时)
          格式化时间:'1999-1-1'

      • 三种时间的转换

        • import time
          
          # --------------正向--------------------
          # 时间戳
          Timestamp = time.time()
          print(Timestamp)
          # 时间戳-->结构化时间
          struct_time = time.localtime(Timestamp)
          print(struct_time)
          # 结构化时间-->字符串时间
          Format_string = time.strftime("%Y-%m-%d %H:%M:%S", struct_time)
          print(Format_string)
          # -----------------反向-------------------
          # 字符串时间-->结构化时间
          struct_time = time.strptime(Format_string, "%Y-%m-%d %H:%M:%S")
          print(struct_time)
          # 结构化时间-->时间戳
          Timestamp = time.mktime(struct_time)
          print(Timestamp)
          
          # 计算时间差
          time_time = time.mktime(time.strptime('2020-01-01 00:00:00', "%Y-%m-%d %H:%M:%S"))
          time_now = time.mktime(time.strptime('2020-09-07 09:13:09', "%Y-%m-%d %H:%M:%S"))
          dif_time = time_now - time_time
          struct_time = time.localtime(dif_time)
          print('过去了%d年%d月%d天%d小时%d分钟%d秒' % (struct_time.tm_year - 1970, struct_time.tm_mon - 1,
                                             struct_time.tm_mday - 1, struct_time.tm_hour,
                                             struct_time.tm_min, struct_time.tm_sec))  

     

      • random模块 
        • import random
          # 随机小数
          random.random():0-1之间的小数
          random.uniform(1,3):1-3之间的小数
          # 随机整数
          random.randint(1,5):1-5之间的整数
          random.randrange(1,10,2):类似range,1-10之间的奇数
          # 随机选择一个返回
          random.choice([1,'23',[4,5]])
          # 随机选择多个返回
          random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
          
          # 打乱顺序
          item=[1,3,5,7,9]
          random.shuffle(item) # 打乱次序
          
          
          # 随机验证码
          
          import random
          
          
          def v_code():
              code = ''
              for i in range(5):
                  # 选择0-9整数
                  num = random.randint(0, 9)
                  # 返回值是当前(0-255)的整数对应的ASCII字符
                  alf = chr(random.randint(65, 90))
                  # 从整数和ASCII字符选择一个
                  add = random.choice([num, alf])
                  # 将得到的add加到字符串code中
                  code = "".join([code, str(add)])
              return code
          
          
          print(v_code())
      • OS模块:是与操作系统交互的一个接口 
        • os.makedirs('dirname1/dirname2')    可生成多层递归目录
          os.removedirs('dirname1')    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
          os.mkdir('dirname')    生成单级目录;相当于shell中mkdir dirname
          os.rmdir('dirname')    删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
          os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
          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
          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的大小
          
          os.sep    输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
          os.linesep    输出当前平台使用的行终止符,win下为"
          ",Linux下为"
          "
          os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
          os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
      • sys模块:与Python解释器交互的模块 
        • sys.argv           命令行参数List,第一个元素是程序本身路径
          sys.exit(n)        退出程序,正常退出时exit(0),错误退出sys.exit(1)
          sys.version        获取Python解释程序的版本信息
          sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
          sys.platform       返回操作系统平台名称    
      • 序列化模块
        • 什么是序列化?将原本字典、列表等内容转换成一个字符串的过程就叫做序列化 
        • 序列化的目的:
          • 以某种存储形式使自定义对象持久化
          • 将对象从一个地方传递到另一个地方
          • 使程序更具维护性。
        • dumps和loads
          • import json
            dic = {'k1':'v1','k2':'v2','k3':'v3'}
            str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
            print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
            #注意,json转换完的字符串类型的字典中的字符串是由""表示的
            
            dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
            #注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
            print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
            
            
            list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
            str_dic = json.dumps(list_dic,ensure_ascii=False) #也可以处理嵌套的数据类型 
            print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
            list_dic2 = json.loads(str_dic)
            print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
        • dump和load
          • import json
            f = open('json_file','w')
            dic = {'k1':'v1','k2':'v2','k3':'v3'}
            json.dump(dic,f)  #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
            f.close()
            
            f = open('json_file')
            dic2 = json.load(f)  #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
            f.close()
            print(type(dic2),dic2) 
      • re模块:主要是正则
        • import re
          
          ret = re.findall('a', 'eva egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
          print(ret) #结果 : ['a', 'a']
          
          ret = re.search('a', 'eva egon yuan').group()
          print(ret) #结果 : 'a'
          # 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
          # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配,则返回None。
          
          ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
          print(ret)
          #结果 : 'a'
          
          ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
          print(ret)  # ['', '', 'cd']
          
          ret = re.sub('d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H',参数1表示只替换1个
          print(ret) #evaHegon4yuan4
          
          ret = re.subn('d', 'H', 'eva3egon4yuan4')#将数字替换成'H',返回元组(替换的结果,替换了多少次)
          print(ret)
          
          obj = re.compile('d{3}')  #将正则表达式编译成为一个 正则表达式对象,规则要匹配的是3个数字    compile编译
          ret = obj.search('abc123eeee') #正则表达式对象调用search,参数为待匹配的字符串
          print(ret.group())  #结果 : 123
          
          import re
          ret = re.finditer('d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
          print(ret)  # <callable_iterator object at 0x10195f940>
          print(next(ret).group())  #查看第一个结果
          print(next(ret).group())  #查看第二个结果
          print([i.group() for i in ret])  #查看剩余的左右结果
        • 爬虫中正则的常用写法
          • com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>d+).*?<span class="title">(?P<title>.*?)</span>'
                               '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>',re.S)
            
            ret=com.finditer(s)
          • flags有很多可选值:

            • re.I(IGNORECASE)忽略大小写,括号内是完整的写法
              re.M(MULTILINE)多行模式,改变^和$的行为
              re.S(DOTALL)点可以匹配任意字符,包括换行符
              re.L(LOCALE)做本地化识别的匹配,表示特殊字符集 w, W, , B, s, S 依赖于当前环境,不推荐使用
              re.U(UNICODE) 使用w W s S d D使用取决于unicode定义的字符属性。在python3中默认使用该flag
              re.X(VERBOSE)冗长模式,该模式下pattern字符串可以是多行的,忽略空白字符,并可以添加注释
      • hashlib模块

        • Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等。

        • 什么是摘要算法呢?摘要算法又称哈希算法、散列算法。它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。

        • MD5

          • import hashlib
            
            md5 = hashlib.md5()
            md5.update('how to use md5 in ')
            md5.update('python hashlib?')
            print(md5.hexdigest())
        • Sha1

          • import hashlib
             
            sha1 = hashlib.sha1()
            sha1.update('how to use sha1 in ')
            sha1.update('python hashlib?')
            print(sha1.hexdigest())
        • 防止用反推表直接得到密码,加密中有加盐操作

          • hashlib.md5("salt".encode("utf8"))
            
      • configparser模块:生成类似下方的文件

        • [DEFAULT]
          ServerAliveInterval = 45
          Compression = yes
          CompressionLevel = 9
          ForwardX11 = yes
            
          [bitbucket.org]
          User = hg
            
          [topsecret.server.com]
          Port = 50022
          ForwardX11 = no
        • 实现代码

          • import configparser
            
            config = configparser.ConfigParser()
            
            config["DEFAULT"] = {'ServerAliveInterval': '45',
                                  'Compression': 'yes',
                                 'CompressionLevel': '9',
                                 'ForwardX11':'yes'
                                 }
            
            config['bitbucket.org'] = {'User':'hg'}
            
            config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}
            
            with open('example.ini', 'w') as configfile:
            
               config.write(configfile)
            

              

                          

                                

                                    

        

       

              

            

                        

  • 相关阅读:
    python05-循环
    python03-列表
    python03 input
    python02-灭霸的选择
    python学习小记01--萌新的进化
    Linux—-软件安装
    linux-认识与分析日志
    Esxi遇到问题汇总。
    xx
    Pramp mock interview (4th practice): Matrix Spiral Print
  • 原文地址:https://www.cnblogs.com/shuimohei/p/13631142.html
Copyright © 2011-2022 走看看