文件操作
1.文件的概念
就是操作系统暴露给用户操作硬盘的快捷方式
eg:双击一个文件 其实是从硬盘将数据加载到内存
ctrl+s保存文件 其实是将内存中的数据刷到硬盘保存
2.代码打开文件的两种方式
方式1:
f = open(文件路径,读写模式,encoding='utf8')
f.close()
方式2:
with open('a.txt', 'r', encoding='utf8') as f1:
with子代码块
ps:with上下文管理好处在于子代码运行结束自动调用close方法关闭资源
"""
open方法的第一个参数是文件路径 并且撬棍跟一些字母的组合会产生特殊的含义导致路径查找混乱 为了解决该问题可以在字符串的路径前面加字母r
D:\a\n\t
r'D:\a\n\t'
以后涉及到路径的编写 推荐加上r
with支持一次性打开多个文件
with open() as f1,open() as f2,open() as f3:
子代码
"""
文件读写模式
'r' 只读模式:只能读不能写
# 1.文件路径不存在:会直接报错
# with open(r'b.txt','r',encoding='utf8') as f:
# print(f.read())
# 2.文件路径存在:正常读取文件内容
with open(r'a.txt', 'r', encoding='utf8') as f:
print(f.read())
'w' 只写模式:只能写不能看
# 1.文件路径不存在:自动创建
# with open(r'b.txt', 'w', encoding='utf8') as f:
# pass
# 2.文件路径存在:先清空文件内容 之后再写入
with open(r'a.txt', 'w', encoding='utf8') as f:
f.write('假期综合征 赶紧要调整\n')
f.write('假期综合征 赶紧要调整\n')
f.write('假期综合征 赶紧要调整\n')
'''强调:换行符需要自己添加 并且在后续数据读取比对的时候也一定要注意它的存在'''
'a' 只追加模式:文件末尾添加数据
# 1.文件路径不存在:自动创建
# with open(r'c.txt', 'a', encoding='utf8') as f:
# pass
# 2.文件路径存在:自动在末尾等待追加内容
with open(r'a.txt', 'a', encoding='utf8') as f:
f.write('放假七天和上班七天感觉是完全不一样的')
"""
当我们在编写代码的时候 有些部分不知道写什么具体代码 但是也不能空着不写
这个时候可以使用关键字
pass
...
文件操作模式
t 文本模式
默认的模式 我们上面所写的r w a其实全称是 rt wt at
1.只能操作文本文件
2.读写都是以字符为单位
3.需要指定encoding参数 如果不知道则会采用计算机默认的编码
b 二进制模式(bytes模式)
不是默认的模式 需要自己指定 rb wb ab
1.可以操作任意类型的文件
2.读写都是以bytes为单位
3.不需要指定encoding参数 因为它已经是二进制模式了 不需要编码
二进制模式与文本模式针对文件路径是否存在的情况下 规律是一样的!!!
文件诸多方法
1.read()
一次性读取文件内容 并且光标停留在文件末尾 继续读取则没有内容
并且当文件内容比较多的时候 该方法还可能会造成计算机内存溢出
括号内还可以填写数字 在文本模式下 表示读取几个字符
2.for循环
一行行读取文件内容 避免内存溢出现象的产生
3.readline()
一次只读一行内容
4.readlines()
一次性读取文件内容 会按照行数组织成列表的一个个数据值
5.readable()
判断文件是否具备读数据的能力
6.write()
写入数据
7.writeable()
判断文件是否具备写数据的能力
8.writelines()
接收一个列表 一次性将列表中所有的数据值写入
9.flush()
将内存中文件数据立刻刷到硬盘 等价于ctrl + s
文件内光标的移动
with open(r'a.txt', 'rb') as f: print(f.read()) f.seek(0,0) print(f.read()) f.seek(0, 0) print(f.read()) # print(f.read(2).decode('utf8')) # f.seek(-1, 2) # print(f.tell()) # 返回光标距离文件开头产生的字节数 """ seek(offset, whence) offset是位移量 以字节为单位 whence是模式 0 1 2 0是基于文件开头 文本和二进制模式都可以使用 1是基于当前位置 只有二进制模式可以使用 2是基于文件末尾 只有二进制模式可以使用 """ # print(f.read(3).decode('utf8'))
函数的语法结构
def 函数名（参数）：
"'函数注释'"
函数体代码
return 返回值
1.def
定义函数的关键字
2.函数名
命名等同于变量名
3.参数
可有可无，主要是在使用函数的时候规定要不要外界传数据进来
4.函数注释
就是说明书
5.函数体代码
是整个函数的核心，主要取决于程序员的编写
6.return
使用函数之后可以返回给使用者的数据，
函数的定义与调用
1.函数在定义阶段只检测语法，不执行代码
def func（）
pass
2.函数在调用阶段才会执行函数体代码
func（）
3.函数必须先定义后调用
4.函数定义使用关键字def 函数调用使用》》》：函数名加括号
如果有参数则需要在括号内按照相应的规则传递参数
函数的分类
1.空函数
函数体代码为空 使用的pass 或者...补全的空函数主要用于项目前期的功能框架搭建
def register（）：
"""注册功能"""
pass
2.无参函数
定义函数的时候括号内没有参数
def index（）
print（'from index function'）
3.有参函数
定义函数的时候括号内写参数，调用函数的时候括号传参数
def func（a）
print（a）
函数的返回值
1.什么是返回值
调用函数之后返回给调用者的结果
2.如何获取返回值
变量名 赋值符号 函数的调用
res = func（）# 先执行func函数，然后将返回值赋值给变量res
3.函数返回值的多种情况
3.1：函数体代码中没有return关键字，默认返回None
3.2：函数体代码有return,如果后面没有写如何东西还是None
3.3：函数体代码有return, 后面写什么就返回什么
3.4：函数体代码有return 并且后面有多个数据值，则自动组织成元组返回
3.5：函数体代码遇到return会立刻结束
函数的参数
形式参数
在函数定义阶段括号内填写的参数 简称'形参'
实际参数
在函数调用阶段括号内填写的参数 简称'实参'
"""
形参与实参的关系
形参类似于变量名，在函数定义阶段可以随便写，最好见名知意
def register (name,pwd):
pass
实参类似于数据值，在函数调用阶段与形参临时绑定，函数运行结束立刻断开
register（'jason',123）形参name与jason绑定，形参pwd与123绑定
"""
函数参数之位置参数
"""
短的，简单的靠前
长的 复杂靠后
同一个形参在调用的过程中不能多次赋值
"""
"""
补充：当子代码只有一行并且很简单的情况下，可以直接在冒号后编写，不用换行
"""
位置形参
函数定义阶段括号内从左到右依次填写的变量名
def func1(a,b,c):pass
位置实参
函数调用阶段括号内从左往右依次填写的数据值
funct1（1，2，3）
def func1(a,b):
print(a,b)
func1(1,2)
func1(1) # 少一个不行
func1(1, 2, 3) # 多一个也不行
func1(b=1, a=2) # 关键字传参(指名道姓的传)
func1(b=1, 2) # 关键字传参一定要跟在位置传参的后面 报错
func1(2, b=1) # 可以
func1(1, a=2, b=3) # 同一个形参在调用的时候不能多次赋值
name = 'jason'
pwd = 123
func1(name, pwd) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
func1(a=name, b=pwd) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
"""
越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列的情况除外
同一个形参在调用的时候不能多次赋值
"""
默认参数
本质其实就是关键字形参
别名叫默认参数：提前就已经给了，用户可以不传，也可以传
"""
默认参数的定义也遵循短的简单的靠前，长的复杂的靠后
"""
def regidter(name,age,gender='male'):
print(f"""
姓名：{name}
年龄:{age}
性别:{gender}
""")
regidter('lili',18,'male')
可变长形参
*号在形参中
用于接收多余的位置参数，组织成元组赋值给*号后面的变量名
**号在形参中
用于接收多余的关键字参数，组织成字典的形式赋值给**号后面的变量名
*在实参中
类似于for循环，将所有遍历出来的数据按照位置参数一次性传给函数
**在实参中
将字典打散成关键字参数的形式传递给函数
名称空间
name = 'jason'
1.申请内存空间存储jason
2.给jason绑定一个变量名name
3.后续通过变量名name就可以访问到jason
"""名称空间就是用来存储变量名与数据值绑定的关系，也可以理解为就是存储变量名的地方"""
1.1内置名称空间
解释器运行自动产生的，里面包含了很多名字
eg：len print input
2.2 全局名称空间
py文件运行产生里面存放文件级别的名字
3.3 局部名称空间
函数体代码运行、类似代码运行产生的空间
名称空间存活周期及作用范围
*存货周期
内置名称空间
python解释器启动则创建，关闭则销毁
全局名称空间
py文件执行则创建，运行结束则销毁
局部名称空间
函数体代码运行创建，函数体代码结束则销毁
*作用域
内置名称空间
解释器级别的全局有效
全局名称空间
py文件执行则创建，运行结束
局部名称空间
函数体代码内有效
名字的查找顺序
当我们到名字的查找，一定要先搞明白自己在哪个空间
1.当我们在局部名称空间中的时候
局部名称空间》》全局名称空间》》内置名称空间
2.当我们在全局名称空间中的时候
全局名称空间》》内置名称空间
global与nonlocal
global
"""局部名称空间直接修改全局名称空间中的数据"""
nonlocal
"""内部局部名称空间修改外层局部名称空间中的数据"""
函数名的多种用法
函数名其实绑定的也是一块内存地址，只不过该地址里面存放的不是数据值而是一段代码，函数名加括号就会找到该代码并执行
1.可以当做变量名赋值
def index()
pass
res = index
res()
2.可以当做函数的参数
def index()
print('from index')
def func(a)
print(a)
a()
3.可以当做函数的返回值
def index()
print('from index')
def func ():
print('from func')
return index
res = func()
print(res)
res
def index()
print('from index')
def func ()
print('from func')
retuen func
res = index()
print(res)
res()
闭包函数
"""
定义在函数内部的函数 ，并且用到了外部函数名称空间中的名字
1.定义在函数内容
2.用到外部函数名称空间中的名字
"""
给函数体代码传参的方法2：闭包函数
def outer(name,age):
def register():
print(f"""
姓名：{name}
年龄：{age}
""")
return register
res = outer('jason',18)
res()
res()
res = outer('kevin',28)
res()
res()
res()
装饰器简介
1.概念
在不改变被装饰对象原代码和调用方式的情况下给被装饰器对象添加新的功能
2.本质
并不是一门新的语言，而是由函数参数，名称空间，函数名多种用法，闭包函数组合到一起的结果
3.口诀
对修改封闭，对扩展开放
4.知识储备
时间相关操作
import time
print(time.time())
time.sleep(3)
print('该结束了吧')
# count = 0
# 循环之前先获取时间戳
# start_time = time.time()
# while count < 100:
# print('哈哈哈')
# count += 1
# end_time = time.time()
# print('循环消耗的时间:', end_time - start_time)
装饰器推导流程
import time
def index():
time.sleep(3)
print('from index')
def home():
time.sleep(1)
print('from home')
'''1.直接在调用index函数的前后添加代码'''
# start_time = time.time()
# index()
# end_time = time.time()
# print('函数index的执行时间为>>>:', end_time-start_time)
'''2.index调用的地方较多 代码不可能反复拷贝>>>:相同的代码需要在不同的位置反复执行>>>:函数'''
# def get_time():
# start_time = time.time()
# index()
# end_time = time.time()
# print('函数index的执行时间为>>>:', end_time - start_time)
# get_time()
'''3.函数体代码写死了 只能统计index的执行时间 如何才能做到统计更多的函数运行时间 直接传参变换统计的函数'''
# def get_time(xxx):
# start_time = time.time()
# xxx()
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# get_time(index)
# get_time(home)
'''4.虽然实现了一定的兼容性 但是并不符合装饰器的特征 第一种传参不写 只能考虑闭包'''
# def outer(xxx):
# # xxx = index
# def get_time():
# start_time = time.time()
# xxx()
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# res = outer(index)
# res()
# res1 = outer(home)
# res1()
'''5.调用方式还是不对 如何变形>>>:变量名赋值绑定 (******)'''
# def outer(xxx):
# def get_time():
# start_time = time.time()
# xxx()
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# res = outer(index) # 赋值符号的左边是一个变量名 可以随意命名
# res1 = outer(index)
# res2 = outer(index)
# jason = outer(index)
# index = outer(index)
# index()
# home = outer(home)
# home()
'''6.上述装饰器只能装饰无参函数 兼容性太差'''
# def func(a):
# time.sleep(0.1)
# print('from func', a)
#
# def func1(a,b):
# time.sleep(0.2)
# print('from func1', a, b)
#
# def func2():
# time.sleep(0.3)
# print('from func2')
# func(123)
# def outer(xxx):
# def get_time(a, b):
# start_time = time.time()
# xxx(a, b)
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# func1 = outer(func1)
# func1(1, 2)
# func = outer(func)
# func(1)
# func2 = outer(func2)
# func2()
'''7.被装饰的函数不知道有没有参数以及有几个参数 如何兼容'''
# def func(a):
# time.sleep(0.1)
# print('from func', a)
# def func1(a,b):
# time.sleep(0.2)
# print('from func1', a, b)
# def outer(xxx):
# def get_time(*args, **kwargs): # get_time(1,2,3) args=(1,2,3)
# start_time = time.time()
# xxx(*args, **kwargs) # xxx(*(1,2,3)) xxx(1,2,3)
# end_time = time.time()
# print('函数的执行时间为>>>:', end_time - start_time)
# return get_time
# func = outer(func)
# func(123)
# func1 = outer(func1)
# func1(1, 2)
'''8.如果被装饰的函数有返回值'''
def func(a):
time.sleep(0.1)
print('from func', a)
return 'func'
def func1(a,b):
time.sleep(0.2)
print('from func1', a, b)
return 'func1'
def outer(xxx):
def get_time(*args, **kwargs):
start_time = time.time()
res = xxx(*args, **kwargs)
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
return res
return get_time
# func = outer(func)
# res = func(123)
# print(res)
func1 = outer(func1)
res = func1(123, 123)
print(res)
装饰器模板
无参装饰器
def outer (func):
def inner(*args,**kwargs):
#执行被装饰对象之前可以做的额外操作
res = func(*args,**kwargs)
# 执行被装饰对象之后可以做的额外操作
return res
return inner
不常用的有参装饰器
# def outer_plus(mode):
# def outer(func_name):
# def inner(*args, **kwargs):
# res = func_name(*args, **kwargs)
# return res
# return inner
# return outer
# @outer_plus('MySQL')
# def func():
# pass
装饰器语法糖
def outer(func_name):
def inner(*args, **kwargs):
print('执行被装饰对象之前可以做的额外操作')
res = func_name(*args, **kwargs)
print('执行被装饰对象之后可以做的额外操作')
return res
return inner
"""
语法糖会自动将下面紧挨着的函数名当做第一个参数自动传给@函数调用
"""
@outer # func = outer(func)
def func():
print('from func')
return 'func'
@outer # index = outer(index)
def index():
print('from index')
return 'index'
func()
index()
三元表达式
作用：主要就是用来精简代码的
场景：当二选一的时候使用三元表达式更简单，但是不建议多个三元表达式嵌套
简化步骤1:代码简单并且只有一行 那么可以直接在冒号后面编写
name = 'jason'
if name == 'jason':print('老师')
else:print('学生')# 三元表达式
res = '老师' if name == 'jason' else '学生'
print(res)
"""
数据值1 if 条件 else 数据值2
条件成立则使用数据值1 条件不成立则使用数据值2
当结果是二选一的情况下 使用三元表达式较为简便
并且不推荐多个三元表达式嵌套
"""
各种生成式/表达式/推导式
name_list = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
给列表中所有人名的后面加上_NB的后缀
for循环
new_list = []
for name in name_list:
data = f'{name}_NB'
new_list.append(data)
print(new_list)
列表生成式
先看for循环 每次for循环之后再看for关键字前面的操作
new_list = [name + "_NB" for name in name_list]
print(new_list)
复杂情况
new_list = [name + "_NB" for name in name_list if name == 'jason']
print(new_list)
new_list = ['大佬' if name == 'jason' else '小赤佬' for name in name_list if name != 'jack']
print(new_list)
字典生成式
s1 = 'hello world'
for i,j in enumerate(s1,start=100):
print(i,j)
d1 = {i: j for i, j in enumerate('hello')}
print(d1)
集合生成式
res = {i for i in 'hello'}
print(res)
"""for循环s1字符串 并把一个一个字符给前面的数据操作上组成集合（集合自动去重且无序）"""
匿名函数
匿名函数就是没有名字的函数，要用关键字lambda
语法结构
lambda 形参:返回值
使用场景
lambda a,b:a+b
匿名函数一般不单独使用 需要配合其他函数一起用
常用内置函数
1.map() 映射
l1 = [1, 2, 3, 4, 5]
# def func(a):
# return a + 1
res = map(lambda x:x+1, l1)
print(list(res))
2.max()\min()
l1 = [11, 22, 33, 44]
res = max(l1)
d1 = {
'zj': 100,
'jason': 8888,
'berk': 99999999,
'oscar': 1
}
def func(a):
return d1.get(a)
# res = max(d1, key=lambda k: d1.get(k))
res = max(d1, key=func)
print(res)
3.reduce
# reduce 传多个值 返回一个值
from functools import reduce
l1 = [11, 22, 33, 44, 55, 66, 77, 88]
res = reduce(lambda a, b: a * b, l1)
print(res)
常见内置函数
1.abs（）
把数据值变成绝对值（正数）
print(abs(100)) # 100
print(abs(-100)) # 100
2.all()
判断容器类型中所有数据值对应的布尔值都是True结果就为True，否则结果就为False。类似and
print(all([1,2,3])) # True
print(all([0,1,2])) # False
3.any()
判断容器类型中所有数据值对应的布尔值有一个为True结果就是True。类似or
print(any([0,None,''])) # False
print(any([1,0,None,''])) # True
4.bin() oct() hex() int()
类型转换
print(bin(10)) # 十 >> 二
print(oct(10)) # 十 >> 八
print(hex(10)) # 十 >> 十六
`````````````````````````````
print(int(0b1010)) # 二 >> 十
print(int(0o12)) # 八 >> 十
print(int(0xa)) # 十六 >> 十
5.bytes()
类似于编码(encode)解码(decode)
s1='哈'
res=s1.encode('utf8') # 编码
print(res) # b'\xe5\x93\x88'
res1=res.decode() # 解码
print(res1) # 哈
``````````````````````````````
res=bytes(s1,'utf8') # 转为bytes类型用utf8
print(res) #结果为：b'\xe5\x93\x88'
res1=str(res,'utf8') # 转为字符串类型用utf8
print(res1) #结果为：哈
6.callable()
判断一个名字是否可以加括号调用
name = 'jason'
def func():
pass
print(callable(name)) # False
print(callable(func)) # True
7.chr() ord()
根据ASCII码表做数字与字母的转换
print(chr(65))#A
print(ord('A'))#65
8.dir()
获取对象内部可以通过句点符调用的方法名字
print(dir(name))
9.divmod()
获取除完后的整数与余数
i,j=divmod(10,2)
print(i,j)
#结果为：5 0
10.enumerate()枚举
for循环可迭代对象时还会同时产生一个默认从0开始的编号(括号里加start=1则是从1开始)
s1='abc'
for i,j in enumerate(l1,start=1)
print(i,j)
#结果为：1 a
# 2 b
# 3 c
11.eval() exec()
可以识别字符串中的python代码并执行。
两种用法相同,区别是第一个只能识别简单的结构,第二个可以识别复杂的结构
s1 = 'print(123)'
eval(s1) # 只能识别简单的结构
#结果为：123
——————————————————————————————————————
s2='for i in range(10):print(i)'
exec(s2) # 能识别复杂的结构
#结果为：循环打印1~9
12.hash()
给字符串用hash加密返回密文
print(hash('123'))
#结果为：5474369475686684015
13.id() input() isinstance()
id() # 获取对象的内存地址
s1='aaa'
print(id(s1)) # 2996384812336
````````````````````````````````
input() # 接收用户输入的信息
choice = input('输入指令：').strip()
`````````````````````````````````````
isinstance() # 判断某个数据类型是否属于某个数据类型
print(isinstance(123,int)) # True
print(isinstance(123,str)) # False
14.map() max() min()
map() # 映射(把一个东西经过函数操作变成另一个东西)
"""用匿名函数操作"""
res = map(lambda a:a+1,[1,2])
print(list(res)) #map类似一个工厂 获取数据要用list括起来
#结果为：[2,3]
``````````````````````````````````````````````````````
max()、 min() 求最大、最小值
#括号里默认不用传函数，如果字典要传函数比较V值，则用key=func自动加括号调用，先取出每一个值然后比较大小
__________________________________
【列表】：
#取列表中最大的数据值
l1=[1,2,3,4]
res=max(l1) # 底层也是用for循环取每一个数据值判断最大值
print(res) # 4
——————————————————————————————————
【字典】：
d1 = {
'zj': 100,
'jason': 8888,
'berk': 99999999,
'oscar': 1}
"""用匿名函数操作"""
res=max(d1,key=lambda a:d1.get(a))#max(key=lambda 形参:返回值,可迭代对象)
print(res)
#结果为：break 返回的结果是K键(比较用V值比较,返回K键)
15.open()
文件操作：打开一个文本文件
with open(r'a.txt','r',encoding='utf8')as f:
print(f.read())
#结果为：文件里的内容
16.pow()
求幂指数(次方)
print(pow(2,3)) # 8
print(pow(2,4)) # 16
17.range()
类似于一个工厂产生数据 python2中的xrange和python3中的range用法一样
for i in range(10):
print(i)
#结果为：打印0~9的数字
18.round()
五舍六入（python对数字不敏感！）
print(round(10.5)) # 10
print(round(10.6)) # 11
19.sum()
求和
l1=[1,2,3]
print(sum(l1)) # 6
20.zip()
就是把多个数据集用for循环依次取出然后分别组成元组。取结果是也类似工厂需要用list括起来
注意：当多个数据集个数不同时会按照最短的来拼接
eg:把以下数据集中的数据拼接为一个列表
l1 = [1,2,3,4]
s1 = 'abc'
t1 = (1,2,3,4)
res = zip(l1, s1, t1)
print(list(res))
#结果为：[(1,'a',1), (2,'b',2), (3,'c',3)]
还可以用解压赋值
可迭代对象
1.可迭代对象
对象内置有__iter__方法的都称为可迭代对象
"""
1.内置方法 通过点的方式能够调用的方法
2.__iter__ 双下iter方法
"""
2.可迭代对象的范围
不是可迭代对象
int float bool 函数对象
是可迭代对象
str list dict tuple set 文件对象
3.可迭代的含义
"""
迭代:更新换代(每次更新都必须依赖上一次的结果)
eg:手机app更新
"""
可迭代在python中可以理解为是否支持for循环
迭代器对象
1.可迭代对象
对象内置有__iter__方法的都称为可迭代对象
"""
1.内置方法 通过点的方式能够调用的方法
2.__iter__ 双下iter方法
"""
2.可迭代对象的范围
不是可迭代对象
int float bool 函数对象
是可迭代对象
str list dict tuple set 文件对象
3.可迭代的含义
"""
迭代:更新换代(每次更新都必须依赖上一次的结果)
eg:手机app更新
"""
可迭代在python中可以理解为是否支持for循环
for 循环的本质
for 变量名 in 可迭代对象：
循环体代码
1.先将in 后面的数据调用__iter__转为迭代器对象
2.依次让迭代器对象调用__next__取值
3.一旦__next__取不到值报错，for 循环会自动捕获