<笔记>第二篇:常用模块

  • 什么是模块?常见的场景:一个模块就是一个包含了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'%s\log' %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下为"\r\n",Linux下为"\n"
        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, \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)
          

            

                        

                              

                                  

 

 

 

    

 

 

 

   

          

        

                    

 

posted @ 2020-09-08 10:46  水墨黑  阅读(166)  评论(0编辑  收藏  举报