第四周总结
目录异常处理
异常常见类型
SyntaxError 语法错误
AttributeError 访问的对象属性不存在
ImportError 无法导入模块或者对象，主要是路径有误或名称错误
IndentationError 代码没有正确对齐，主要是缩进错误
IndexError 下标索引超出序列范围
IOError 输入/输出异常，主要是无法打开文件
KeyError 访问字典里不存在的键
NameError 访问一个未声明的变量
OverflowError 数值运算超出最大限制
SyntaxError python语法错误
TabError Tab和空格混用
TypeError 不同类型数据之间的无效操作（传入对象类型与要求的不符合）
ValueError 传入无效的值，即使值的类型是正确的
ZeroDivisionError 除法运算中除数0 或者 取模运算中模数为0
......
异常处理语法结构
1.基本语法结构
try:
待监测的代码(可能会出错的代码)
except 错误类型:
针对上述错误类型制定的方案
2.查看错误的信息
try:
待监测的代码(可能会出错的代码)
except 错误类型 as e: # e就是系统提示的错误信息
针对上述错误类型制定的方案
3.针对不同的错误类型制定不同的解决方案
try:
待监测的代码(可能会出错的代码)
except 错误类型1 as e: # e就是系统提示的错误信息
针对上述错误类型1制定的方案
except 错误类型2 as e: # e就是系统提示的错误信息
针对上述错误类型2制定的方案
except 错误类型3 as e: # e就是系统提示的错误信息
针对上述错误类型3制定的方案
...
4.万能异常 Exception/BaseException
try:
待监测的代码(可能会出错的代码)
except Exception as e: # e就是系统提示的错误信息
针对各种常见的错误类型全部统一处理
5.结合else使用
try:
待监测的代码(可能会出错的代码)
except Exception as e: # e就是系统提示的错误
针对各种常见的错误类型全部统一处理
else:
try的子代码正常运行结束没有任何的报错后 再执行else子代码
6.结合finally使用
try:
待监测的代码(可能会出错的代码)
except Exception as e: # e就是系统提示的错误信息
针对各种常见的错误类型全部统一处理
else:
try的子代码正常运行结束没有任何的报错后 再执行else子代码
finally:
无论try的子代码是否报错 最后都要执行finally子代码
异常处理补充
-
断言
assert语句的格式是[assert 表达式，返回数据]，当表达式为False时则触发AssertionError异常
try:
n=input("请输入一个数字:")
assert n.isdigit(),"只能输入数字"
print("你输入的是：",n)
except Exception as ex:
print("发现错误:",ex)
-
主动抛出异常
raise 语句的基本语法格式为：
raise [exceptionName [(reason)]]
其中，用 [] 括起来的为可选参数，其作用是指定抛出的异常名称，以及异常信息的相关描述。如果可选参数全部省略，则 raise 会把当前错误原样抛出；如果仅省略 (reason)，则在抛出异常时，将不附带任何的异常描述信息。
name = 'jason' if name == 'jason': raise Exception('老子不干了') else: print('正常走')
异常处理实战应用
1.异常处理能尽量少用就少用
2.被try监测的代码能尽量少就尽量少
3.当代码中可能会出现一些无法控制的情况报错才应该考虑使用
eg:使用手机访问网络软件 断网
编写网络爬虫程序请求数据 断网
简单练习
使用while循环+异常处理+迭代器对象 完成for循环迭代取值的功能
l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]
# 1.先将列表调用__iter__转变成迭代器对象
iter_l1 = l1.__iter__()
# 2.while循环让迭代器对象反复执行__next__
while True:
try:
print(iter_l1.__next__())
except StopIteration as e:
break
生成器
生成器对象
1.本质
还是内置有__iter__和__next__的迭代器对象
2.区别
迭代器对象是解释器自动提供的
数据类型\文件对象>>>:迭代器对象
生成器对象是程序员编写出来的
代码、关键字>>>:迭代器对象(生成器)
3.创建生成器的基本语法
函数体代码中填写yield关键字
def my_iter():
print('椰子汁nice')
yield
"""1.函数体代码中如果有yield关键字
那么函数名加括号并不会执行函数体代码
会生成一个生成器对象(迭代器对象)
"""
res = my_iter() # 生成器对象my_iter的内存地址绑定给变量名res
"""2.加了括号之后再调用__next__才会执行函数体代码"""
res.__next__() # 运行函数体代码 椰子汁nice
"""3.每次执行完__next__代码都会停在yield位置下次基于该位置继续往下找第二个yield"""
def my_iter():
print('哈哈哈 椰子汁good')
yield 111, 222, 333
print('呵呵呵 从小喝到大')
yield 444, 555, 666
print('嘿嘿嘿 特种兵牌还可以')
yield 777, 888, 999
print('哼哼哼 not good')
yield 1, 2, 3
res = my_iter()
r1 = res.__next__() # 哈哈哈 椰子汁good r1接收yield返回值
print(r1) # (111, 222, 333)
r2 = res.__next__() # 呵呵呵 从小喝到大
print(r2) # (444, 555, 666)
r3 = res.__next__() # 呵呵呵 从小喝到大
print(r3) # (777, 888, 999)
r4 = res.__next__() # 哼哼哼 not good
print(r4) # (1, 2, 3)
"""4.yield类似于return 可以返回返回值"""
yield冷门用法
def eat(name, food=None):
print(f'{name}准备用餐')
while True:
food = yield
print(f'{name}正在吃{food}')
res = eat('qyf')
res.__next__() # qyf准备用餐
res.send('kfc') # 1.将括号内的数据传给yield前面的变量名 2.再自动调用__next__ qyf正在吃kfc
res.send('coco') # qyf正在吃coco
res.send('a little little') # qyf正在吃a little little
生成器表达式
生成器简化写法
l1 = (i ** 2 for i in range(100)) # 生成器对象
print(l1) # <generator object <genexpr> at 0x000001DFC07F7E40>
for i in l1:
print(i)
"""
面试题(有难度)
大致知道流程即可
"""
def add(n, i): # 普通函数 返回两个数的和 求和函数
return n + i
def test(): # 生成器
for i in range(4):
yield i
g = test() # 激活生成器
for n in [1, 10]:
g = (add(n, i) for i in g)
"""
第一次for循环
g = (add(n, i) for i in g)
第二次for循环
g = (add(10, i) for i in (add(10, i) for i in g))
"""
res = list(g)
print(res)
#A. res=[10,11,12,13]
#B. res=[11,12,13,14]
#C. res=[20,21,22,23]
#D. res=[21,22,23,24]
'''不用深入研究 大致知道起始数即可'''
自定义生成器range
1.先写两个参数的
2.再写一个参数的
3.最后写三个参数的
'''自定义生成器对标range功能'''
# 两个参数的
def my_range(start_num, end_num):
while start_num < end_num:
yield start_num
start_num += 1
# 一个参数的
def my_range(start_num, end_num=None):
if not end_num:
end_num = start_num
start_num = 0
while start_num < end_num:
yield start_num
start_num += 1
# 三个参数的
def my_range(start_num, end_num=None, step=1): # 判断end_num是否有值 没有值说明用户只给了一个值 起始数字应该是0 终止位置应该是传的值
if not end_num:
end_num = start_num
start_num = 0
while start_num < end_num:
yield start_num
start_num += step
for循环底层运行
res = my_range(1, 10).__iter__()
while True:
try:
i = res.__next__() # for i in range(1, 10): print(i)
print(i)
except StopIteration:
break
索引取值与迭代取值的差异
l1 = [11, 22, 33, 44, 55]
1.索引取值
可以任意位置任意次数取值
不支持无序类型的数据取值
2.迭代取值
只能从前往后依次取值无法后退
支持所有类型的数据取值(无序有序)
ps:两者的使用需要结合实际应用场景
模块
模块简介
1.模块的本质
内部具有一定的功能(代码)的py文件
2.python模块的历史
python刚开始的时候所有搞其他编程语言的程序员都看不起 甚至给python起了个外号>>>:调包侠(贬义词)
随着时间的发展项目的复杂度越来越高 上面那帮人也不得不用一下python 然后发现真香定律>>>:调包侠(褒义词)
3.python模块的表现形式
1.py文件(py文件也可以称之为是模块文件)
2.含有多个py文件的文件夹(按照模块功能的不同划分不同的文件夹存储)
3.已被编译为共享库或DLL的C或C++拓展(了解)
4.使用C编写并链接到python解释器的内置模块(了解)
模块的分类
1.自定义模块
自己写的模块文件
2.内置模块
python解释器提供的模块
3.第三方模块
别人写的模块文件(python背后真正的大佬)
导入模块的两种句式
"""
强调:
1.一定要搞清楚谁是执行文件 谁是被导入文件
2.以后开发项目的时候py文件的名称一般是纯英文
不会含有中文甚至空格
01 作业详解.py 不会出现
test.py views.py 出现
3.导入模块文件不需要填写后缀名
"""
1.import句式
以import a为例研究底层原理
"""
1.先产生执行文件的名称空间
2.执行被导入文件的代码将产生的名字放入被导入文件的名称空间中
3.在执行文件的名称空间中产生一个模块的名字
4.在执行文件中使用该模块名以点的方式使用模块名称空间中所有的名字
"""
2.from...import...句式
以from a import name,func1为例研究底层原理
"""
1.先产生执行文件的名称空间
2.执行被导入文件的代码将产生的名字放入被导入文件的名称空间中
3.在执行文件的名称空间中产生对应的名字绑定模块名称空间中对应的名字
4.在执行文件中直接使用名字就可以访问名称空间中对应的名字
"""
导入模块的补充说明
1.import与from...import...两者优缺点
import句式
由于使用模块名称空间中的名字都需要模块名点的方式才可以用
所以不会轻易的被执行文件中的名字替换掉
但是每次使用模块名称空间中的名字都必须使用模块名点才可以
from...import...句式
指名道姓的导入模块名称空间中需要使用的名字 不需要模块名点
但是容易跟执行文件中名字冲突
2.重复导入模块
解释器只会导入一次 后续重复的导入语句并不会执行
3.起别名
import qianyufengyyds as yf
from qianyufengyyds import qianqianqianqianqian as qyf
from a import name as n,func1 as f1
4.涉及到多个模块导入
import a
import qianyufengyyds
如果模块功能相似度不高 推荐使用第一种 相似度高可以使用第二种
import a, qianyufengyyds
循环导入问题
1.循环导入
两个文件之间彼此导入彼此并且相互使用各自名称空间中的名字 极容易报错
2.如何解决循环导入问题
1.确保名字在使用之前就已经准备完毕
2.我们以后在编写代码的过程中应该尽可能避免出现循环导入
判断文件类型
所有的py文件都可以直接打印__name__对应的值
当py文件是执行文件的时候__name__对应的值是
__main__
当py文件是被导入文件的时候__name__对应的值是模块名
if__name__ == 'main':
print('我是执行文件 我可以运行这里的子代码')
上述脚本可以用来区分所在py文件内python代码的执行
使用场景
1.模块开发阶段
2.项目启动文件
"""
from a import *
*默认是将模块名称空间中所有的名字导入
__all__ = ['名字1'， '名字2'] 针对*可以限制拿的名字
"""
模块的查找顺序
先从内存中找，内存中没的话会去内置中找，内置中找不到的话会去sys.path中找(环境变量)
1.内存
import a # 创建一个a.py文件 里面定义一个name
import time
time.sleep(15) # 右键运行 然后将a.py删掉
print(a.name) # 最后会执行完毕 并打印a.name所对应的数据
2.内置
import time # 此时的time是自定义的time
print(time)
print(time.name) # 取自定义time中name的数据
# 运行会报错 因为当内存中没有time模块时会先去内置中找 内置中的time并没有name
3.执行文件所在的sys.path(系统环境变量)
当模块和执行文件不在同一个目录时 直接导入也是会报错的
可以将模块所在的路径也添加到执行文件的sys.path中即可
import sys
print(sys.path) # 查看系统环境变量 是一个列表
sys.path.append(r'模块的路径') # 是一个列表 所以可以通过列表的相关命令添加数据 先从内存中找，内存中没的话会去内置中找，内置中找不到的话会去sys.path中找(环境变量)
绝对导入与相对导入
"""
再次强调:一定要分清楚谁是执行文件!!!
模块的导入全部以执行文件为准
"""
绝对导入
from mymd.aaa.bbb.ccc.ddd import name # 可以精确到变量名
from mymd.aaa.bbb.ccc import ddd # 也可以精确到模块名
ps:套路就是按照项目根目录一层层往下查找
相对导入
.在路径中表示当前目录
..在路径中表示上一层目录
..\..在路径中表示上上一层目录
不在依据执行文件所在的sys.path 而是以模块自身路径为准
from . import b
相对导入只能用于模块文件中 不能在执行文件中使用
"""
相对导入使用频率较低 一般用绝对导入即可 结构更加清晰
"""
包的简介
大白话:多个py文件的集合>>>:文件夹
专业:内部含有__init__.py文件的文件夹(python2必须要求 python3无所谓)
包的具体使用
虽然python3对包的要求降低了 不需要__init__.py也可以识别 但是为了兼容性考虑 最好还是加上__init__.py
1.如果只想用包中某几个模块 那么还是按照之前的导入方式即可
from aaa import md1, md2
2.如果直接导入包名
import aaa
导入包名其实就是导包下面的__init__.py文件,该文件内有什么名字就可以通过包名点什么名字
若__init__.py文件没有导入包其他的模块 那么只能使用__init__文件中的名字其他模块中的名字并不能使用
编程思想与软件开发目录
编程思想的转变
1.面条版阶段
所有的代码全部堆叠在一起
2.函数版阶段
根据功能的不同封装不同的函数
3.模块版阶段
根据功能的不同拆分成不同的py文件
"""
第一个阶段可以看成是直接将所有的数据放在C盘
视频 音频 文本 图片
第二个阶段可以看成是将C盘下的数据分类管理
视频文件夹 音频文件夹 文本文件夹 图片文件夹
第三个阶段可以看成是将C盘下的数据根据功能的不同划分到更合适的位置
系统文件夹 C盘
视频文件夹 D盘
图片文件夹 E盘
ps:类似于开公司(小作坊 小公司 上市公司)
为了资源的高效管理
"""
软件开发目录规范
1.文件及目录的名字可以变换 但是思想是不变的 分类管理
2.目录规范主要规定开发程序的过程中针对不同的文件功能需要做不同的分类
myproject项目文件夹
1.bin文件夹 主要存放项目启动文件
start.py 启动文件可以放在bin目录下 也可以直接在项目根目录
2.conf文件夹 主要存放项目配置文件
settings.py 里面存放项目的默认配置 一般都是全大写
3.core文件夹 主要存放项目核心文件
src.py 里面存放项目核心功能
4.interface文件夹 主要存放项目接口文件
goods.py 根据具体业务逻辑划分对应的文件
user.py
account.py
5.db文件夹 主要存放项目相关数据
userinfo.txt
db_handler.py 存放数据库操作相关的代码
6.log文件夹 主要存放项目日志文件
log.log
7.lib文件夹 主要存放项目公共功能
common.py
8.readme文件 主要存放项目相关说明
9.requirements.txt文件 主要存放项目所需模块及版本
常见内置模块
collections模块
collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。
1.namedtuple: 生成可以使用名字来访问元素内容的tuple
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
队列与堆栈
队列:先进先出
堆栈:先进后出
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典
1.具名元组:namedtuple用法
我们知道tuple可以表示不变集合，例如，一个点的三维坐标就可以表示成：
# 表示三维坐标系
p = (1, 2, 5)
print(p) # (1, 2, 5)
但是，看到(1, 2，5)，很难看出这个tuple是用来表示一个三维坐标的。
此时，namedtuple就派上了用场：
from collections import namedtuple
# namedtuple('名称', [属性list]):
Point = namedtuple('Point', ['x', 'y', 'z'])
p = Point(1, 2, 5)
print(p) # point(x=1, y=2, z=5)
print(p.x, p.y, p.z) # 1 2 5
card = namedtuple('扑克牌', ['num', 'color'])
c1 = card('A', '黑♠')
c2 = card('A', '红♥')
print(c1, c1.num, c1.color) # 扑克牌(num='A', color='黑♠') A 黑♠
print(c2, c2.num, c2.color) # 扑克牌(num='A', color='红♥') A 红♥
2.deque的用法
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
from collections import deque
q = deque(['白给', '小钱', '小魏', '小李', '小白'])
q.append('小黑') # 默认添加在右侧尾部
print(q) # deque(['白给', '小钱', '小魏', '小李', '小白', '小黑'])
q.appendleft('python3')
print(q) # deque(['python3', '白给', '小钱', '小魏', '小李', '小白', '小黑'])
deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。
q.pop() # 默认从尾部删除
print(q) # deque(['白给', '小钱', '小魏', '小李'])
q.popleft() # 从头部删除，不能传值
print(q) # deque(['小钱', '小魏', '小李', '小白'])
3.Counter的用法
Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）
res = 'abcdeabcdabcaba'
from collections import Counter
ret = Counter(res)
print(ret) # Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
4.OrderedDict的用法
使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict：
from collections import OrderedDict
d = {'name': '小钱', 'age': 23, 'gender': 'male', 'id': 123}
d1 = OrderedDict(d)
print(d1) # OrderedDict([('name', '小钱'), ('age', 23), ('gender', 'male'), ('id', 123)])
print(d1['age']) # 获取key对应的值内容 23
注意：OrderedDict的Key会按照插入的顺序排列，不是Key本身排序
from collections import OrderedDict
d = OrderedDict()
d['name'] = '小钱'
d['age'] = 23
d['work'] = '摸鱼'
d['id'] = 123
print(d.keys()) # 按照插入的Key的顺序返回 odict_keys(['name', 'age', 'work', 'id'])
5.defaultdict的用法
方式一：原生字典解决方法
l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]
# {'k1':[小于60], 'k2':[大于60]}
# 1.先定义字典数据
new_dict = {'k1': [], 'k2': []}
# 2.for循环列表数据
for i in l1:
if i < 60:
new_dict.get('k1').append(i)
else:
new_dict.get('k2').append(i)
print(new_dict)
方式二：defaultdict字典解决方法
from collections import defaultdict
l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]
my_dict = defaultdict(list)
for i in l1:
if i < 60:
my_dict['k1'].append(i)
else:
my_dict['k2'].append(i)
print(my_dict) # defaultdict(<class 'list'>, {'k1': [11, 22, 33, 44, 55], 'k2': [66, 77, 88, 99]})
使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：
from collections import defaultdict
d = defaultdict(lambda: 'N/A')
d['name'] = '小钱'
print(d['name']) # name存在 返回值小钱
print(d['age']) # age不存在，返回默认值N/A
时间模块
1.三种时间表现形式
1.时间戳
秒数
2.结构化时间
主要是给计算机看的 人看不适应
3.格式化时间
主要是给人看的
2.python中时间日期格式化符号：
%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 当前时区的名称
%% %号本身
3.元组(struct_time) ：struct_time元组共有9个元素共九个元素
4.代码实战
import time
print(time.time()) # 从1970年1月1日00:00:00开始按秒计算的偏移量
print(time.localtime()) # 时间元组:localtime将一个时间戳转换为当前时区的 time.struct_time(tm_year=2022, tm_mon=10, tm_mday=19, tm_hour=16, tm_min=52, tm_sec=7, tm_wday=2, tm_yday=292, tm_isdst=0)
print(time.strftime('%Y-%m-%d')) # 年-月-日2022-10-19
print(time.strftime('%Y/%m/%d')) # 年/月/日2022/10/19
print(time.strftime('%Y/%m/%d %H:%M:%S')) # 年/月/日 时:分:秒 2022/10/19 16:55:01
print(time.strftime('%Y/%m/%d %X')) # 2022/10/19 16:55:01 %X = %H:%M:%S
time.sleep(10) # 让程序原地阻塞指定的秒数
import datetime
# 自定义日期
res = datetime.date(2019, 7, 15)
print(res) # 2019-07-15
print(datetime.datetime.now()) # 2022-10-19 16:57:09.997134 获取本地时间 年 月 日 时 分 秒
print(datetime.datetime.today()) # 2022-10-19 16:57:09.997134 获取本地时间 年 月 日 时 分 秒
print(datetime.date.today()) # 2022-10-19 获取本地时间 年月日
'''
datetime 年月日 时分秒
date 年月日
time 时分秒(后续会有此规律)
'''
from datetime import date, datetime
print(date.today()) # 2022-10-19
print(datetime.today()) # 2022-10-19 17:04:50.987897
print(datetime.utcnow()) # 2022-10-19 09:04:50.987896 UTC时间比我们本地早8小时
import datetime
c = datetime.datetime(2017, 5, 23, 12, 20)
print('指定日期：',c) # 指定日期： 2017-05-23 12:20:00
from datetime import datetime
d=datetime.strptime('2017/9/30','%Y/%m/%d')
print(d) # 2017-09-30 00:00:00
e=datetime.strptime('2017年9月30日星期六','%Y年%m月%d日星期六')
print(e) # 2017-09-30 00:00:00
f=datetime.strptime('2017年9月30日星期六8时42分24秒','%Y年%m月%d日星期六%H时%M分%S秒')
print(f) # 2017-09-30 08:42:24
import datetime
# 获得本地日期 年月日
ctime = datetime.date.today()
print(ctime) # 2022-10-19
# 定义操作时间 day=3 也就是可以对另一个时间对象加3天或者减少3天
time_del = datetime.timedelta(days=3)
print(ctime + time_del) # 2022-10-22
ctime = datetime.datetime.today()
print(ctime) # 2022-10-19 17:16:20.168040
time_del = datetime.timedelta(minutes=20)
print(ctime + time_del) # 2022-10-19 17:36:20.168040
随机数模块
import random
print(random.random()) # 随机产生0到1之间的小数
print(random.randint(1, 6)) # 随机产生1到6之间的整数
print(random.uniform(1,100)) # 产生一个 区间 的随机浮点数
print(random.randrange(1, 100, 2)) # 随机产生指定的整数
print(random.choice(['一等奖', '二等奖', '三等奖', '谢谢惠顾'])) # 随机抽取一个样本 '二等奖'
print(random.choices(['一等奖', '二等奖', '三等奖', '谢谢惠顾'])) # 随机抽取一个样本 ['二等奖']
print(random.sample(['jason', 'kevin', 'tony', 'oscar', 'jerry', 'tom'], 2)) # 随机抽指定样本数 ['tom', 'jerry']
l1 = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A']
random.shuffle(l1) # 随机打乱数据集
print(l1)
random实战验证码生成
'''产生图片验证码: 每一位都可以是大写字母 小写字母 数字 4位'''
def get_code(n):
code = ''
for i in range(n):
# 1.先产生随机的大写字母 小写字母 数字
random_upper = chr(random.randint(65, 90))
random_lower = chr(random.randint(97, 122))
random_int = str(random.randint(0, 9))
# 2.随机三选一
temp = random.choice([random_upper, random_lower, random_int])
code += temp
return code
res = get_code(10)
print(res)
res = get_code(4)
print(res)
os模块
import os
1.创建目录(文件夹)
os.mkdir(r'd1') # 相对路径 在执行文件所在的路径下创建目录 可以创建单级目录
os.mkdir(r'd2\d22\d222') # 报错 不可以创建多级目录
os.makedirs(r'd2\d22\d222') # 可以创建多级目录
os.makedirs(r'd3') # 也可以创建单级目录
2.删除目录(文件夹)
os.rmdir(r'd1') # 可以删除单级目录
os.rmdir(r'd2\d22\d222') # 不可以一次性删除多级目录
os.removedirs(r'd2\d22') # 可以删除多级目录
os.removedirs(r'd2\d22\d222\d2222) # 只能删除空的多级目录
os.rmdir(r'd3') # 只能删除空的单级目录
3.列举指定路径下内容名称
os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表。
注意：针对目录下有中文目录对情况，Python2 需要经过编码处理，但是在 Python3 中不需要已经没有 unicode() 方法，默认是 utf8 编码，所以需要转。
print(os.listdir()) # 默认返回当前执行文件所在路径下的文件及文件夹
print(os.listdir(r'D:\\')) # 指定返回D盘目录下的文件及文件夹
4.删除/重命名文件
os.rename(r'a.txt', r'aaa.txt') # 重命名
os.remove(r'aaa.txt') # 删除
5.获取/切换当前工作目录
print(os.getcwd()) # 获取当前执行文件的所在路径 D:\pythonProject\tests
os.chdir('..') # 切换到上一级目录
print(os.getcwd()) # D:\pythonProject
6.动态获取项目根路径(重要)
print(os.path.abspath(__file__)) # 获取执行文件的绝对路径 D:\pythonProject\tests\练习.py
print(os.path.dirname(__file__)) # 获取执行文件所在的目录路径 D:/pythonProject/tests
7.判断路径是否存在(文件、目录)
print(os.path.exists(r'练习.py')) # 判读文件路径是否存在 True
print(os.path.exists(r'D:/pythonProject/tests')) # 判断目录是否存在 True
print(os.path.isfile(r'练习.py')) # 判断路径上是否是文件 True
print(os.path.isfile(r'D:/pythonProject/tests')) # 判断路径是否是文件 False
print(os.path.isdir(r'练习.py')) # 判断对象是否为一个目录 False
print(os.path.isdir(r'D:/pythonProject/tests')) # 判断对象是否为一个目录 True
8.路径拼接
s1 = r'D:/pythonProject/tests'
s2 = r'练习.py'
# print(f'{s1}/{s2}')
"""
涉及到路径拼接一定不要自己做 因为不同的操作系统路径分隔符不一样
"""
print(os.path.join(s1, s2))
9.获取文件大小(字节)
print(os.path.getsize(r'a.txt'))
sys模块
sys模块主要与python解释器打交道
import sys
print(sys.path) # 获取执行文件的sys.path
# sys.path指定模块搜索路径的列表。默认情况下，python导入文件或者模块，会在sys.path里找模块的路径。如果在当前搜索路径列表sys.path中找不到该模块的话，就会报错。
print(sys.getrecursionlimit()) # 获取python解释器默认最大递归深度 1000
sys.setrecursionlimit(2000) # 修改python解释器默认最大递归深度
print(sys.version) # 3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC v.1927 64 bit (AMD64)] 获取Python解释程序的版本信息
print(sys.platform) # 获取当前系统平台 win32
res = sys.argv # 命令行参数,实现从程序外部向程序传递参数 用cmd终端执行
if len(res) != 3:
print('执行命令缺少了用户名或密码')
else:
username = res[1]
password = res[2]
if username == 'jason' and password == '123':
print('jason您好 文件正常执行')
else:
print('您不是jason无权执行该文件')
json模块
json模块理论
json模块也称为序列化模块 序列化可以打破语言限制实现不同编程语言之间数据交互
json模块的主要功能是将序列化数据从文件里读取出来或者存入文件
json格式数据的形式
字符串类型并且引号都是双引号
json相关操作
针对数据
json.dumps()
把python对象转换成json对象的一个过程，生成的是字符串
json.loads()
将json字符串转化为python对象
针对文件
json.dump()
将数据以json的数据类型写入文件中
json.load()
从json文件中读取数据,用来处理文件类型
json模块实战
import os
import json
# 注册功能
base_dir = os.path.dirname(__file__) # 1.获取执行文件所在的目录路径
db_dir = os.path.join(base_dir, 'db') # 2.拼接出db目录的路径
if not os.path.isdir(db_dir): # 3.创建db目录
os.mkdir(db_dir)
username = input('username>>>:').strip() # 4.用户输入
password = input('password>>>:').strip()
# 5.构造用户字典
user_dict = {
'username': username,
'password': password,
'account': 15000, # 账户余额
'shop_car': [] # 购物车
}
# 6.判断用户是否存在 两种方式
# user_json = f'{username}.jason' # 定义文件格式用于下方判断
# if user_json not in os.listdir(db_dir): # 获取db目录下所有文件 并判断
# user_info_path = os.path.join(db_dir, f'{username}.json') # 拼接文件路径
# with open(user_info_path, 'w', encoding='utf8') as f:
# json.dump(user_dict, f) # 将数据以json的数据类型写入文件
# print(f'{username}已注册成功')
# else:
# print('该用户已存在')
user_info_path = os.path.join(db_dir, f'{username}.json')
if os.path.isfile(user_info_path): # 判断路径是否是文件
print('用户已存在')
else:
with open(user_info_path, 'w', encoding='utf8') as f:
json.dump(user_dict, f)
print(f'{username}已注册成功')
# 用户登录
import os
import json
base_dir = os.path.dirname(__file__) # 1.获取执行文件所在的目录路径
db_dir = os.path.join(base_dir, 'db') # 2.拼接出db目录的路径
if not os.path.isdir(db_dir): # 3.创建db目录
os.mkdir(db_dir)
username = input('username>>>:').strip()
user_info_path = os.path.join(db_dir, f'{username}.json')
if not os.path.isfile(user_info_path):
print('你赶紧滚蛋 用户名都不对 搞什么飞机')
else:
password = input('password>>>:').strip()
# 2.获取用户真实数据字典
with open(user_info_path, 'r', encoding='utf8') as f:
real_user_dict = json.load(f)
if password == real_user_dict.get('password'):
print('登录成功')
print(real_user_dict)
else:
print('密码错误')