经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » Python » 查看文章
分分钟钟学会Python - 模块
来源:cnblogs  作者:淡品岁月  时间:2019/5/15 9:19:34  对本文有异议

模块

1 模块基础知识

  1. 模块(类库)分类
  • 内置模块,python内部提供的功能

    import sys    # 优先导入模块加载到内存
    print(sys,argv)
  • 第三方模块,下载、安装、使用

    1.pip包管理工具
        把pip.exe 所在的文件目录加到环境变量中
        pip install 要安装的模块名称 # pip install xxxx
    
    2.源码安装
        下载源码包:压缩文件。
        解压文件
        打开cmd窗口,并进入此目录:cd C:\Python36\Lib\site-packages
        执行:python36 setup.py build 
        执行:python36 setup.py install 
  • 自定义模块

  1. 模块可以是一个py文件当做模块,以便以后其他py文件调用某方面功能的文件

  2. 模块包的调用,包:文件夹,存储多个py文件的文件夹

    如果导入的是一个包,这个包里的模块默认是不能使用的

    导入一个包相当于执行__init__py文件的内容

  3. 导入模块的方法

    • import

      • import 模块1 模块1.函数()
      • import 模块1.模块2.模块3 模块1.模块2.模块3.函数()
    • from xx import xxx

      • from 模块.模块 import 函数 函数()
      • from 模块.模块 import 函数 as f f()
      • from 模块.模块 import * 函数1() 函数2()
      • from 模块 import 模块 模块.函数()
      • from 模块 import 模块 as m m.函数()
    • 多次导入只导入一次

  4. 总结

    • 模块和要执行的py文件在同一目录 且 需要 模块中的很多功能时,推荐用: import 模块
    • 其他推荐:from 模块 import 模块 / 模块.函数()
    • 其他推荐:from 模块.模块 import 函数 函数()

2 random 返回随机生成的一个实数

  • random.randint() 返回随机生成的一个实数

  • random.choice 从序列中随机抽选一个函数 验证码,抽奖

  • random.sample 一个奖项多个人

  • random.uniform 随机小数

  • random.shuffle 将序列顺序打乱 洗牌

  • random.random()生成0和1之间的随机浮点数float

3 hashlib 摘要算法模块 Hmac算法

  • 加密模块。md5/sha

    • 两个文件的md5值是相同的
  • hmac输出的长度和原始哈希算法的长度一致。需要注意传入的key和message都是bytes类型,str类型需要首先编码为bytes

4 time /datetime 时间模块

  • time.time() 时间戳

  • time.timezone 当前时区与时间戳相差的秒数

  • time.sleep(2) 睡2秒

  • datetime.now() 当前本地时间

  • timezone(timedelta(hours=7)) 获取东7区时间

  • datetime.utcnow() 当前UTC时间

  • strftime 把datetime格式转换成字符串

  • strptime 字符串转成datetime

  • timedelta datetime时间的加减

  • 时间戳和datetime关系

5 getpass 密码不显示(只能在终端运行)

  • 密码不显示(只能在终端运行)

    import getpass
    
    pwd = getpass.getpass('请输入密码:')
    if pwd == '123':
        print('输入正确')

6 sys 解释器相关模块

  • sys.getrefcount,获取一个值的应用计数

  • sys.getrecursionlimit,python默认支持的递归数量

  • sys.stdout.write ----> print (可以查看进度)

  • sys.argv 获取用户执行脚本时,传入的参数。

    删除目录

    import shutil
    shutil.rmtree(path)
    ```

  • sys.path 模块搜索 默认Python去导入模块时,会按照sys.path中的路径挨个查找。

  • sys.exit(0) 终止程序

  • sys.modules 存储当前程序用到的所有模块,反射文件中的内容

7 os 操作系统相关

  • os.path.exists(path) 判断文件目录是否存在 , 如果path存在,返回True;如果path不存在,返回False

    os.path.isfile(path) 判断文件是否存在

    os.path.basename(file_path) 获取文件名

  • os.stat('文件').st_size , 获取文件大小

    os.path.getsize(path) 获取文件大小

  • os.path.abspath() , 获取一个文件的绝对路径 (__file__)获取当前文件绝对路径

    os.path.isabs(path) 判断是否为绝对路径

  • os.path.dirname ,获取路径的上级目录

  • os.path.join ,路径的拼接

  • os.listdir , 查看一个目录下所有的文件【第一层】

  • os.walk , 查看一个目录下所有的文件【所有层】

  • os.makedirs,创建目录和子目录

  • os.renname,重命名

8 shtil 高级的 文件、文件夹、压缩包 处理模块

  • shutil.rmtree 删除目录

  • shutil.move 重命名;移动文件

  • shutil.make_archive 压缩文件夹

  • shutil.unpack_archive 解压文件

9 json / pickle 序列化

  • 二者优缺点

    • json,优点:所有语言通用;缺点:只能序列化基本的数据类型

      所有字符串都是双引号;最外层只能是列表或字典

      存在字典的key只能是str;不能连续load多次

    • pickle,优点:python中几乎所有的东西都能被序列化(socket对象);缺点:序列化的内容只有python认识

      支持连续load多次

  • 一个特殊的字符串。【长得像列表、字典、字符串、数字、真假】

    
     +-------------------+---------------+
        | Python            | JSON          |
        +===================+===============+
        | dict              | object        |
        +-------------------+---------------+
        | list, tuple       | array         |
        +-------------------+---------------+
        | str               | string        |
        +-------------------+---------------+
        | int, float        | number        |
        +-------------------+---------------+
        | True              | true          |
        +-------------------+---------------+
        | False             | false         |
        +-------------------+---------------+
        | None              | null          |
        +-------------------+---------------+
  • dumps 序列化,将python的值转换为json格式的字符串(str/bytes类型)。

  • loads 反序列化,将json格式的字符串转换为python的值。

  • 字典或列表中如有中文,序列化时想要保留中文显示:

    v = {'k1':"asdf",'k2':'中文'}
    
    import json
    val = json.dumps(v,ensure_ascii=False)
    print(val)    # {"k1": "alex", "k2": "李杰"}
  • dump 将字典以特殊格式写到文件中

  • load 读取文件中内容转换成字典

10 importlib 根据字符串的形式导入模块。

模块 = importlib.import_module('utils.redis')
  • 开放封闭原则

    对配置文件开放

    对源代码封闭

11 collections 加强版数据结构

  1. OrderedDict 有序字典

  2. deque 双端队列

  3. defaultDict 默认字典,给value设置一个默认值

  4. namedtuple 可命名元祖

    应用:创建一个类,这个类没有办法,所有的属性的值都不能修改

12 logging 日志模块

  1. 报警等级

    CRITICAL = 50    # 最高
    FATAL = CRITICAL
    ERROR = 40
    WARNING = 30
    WARN = WARNING
    INFO = 20
    DEBUG = 10
    NOTSET = 0   # 最低
  2. 日志处理本质:Logger/FileHandler/Formatter

    应用:统计用;做故障排除debug;记录错误,完成代码优化

    logging.basicconfig

    • 使用方便
    • 不能实现编码问题;不能同时向文件和屏幕输出
    • logging.debug logging.warning

    logger对象 复杂的创建流程

    • 创建一个logger对象
    • 创建一个文件操作符
    • 创建一个屏幕操作符
    • 创建一个格式

    操作;

    • 给logger对象绑定 文件操作符

    • 给logger对象绑定 屏幕操作符

    • 给文件操作符设定格式

    • 给屏幕操作符设定格式

      import logging
      
      logger = logging.getLogger()   # 创建一个logger对象
      fh = logging.FileHandler('log.log')    # 创建一个文件操作符
      sh = logging.StreamHandler()   # 创建一个屏幕操作符
      logger.addHandler(fh)  # 给logger对象绑定 文件操作符
      logger.addHandler(sh)  # 给logger对象绑定 屏幕操作符
      formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  # 创建一个格式
      fh.setFormatter(formatter) # 给文件操作符设定格式
      sh.setFormatter(formatter) # 给屏幕操作符设定格式
      logger.warning('message')  # 
  3. 推荐处理日志方式

    import logging
    
    file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)
    logging.basicConfig(
        format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S %p',
        handlers=[file_handler,],
        level=logging.ERROR
    )
    
    logging.error('你好')
    # 日志切割
    import time
    import logging
    from logging import handlers
    # file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)
    file_handler = handlers.TimedRotatingFileHandler(filename='x3.log', when='s', interval=5, encoding='utf-8')
    logging.basicConfig(
        format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S %p',
        handlers=[file_handler,],
        level=logging.ERROR
    )
    
    for i in range(1,100000):
        time.sleep(1)
        logging.error(str(i))
  4. 注意事项

    # 在应用日志时,如果想要保留异常的堆栈信息。
    import logging
    import requests
    
    logging.basicConfig(
        filename='wf.log',
        format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S %p',
        level=logging.ERROR
    )
    
    try:
        requests.get('http://www.xxx.com')
    except Exception as e:
        msg = str(e) # 调用e.__str__方法
        logging.error(msg,exc_info=True)

13 copy

14 re模块

  1. 转义符

    正则表达式中的转义符在python的字符串中也刚好有转移的作用但是正则表达式中的转义符和字符串中的转义符并没关系,且还容易有冲突,为了避免这种冲突,我们所有的正则都以在工具中的测试结果为结果,然后只需要在正则和待匹配的字符串外面都加r即可

  2. re.fingall 匹配字符串中所有规则的项,返回一个列表;未匹配返回一个空列表

  3. re.search 会从头到尾从带匹配,匹配字符串取出第一个符合条件的项,如果匹配到了,返回一个对象,用group取值;如果没匹配到,返回None,不能用group,会报错

  4. re.match 会从头匹配字符串中取出从第一个字符开始是否符合规则,如果符合,就返回对象,用group取值;如果不符合,就返回None,相当于 match = search + ^正则

  5. re.finditer 在查询的结果超过1个的情况下,能够有效的节省内存,降低空间复杂度,从而也降低了时间复杂度

  6. compile 在同一个正则表达式重复使用多次的时候使用能够减少时间的开销,属于内置函数

  7. re.split() 分割,根据正则规则切割,返回列表,默认不保留切掉的内容

  8. re.sub() 替换,默认替换所有,可以使用替换深度参数

    re.subn() 替换,返回元祖

  9. 分组

    1. findall遇到正则表达式中的分组,会优先显示分组中的内容

    2. split遇到正则表达式中的分组,会保留分组中本来应该被切割掉的内容

    3. group(加参数)

    4. 分组命名 (?P<名字>正则表达式)

      search 取分组中的内容 通过索引;通过组名取

    5. 分组引用 (?P=组名) 这个组中的内容必须完全和之前已经存在的组匹配到的内容一模一样

    6. 取消分组优先 (?:)

  10. [] 和 [^] 带有特殊意义的元字符到字符组内大部分都会取消它的特殊含义

    • [()+*.]

      • [(\-)] -的位置决定了它的意义,写在字符组的第一位位置或者最后一个位置就表示一个普通的横杠
      • 写在字符组的其他任何位置都会表示一个范围

15 struct模块

  1. pack 能够把所有的数字都固定的转换成4字节

16 正则表达式

  1. 基础

    1. 正则表达式概念: 是一种规则(元字符,量词)

      ? 正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符、及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串”用来表达对字符串的一种过滤逻辑。

    2. re 模块和正则表达式的关系

    ? re 模块本身只是用来操作正则表达式,和正则表达式一点关系都没有

    1. 应用;

    ? 匹配字符串

    ? 表单验证

    ? 爬虫

  2. [ ] 字符组

    • 本身是哪一个字符,就匹配字符串中哪一个字符
    • 字符组[字符1字符2],一个字符组就代表匹配一个字符,只要这个字符出现在字符串中,那么久说明这个字符能匹配上
    • 字符中还可以使用范围
    • 所有的范围都必须遵循ascii码从小到大来指定
  3. 元字符

    1. ? 转义符 可以转义所有

      ?d (digit) 能匹配所有0-9之间的数字

      \w (word) 能匹配大小写字母,数字,下划线

      \s (space) 能匹配 空白 空格 换行符 制表符

      ?t (table) 只能匹配制表符

      ?n (next) 只能匹配换行符

    2. \D 表示除 数字所有

      \W 表示除 大小写字母,数字,下划线 的所有

      \S 表示除 空白 空格 换行符 制表符 的所有

    3. [\d\D] [\w\W] [\s\S] 能表示一切字符

      . 表示除换行符之外的任意内容

    4. [ ] 字符组只要在中括号内的所有字符都符合规则的字符

      [ ^ ] 字符组只要在中括号内的所有字符都不符合规则的字符

    5. ^ 表示一个字符,只匹配一个开头

      $ 表示一个字符的结束

      ^abc$ 表示约束以a开头,c结尾

    6. | 或 表示两个规则哟重叠的部分,总是长的在前面,短的在后面

      () 分组 表示给一部分正则规定为一组,| 这个符号的作用域就可以缩小了

  4. 量词

    1. { n } 表示只能出现n次

      { n, } 表示至少出现n次

      { n,m } 表示至少出现n次,至多出现m次

    2. ? 表示匹配0次或者1次,可有可无但是又只能有1个

      + 表示匹配一次或者多次

      * 表示匹配0次或者多次,可有可无但是有可以有多个

  5. 默认贪婪匹配:总是会在符合量词条件的范围为尽量多的匹配

    非贪婪匹配(惰性匹配):总是会匹配符合条件范围内尽量小的字符串

    元字符 量词 ?x 表示元字符规则在量词范围内匹配,一遇到x就会停止

    . * ? x 表示匹配任意的内容多次遇到X就会立即停止

    1. 元字符
    2. 元字符量词
    3. 元字符量词?
    4. \d+?x .*?x 爬虫

17 异常处理

  1. 基本格式

    try:
        pass
    except Exception as e:
        pass 
  2. 主动触发异常

    try:
        int('123')
        raise Exception('阿萨大大是阿斯蒂') # 代码中主动抛出异常
    except Exception as e:
        print(e)
    
    
    # 实例
    def func():
        result = True
        try:
            with open('x.log',mode='r',encoding='utf-8') as f:
                data = f.read()
            if 'alex' not in data:
                raise Exception()
        except Exception as e:
            result = False
        return result
  3. 自定义异常

    # 实例一
    class MyException(Exception):
        pass
    
    try:
        raise MyException('asdf')
    except MyException as e:
        print(e)
    
    

原文链接:http://www.cnblogs.com/dpsy921/p/10864706.html