模块
整形
浮点型
字符串
列表
字典
集合
元组
布尔值
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'))
