Python模块简介

标签：多行   伦敦   文件夹   enum   完整   key   删除   list   之间   

模块

整形
浮点型
字符串
列表
字典
集合
元组
布尔值

collection模块

# namedtuple：具名元组
from collections import namedtuple				 # 导入模块方式
point = namedtuple(‘坐标‘,[‘x‘,‘y‘])				# 关键字namedtuple
p = point(1,2)
print(p)
print(p.x)
print(p.y)

city = namedtuple(‘日本‘,‘name person size‘)
c = city(‘东京‘,‘R老师‘,‘L‘)
print(c)
print(c.name)
print(c.person)
print(c.size)

# queue：队列
import queue
q = queue.Queue()   # 生成队列对象
q.put(‘first‘)      # 往队列塞值
q.put(‘second‘)
q.put(‘third‘)

print(q.get())      # 朝队列要值，如果队列取完了，程序会在原地等待，直到队列中拿到值为止

# deque:双端队列（先进先出FIFO first in first out）
"""
append
appendleft
pop
popleft
"""
from collections import deque       # 导入双端队列
q = deque([‘a‘,‘b‘,‘c‘])
q.append(1)                         # 在右侧插入值
q.appendleft(2)                     # 在左侧插入值
# print(q.pop())                    # 1
# print(q.popleft())                # 2
q.insert(0,‘哈哈哈‘)                 # 直接插队在索引0的位置指定内容
print(q.popleft())                  # 哈哈哈

"""
队列不应该支持任意位置插值
只能在首尾插值（不能插队）
"""



# Counter:计数器
案例：将s中的每个单词作为key出现次数对应value 使用Counter模块实现
from collections import Counter
s = ‘abcdeabcdabccaba‘
res = Counter(s)
print(res)

# ORderedDict:有序字典
normal_d = dict([(‘a‘,1),(‘b‘,2),(‘c‘,3)])
print(normal_d)                         # {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

from collections import OrderedDict
order_d = OrderedDict([(‘a‘,1),(‘b‘,2),(‘c‘,3)])
print(order_d)                          # OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])

order_d1 = OrderedDict()
order_d1[‘x‘] = 1
order_d1[‘y‘] = 2
order_d1[‘z‘] = 3
for i in order_d1:                      # x y z   输出结果是有序的
    print(i)

order_d2 = dict()
order_d2[‘x‘] = 1
order_d2[‘y‘] = 2
order_d2[‘z‘] = 3
print(order_d2)
for i in order_d2:
    print(i)                            # y x z   输出结果是无序的
    
    
# defaultdict:带有默认值的字典
案例：列表值大于66那么字典的key为k1，反之字典的key为k2
from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99]
my_dict = defaultdict(list)                 # 后续该字典中新建的key对应的value默认就是列表
for i in values:
    if i > 66:
        my_dict[‘k1‘].append(i)
    else:
        my_dict[‘k2‘].append(i)

print(my_dict)                              # defaultdict(<class ‘list‘>, {‘k2‘: [11, 22, 33, 44, 55, 66], ‘k1‘: [77, 88, 99]})

时间模块

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

"""
三种表现形式：
    1. 时间戳(秒数)
    2. 格式化时间（用来展示给人看的）
    3. 结构化时间
"""
# 1. 时间戳
import time
print(time.time())                      # 1614324839.1989524

# 2. 格式化时间
import time
print(time.strftime(‘%Y-%m-%d‘))        # 2021-02-26

# 3. 结构化时间
import time
print(time.localtime())                 # time.struct_time(tm_year=2021, tm_mon=2, tm_mday=26, tm_hour=15, tm_min=44, tm_sec=44, tm_wday=4, tm_yday=57, tm_isdst=0)

• 格式转换关系

• 时间戳转结构化时间

#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳　
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0

• 结构化时间转格式化时间

#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则显示当前时间
>>>time.strftime("%Y-%m-%d %X")
‘2017-07-24 14:55:36‘
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
‘2017-07-14‘

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
‘Fri Jul 14 10:40:00 2017‘
>>>time.asctime()
‘Mon Jul 24 15:18:33 2017‘

#时间戳 --> %a %b %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
>>>time.ctime()
‘Mon Jul 24 15:19:07 2017‘
>>>time.ctime(1500000000)
‘Fri Jul 14 10:40:00 2017‘

import time
true_time=time.mktime(time.strptime(‘2017-09-11 08:30:00‘,‘%Y-%m-%d %H:%M:%S‘))
time_now=time.mktime(time.strptime(‘2017-09-12 11:00:00‘,‘%Y-%m-%d %H:%M:%S‘))
dif_time=time_now-true_time
struct_time=time.gmtime(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))

datetime模块

import datetime

# 自定义日期
res = datetime.date(2019, 7, 15)
print(res)  # 2019-07-15

# 获取本地时间
# 年月日
now_date = datetime.date.today()
print(now_date)  # 2019-07-01
# 年月日时分秒
now_time = datetime.datetime.today()
print(now_time)  # 2019-07-01 17:46:08.214170

# 无论是年月日，还是年月日时分秒对象都可以调用以下方法获取针对性的数据
# 以datetime对象举例
print(now_time.year)  # 获取年份2019
print(now_time.month)  # 获取月份7
print(now_time.day)  # 获取日1
print(now_time.weekday())  # 获取星期(weekday星期是0-6) 0表示周一
print(now_time.isoweekday())  # 获取星期(weekday星期是1-7) 1表示周一

# timedelta对象
# 可以对时间进行运算操作
import datetime

# 获得本地日期 年月日
tday = datetime.date.today()
# 定义操作时间 day=7 也就是可以对另一个时间对象加7天或者减少7点
tdelta = datetime.timedelta(days=7)

# 打印今天的日期
print(‘今天的日期:{}‘.format(tday))  # 2019-07-01
# 打印七天后的日期
print(‘从今天向后推7天:{}‘.format(tday + tdelta))  # 2019-07-08
# 总结:日期对象与timedelta之间的关系
"""
日期对象 = 日期对象 +/- timedelta对象
timedelta对象 = 日期对象 +/- 日期对象

验证:

"""
# 定义日期对象
now_date1 = datetime.date.today()
# 定义timedelta对象
lta = datetime.timedelta(days=6)
now_date2 = now_date1 + lta  # 日期对象 = 日期对象 +/- timedelta对象
print(type(now_date2))  # <class ‘datetime.date‘>
lta2 = now_date1 - now_date2  # timedelta对象 = 日期对象 +/- 日期对象
print(type(lta2))  # <class ‘datetime.timedelta‘>


# 小练习 计算举例今年过生日还有多少天
birthday = datetime.date(2019, 12, 21)
now_date = datetime.date.today()
days = birthday - now_date
print(‘生日：{}‘.format(birthday))
print(‘今天的日期：{}‘.format(tday))
print(‘距离生日还有{}天‘.format(days))


# 总结年月日时分秒及时区问题
import datetime

dt_today = datetime.datetime.today()
dt_now = datetime.datetime.now()
dt_utcnow = datetime.datetime.utcnow()  # UTC时间与我们的北京时间cha ju

print(dt_today)
print(dt_now)
print(dt_utcnow)

生成随机验证码

# 生成随机验证码
"""
验证码构成：
    大写字母  小写字母 数字
    
要求：
    生成5位数的随机验证码
    chr
    random.choice
    
思路：
    1. 先取出随机大写字母 小写字母 数字
    2. for循环五次 在for循环上方定义空字符串名
    3. 将int类型转换为str类型 进而实现后续五个字符拼接
    4. 定义函数，用户随机取出任意位数验证码
    
ps:
	A-Z 65-90
	z-z 97-122
"""

def get_code(n):
    code = ‘‘
    for i in range(n):
        # 先生成随机的大写字母 小写字母或者数字
        upper_str = chr(random.randint(65,90))          # 无法直接找到大写字母，所以先找到ASCII表对应的数字，用chr将对应数字转换为大写，再通过随机模块，取出对应的大写英文
        lower_str = chr(random.randint(97,122))         # 通过ASCII取出对应随机小写字母
        random_int = str(random.randint(0,9))          # 随机取出数字0-9中任意数字并将int转为str
        # 从上面三个中随机选择一个作为随机验证码的某一位
        code += random.choice([upper_str,lower_str,random_int])     # code在for循环上原本是空，每循环一次字符串拼接一位，随之产生五位数的验证码
    return code

res = get_code(5)
print(res)

# ps: 验证码忽略大小写的内部原理：
	后端代码统一转换成大写或者小写进行比对

os模块

"""
os模块是和操作系统打交道的模块
sys模块是和python解释器打交道的模块
"""
# 案例：将目录下的文件列出给用户选择，根据用户选择打开对应文件
import os
BASE_DIR = os.path.dirname(__file__)    # 获取执行文件所在目录的路径
MOVIE_DIR = os.path.join(BASE_DIR,‘老师们的作品‘)     # 在当前路径的上一级路径中找到目录
movie_list = os.listdir(MOVIE_DIR)      # 列出路径下的文件
while True:
    for i,j in enumerate(movie_list,1):
        print(i,j)                      # 输出老师们的作品有哪些
    choice = input(‘你想看谁的啊(今日热搜：tank老师)>>‘).strip()     # 让用户选择
    if choice.isdigit():                # 判断用户选择的是否是一个数字
        choice = int(choice)            # 用户选择的只是一个字符类型的整形，需要转为整形
        if choice in range(1,len(movie_list)+1):    # 判断是在列表顾头不顾尾，所以需要加1
            # 获取用户想看的文件名
            target_file = movie_list[choice-1]      # movie_list是从1开始 需要减1
            # 拼接文件绝对路径
            target_path = os.path.join(MOVIE_DIR,target_file)
            with open(target_path,‘r‘,encoding=‘utf-8‘) as f:
                print(f.read())
                

os.mkdir(‘tank老师精选‘)                                	    # 自动创建文件夹
print(os.path.exists(r‘F:\py_learn\老师们的作品‘))               # 判断文件或者文件夹是否存在
print(os.path.isfile(r‘F:\py_learn\老师们的作品\明老师.txt‘))    # 判断文件是否存在，不支持判断文件夹

os.rmdir(r‘F:\py_learn\老师们的作品‘)                      # 只能删除空文件夹，文件夹不为空则无法删除

print(os.getcwd())                                        # 获取当前所在路径
print(os.chdir(r‘F:\py_learn\老师们的作品‘))               # 切换路径
print(os.getcwd())                                        # 再次获取路径，已经改变为切换的路径

# 获取文件大小
print(os.path.getsize(r‘F:\py_learn\老师们的作品\明老师.txt‘))           # 获取字节大小
with open(r‘F:\py_learn\老师们的作品\明老师.txt‘,encoding=‘utf-8‘) as f: # 获取字符个数
	print(len(f.read()))

sys模块

# 和python解释器打交道

import sys
sys.path.append()             # 将某个路径添加至环境变量中
print(sys.version)            # 打印python解释器版本

print(sys.argv)			       # [‘F:/py_learn/re模块.py‘]
username = sys.argv[1]          # 类似于shell中的$1传参 这里获取第一个参数
password = sys.argv[2]          # 获取执行py文件的第二个参数
if username == ‘jason‘ and password == ‘123‘:
	print(‘欢迎使用‘)

序列化模块

"""
# 序列化
    序列：字符串
    序列化：其他数据类型转换成字符串的过程

写入文件的数据必须是字符串或者是二进制，因为只有字符串才能转换成二进制，所以写入文件的内容必须是字符串
基于网络传输的数据必须是二进制

    序列化：其他数据类型转换成字符串的过程
    反序列化：字符串转换成其他数据类型的过程

# 序列化模块：
    json模块：
        所有的语言都支持json格式 支持的数据类型很少
        支持的数据类型：字符串 列表 字典 数字 元组（转成列表） 布尔值
    pickle模块：
        只支持python语言 python所有的数据类型都支持
          
"""


"""
json模块指南：
    dumps：序列化 将其他类型的数据类型转换为字符串
    loads：反序列化 将字符串转换为其他类型
    dump：dump方法接收一个文件句柄，直接将其他类型换成json字符串写入文件
    load：load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
    
# 使用记忆方式：
	dumps和loads是直接对数据结构进行处理
	dump和load是对文本进行处理
"""

# 序列化与反序列化：
import json
d = {‘name‘:‘jason‘}
res = json.dumps(d)                 # 将字典转换为json格式，json格式的字符串 必须是双引号，外部单引号，内部双引号
print(res,type(res))                # {"name": "jason"} <class ‘str‘>

res1 = json.loads(res)              # 将json格式转换为字典
print(res1,type(res1))              # {‘name‘: ‘jason‘} <class ‘dict‘>


# 案例一：将字典存储到文本中，并且转换为字符串格式，然后又将文本中字符串格式内容取出，转为字典
d = {‘name‘:‘jason‘}
with open(‘userinfo‘,‘w‘,encoding=‘utf-8‘) as f:
     json.dump(d,f)              # 先转成字符串并启动写入文件，结果：userinfo文件中增加内容{‘name‘:‘jason‘}（字符串格式形式存储）
with open(‘userinfo‘,‘r‘,encoding=‘utf-8‘) as f:
     res = json.load(f)
     print(res,type(res))         # 将字符串从文本中取出，并恢复原本的数据类型


# 案例二：将多行字典存储到文本中，并实现格式转换（注意：字典存储在文本中必须一行一个字典，否则无法取出）
with open(‘userinfo‘,‘w‘,encoding=‘utf-8‘) as f:        # 将多个字典存储到同一个文本中，并且通过json.dumps转换为字符串
    res = json.dumps(d)
    res1 = json.dumps(d)
    f.write(‘%s\n‘%res)
    f.write(‘%s\n‘%res1)

with open(‘userinfo‘,‘r‘,encoding=‘utf-8‘) as f:        # 将文本中的字符串转换为字典
    for i in f:
        res = json.loads(i)
        print(res,type(res))                            # {‘name‘: ‘jason‘} <class ‘dict‘>

# 注意：
t = (1,2,3,4)
res = json.dumps(t)
print(res,type(res))                # [1, 2, 3, 4] <class ‘str‘> 元组转字符串会转换为列表形式

a = {‘name‘:‘葬爱汤哥‘}
print(json.dumps(a))                            # {"name": "\u846c\u7231\u6c64\u54e5"}  中文会进行转码
print(json.dumps(a,ensure_ascii=False))         # {"name": "葬爱汤哥"}这样就不会进行转码


"""
用pickle操作文件的时候  文件的打开模式必须是b模式
"""

import pickle
d = {‘name‘:‘jason‘}
res = pickle.dumps(d)       # 将对象转换为二进制
print(res,type(res))        # b‘\x80\x03}q\x00X\x04\x00\x00\x00nameq\x01X\x05\x00\x00\x00jasonq\x02s.‘ <class ‘bytes‘>

res1 = pickle.loads(res)    			# 将二进制转换为字典
print(res1,type(res1))      			# {‘name‘: ‘jason‘} <class ‘dict‘>

with open(‘userinfo‘,‘wb‘) as f:         # 因为pickle模块存储会转换为二进制格式，所以写入方式为wb
      pickle.dump(d,f)                   # 同样直接操作文件需要用dump而不是dumps

with open(‘userinfo‘,‘rb‘) as f:
    res = pickle.load(f)
    print(res,type(res))                  # {‘name‘: ‘jason‘} <class ‘dict‘>

subprocess模块

"""
sub: 子
process： 进程
"""

import subprocess
obj = subprocess.Popen(‘xxxxx‘,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(‘stdout‘,obj.stdout.read().decode(‘gbk‘))        # 打印正确输出结果
print(‘stderr‘,obj.stderr.read().decode(‘gbk‘))        # 打印错误输出结果

# 模拟cmd界面，循环输入指令
while True:
     cmd = input(‘cmd>>>:‘).strip()
     import subprocess
     obj = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
     print(‘正确命令返回结果stdout‘,obj.stdout.read().decode(‘gbk‘))
     print(‘错误命令返回结果stderr‘,obj.stderr.read().decode(‘gbk‘))

Python模块简介

标签：多行   伦敦   文件夹   enum   完整   key   删除   list   之间   

原文地址：https://www.cnblogs.com/tcy1/p/14468483.html