• 内置模块:time, datetime, random, json, pickle, os, sys, hashlib, collections, re


    1.time模块

    import time
    time.time() # 时间戳  浮点数
    time.sleep() # 睡眠
    time.gmtime()/time.localtime() #结构化时间 数据类型是命名元祖
    time.strftime('格式化','结构化时间')
    time.strptime('字符串','格式化')
    time.mktime('结构化时间') #结构化时间转时间戳
    
    # 将时间戳转换成字符串时间
    print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime(1564028611.631374)))
    # 将字符串时间转换成时间戳
    print(time.mktime(time.strptime("2024-3-16 12:30:30","%Y-%m-%d %H:%M:%S")))
    

    img

    2. datetime

    1. 获取当前日期和时间

    form datetime import datetime
    print(datetime.now())
    print(datetime(2018,5,20,13,14)) #获取指定日期和时间
    

    2. datetime 与时间戳的转换

    form datetime import datetime
    print(datetime.now().timestamp()) # 转时间戳
    
    import time
    from datetime import datetime
    print(datetime.fromtimestamp(time.time()))
    

    3. str 与 datetime的转换

    print(datetime.strptime("2019-10-10 22:23:24","%Y-%m-%d %H:%M:%S")) # 将字符串转换成datetime
    print(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) # 将datetime转换成字符串
    print(str(datetime.now()))
    

    4. datetime加减

    from datetime import datetime, timedelta
    print(datetime.now() + timedelta(days=1))
    print(datetime.now() - timedelta(hours=3))
    

    3. random 随机模块

    import random
    print(random.random()) # 0~1之间的浮点数
    print(random.uniform(1,10)) #1~10之间的浮点数
    print(random.randint(1,50)) #1~50之间的整数(闭区间)
    print(random.randrange(1,5,2)) #(起始,终止,步长)
    print(random.choice([1,2,3,4,5,]))#随机选择一个
    print(random.choices([1,2,3,4,5,],k=2))#随机选两个,会有重复数字,列表形式
    print(random.sample((1,2,3,4,5),k=2))#随机选两个,不会有重复数字,列表形式
    lst = [1,2,3,4,5,6,7,8,9,0]
    random.shuffle(lst) # 打乱顺序 
    print(lst)
    

    随机产生验证码:

    import random
    def y_code():
        code = ''
        for i in range(4):
            num = chr(random.randint(48,57))
            # 取数字
            alf = chr(random.randint(97,122))
            # 取小写字母
            alf_upper = chr(random.randint(65,90))
            # 取大写字母
            s = str(random.choice([num,alf,alf_upper]))
            code = ''.join([code,s])
        return code
    print(y_code())
    

    4. 序列化模块

    将一种数据结构(如字典、列表)等转换成一个特殊的序列(字符串或者bytes)的过程就叫做序列化.

    主要用途:文件读写数据,网络传输数据。

    4.1 json模块

    json模块是将满足条件的数据结构转化成特殊的字符串,并且也可以反序列化还原回去。

    json序列化只支持部分Python数据结构:dict,list, tuple,str,int, float,True,False,None

    用于网络传输:dumps、loads

    用于文件写读:dump、load

    4.1.1 dumps、loads

    1. 将字典类型转换成字符串类型
    import json
    dic = {'key1':'1','key2':2}
    str_dic = json.dumps(dic)
    print(str_dic,type(str_dic))  # 字符串
    
    2. 将字符串类型的字典转换成字典类型
    dic1 = json.loads(str_dic)
    print(dic1,type(dic1))
    
    3. 还支持列表类型
    import json
    lit = [1,2,"3",4]
    str_lst = json.dumps(lit)
    print(str_lst,type(str_lst))
    lst = json.loads(str_lst)
    print(lst,type(lst))
    

    4.1.2 dump、load

    1. 讲对象转换成字符串写入到文件中
    dic = {'key1':1}
    with open('a1.txt','a',encoding='utf-8')as f:
        json.dump(dic,f)  
    
    2. 将文件中的字符串类型的字典转换成字典
    with open('a1.txt','r',encoding='utf-8')as f1:
        dic1 = json.load(f1)
    print(dic1)
    
    

    4.1.3 json序列化存储多个数据到同一个文件中

    with open('a1.txt','r',encoding='utf-8')as f1:
        for i in f1:
            lst = json.loads(i)
            print(lst)
    

    4.2 pickle模块

    pickle模块是将Python所有的数据结构以及对象等转化成bytes类型,然后还可以反序列化还原回去。

    pickle模块是只能Python语言识别的序列化模块。

    用于网络传输:dumps、loads

    用于文件写读:dump、load

    4.2.1 dumps、loads

    import json
    dic = {'key1':'1','key2':2}
    str_dic = pickle.dumps(dic)
    print(str_dic,type(str_dic))  # 类似字节
    dic1 = pickle.loads(str_dic)
    print(dic1,type(dic1))
    

    4.2.2 dump、load

    with open('a1.txt','ab')as f:
        pickle.dump(dic,f)
    with open('a1.txt','rb')as f1:
        dic1 = pickle.load(f1)
    print(dic1)
    

    4.2.3 pickle序列化存储多个数据到一个文件中

    import pickle
    dic = {"1":2}
    f = open("info","wb")
    s = "
    ".encode("utf-8")
    f.write(pickle.dumps(dic)+ s)
    f.write(pickle.dumps(dic)+ s)
    f.write(pickle.dumps(dic)+ s)
    f.close()
    
    f1 = open("info","rb")
    for i in f1:
        print(pickle.loads(i))
    

    5. os模块

    os模块是与操作系统交互的一个接口

    os模块四组:

    1. 工作目录

    import os
    print(os.getcwd()) # 当前工作路径  ***
    os.chdir("F:s24day06") # 路径切换 ***
    print(os.curdir)  # 当前目录
    print(os.pardir)  # 当前目录的父级目录
    

    2. 文件夹

    import os
    os.mkdir("ttt") # 创建一个文件夹  ***
    os.rmdir("ttt") # 删除一个文件夹,若不为空则无法删除,报错  ***
    os.makedirs("ttt/sss/ddd/ee")  # 递归创建文件夹     ***
    os.removedirs("ttt/sss/ddd/ee")  # 递归删除文件夹,若为空删除,不为空不删除   ***
    print(os.listdir(r"F:s24day17"))  # 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印***
    

    3. 文件

    import os
    os.remove()  # 删除一个文件  ***
    os.rename("oldname","newname")  # 重命名文件/目录  ***
    

    4. 路径

    import os
    print(os.path.abspath(r"01 今日内容.py"))  # 通过相对路径获取绝对路径  ***
    print(os.path.split(os.path.abspath(r"01 今日内容.py")))  #将路径以最后一个切割(路径,文件名)
    print(os.path.dirname(r"F:s24day171 今日内容.py"))  # 获取路径 ***
    print(os.path.basename(r"F:s24day171 今日内容.py")) # 获取文件名 ***
    print(os.path.exists(r"F:s24day171 今日内容.py"))  # 判断这个路径是否存在  ***
    print(os.path.isdir(r"F:s24day17"))     # 判断是不是路径  ***
    print(os.path.isfile(r"01 今日内容.py"))  # 判断是不是文件  ***
    print(os.path.isabs(r"F:s24day171 今日内容.py"))     # 判断是不是绝对路径 ***
    print(os.path.join("D:\\","ttt","bbb"))                # 路径拼接 *****
    print(os.path.getatime(r"F:s24day174 序列化.py"))      # 最后的修改时间
    print(os.path.getctime(r"F:s24day174 序列化.py"))      # 最后的访问时间
    print(os.path.getmtime(r"F:s24day174 序列化.py"))      # 最后的访问时间
    print(os.path.getsize(r"F:s24day09"))                       # 获取当前文件的大小   ***
    

    6. sys模块

    sys模块是与python解释器交互的一个接口

    import sys
    if sys.argv[-1] == "alex":
        print("dsb")
    else:
        print("cjb")
    print(sys.argv[-1])  
    # 当前文件运行['F:/s24/day17/06 sys.py'] ***
    
    import sys
    print(sys.exit(1))   #退出程序,正常退出时exit(0),错误退出sys.exit(1)
    print(sys.version)  # 获取解释器版本
    print(sys.path)     # 添加自定义模块查找路径 *****
    print(sys.platform)   # *** 区分操作系统然后进行相关逻辑操作
    

    7. hashlib模块

    加密和校验

    md5,sha1,sha256,sha512
    1.只要明文相同密文就是相同的
    2.只要明文不相同密文就是不相同的
    3.不能反逆(不能解密) -- md5中国人破解了

    加密:
    1.加密的内容
    2.将要加密的内容转成字节

    import hashlib
    md5 = hashlib.md5()  # 加密初始化
    md5.update("alex123".encode("utf-8"))
    print(md5.hexdigest())
    

    加盐(固态/动态)

    import hashlib
    md5 = hashlib.md5("alex".encode("utf-8"))  
    md5.update("alex123".encode("utf-8"))
    print(md5.hexdigest())
    

    8. collections模块

    1.namedtuple生成可以使用名字来访问元素内容的tuple

    from collections import namedtuple
    Point = namedtuple('Point', ['x', 'y'])
    p = Point(1, 2)
    print(p)
    # Point(x=1, y=2)
    

    2.deque: 双端队列,可以快速的从另外一侧追加和推出对象

    from collections import deque
    q = deque(['a', 'b', 'c'])
    q.append('x')
    q.appendleft('y')
    print(q)
    # deque(['y', 'a', 'b', 'c', 'x'])
    

    队列: 先进先出

    栈: 先进后出

    3.OrderedDict: 有序字典

    od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
    print(od)
    # OrderedDict([('a', 1), ('b', 2), ('c', 3)])
    

    4.defaultdict: 带有默认值的字典

    from collections import defaultdict
    values = [11, 22, 33,44,55,66,77,88,99,90]
    my_dict = defaultdict(list)
    for value in  values:
        if value>66:
            my_dict['k1'].append(value)
        else:
            my_dict['k2'].append(value)
    

    5.Counter: 计数器,主要用来计数

    from collections import Counter
    c = Counter('abcdeabc')
    print(c)
    # Counter({'a': 2, 'b': 2, 'c': 2, 'd': 1})
    

    9. re模块 (正则表达式)

    # w 匹配字母(包含中文)或数字或下划线 
    import re
    name = "宝元-meet_123 "
    print(re.findall("w",name))
    # ['宝', '元', 'm', 'e', 'e', 't', '_', '1', '2', '3']
    # W 匹配非字母(包含中文)或数字或下划线 
    # s 匹配任意的空白符 
    # S 匹配任意非空白符 
    # d 匹配数字 
    # D 匹配非数字 
    # A 从字符串开头匹配 
    #  匹配字符串的结束,如果是换行,只匹配到换行前的结果 
    # 
     匹配一个换行符 
    # 	 匹配一个制表符 
    # ^ 匹配字符串的开始 
    # $ 匹配字符串的结尾 
    # . 匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符。 
    import re
    name = "宝元-meet_123	 
    "
    print(re.findall(".",name))
    # ['宝', '元', '-', 'm', 'e', 'e', 't', '_', '1', '2', '3', '	', ' ']
    print(re.findall(".",name,re.DOTALL))
    # ['宝', '元', '-', 'm', 'e', 'e', 't', '_', '1', '2', '3', '	', '
    ']
    # [...] 匹配字符组中的字符 
    print(re.findall("[a-z]",s))
    # [^...] 匹配除了字符组中的字符的所有字符 
    # * 匹配0个或者多个左边的字符。 
    # + 匹配一个或者多个左边的字符。 
    # ? 匹配0个或者1个左边的字符,非贪婪方式。 
    # {n} 精准匹配n个前面的表达式。 
    # {n,m} 匹配n到m次由前面的正则表达式定义的片段,贪婪方式 
    # a|b 匹配a或者b 
    # () 匹配括号内的表达式,也表示一个组 
    import re
    print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb'))
    # ['alex', ' wusir', ' 日天']
    print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>')
    # ['http://www.baidu.com']
    

    1.findall 全部找到,返回一个列表

    2.search 从字符串中任意位置进行匹配查找到一个就停止了,返回的是一个对象. 获取匹配的内容必须使用.group()进行获取

    3.match 只在字符串开始位置进行匹配

    4.split 分隔 可按照任意分隔符进行分隔

    5.sub 替换

    6.compile 定义匹配规则

    obj = re.compile("w")
    print(obj.findall("meet_宝元_常鑫垃圾"))
    

    7.finditer 返回一个迭代器

    import re
    g = re.finditer('al',"alex_alsb,al22,aladf")
    print(next(g).group())
    print([i.group() for i in g])
    # al
    # ['al','al','al']
    
  • 相关阅读:
    朴英敏: 用crash工具分析Linux内核死锁的一次实战【转】
    ext3,ext4,xfs和btrfs文件系统性能对比【转】
    STM32MP157——Remoteproc和RPMsg【转】
    使用edac工具来检测服务器内存故障.【转】
    面试题-python 什么是生成器(generator)?
    面试题-python 什么是迭代器(Iterator)?
    面试题-python 浅拷贝和深拷贝(copy模块)
    selenium+python自动化104-如何获取隐藏元素text文本
    面试题-websocket 接口如何测试?
    jmeter压测学习47-发soap请求测试webservice接口
  • 原文地址:https://www.cnblogs.com/lav3nder/p/11801807.html
Copyright © 2020-2023  润新知