Python基础学习——文件操作、函数

#打开
f=open('a.txt',mode='r',encoding='utf-8')
# 读/写
data=f.read()
print(data)
#关闭
del f #回收Python的资源
f.close() ##回收操作的资源

with open('a.txt',mode='r',encoding='utf-8') as f:
print(f.read())

with open('a.txt',mode='r',encoding='utf-8') as f:
print(f.readlines()) #读所有行，结果放入列表中（适用于小文件）
print(f.readline(),end='') #读一行，去掉后面的换行符
print(f.read()) #读所有：bytes---->decode('utf-8')---->str

with open('b.txt',mode='w',encoding='utf-8') as f:
f.write('11111\n') #写一行 :unicode---->encode(utf-8)---->bytes
f.writelines(['881899\n','文件\n','qiiqwhuq']) ##写多行

with open('c.txt',mode='a',encoding='utf-8') as f:
f.write('1899\n')
f.writelines(['OK\n','权限\n'])

with open('weiduoliya.jpg',mode='rb') as f:
print(f.read()) with open('d.txt',mode='wb') as f:
f.write('alex最牛\n'.encode('utf-8')) with open('d.txt',mode='ab') as f:
f.write('engon最棒\n'.encode('utf-8'))

#. 打开文件的模式有(默认为文本模式)：
r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
a， 之追加写模式【不可读；不存在则创建；存在则只追加内容】#. 对于非文本文件，我们只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）
rb
wb
ab
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码#. 了解部分
"+" 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
a+， 写读【可读，可写】x， 只写模式【不可读；不存在则创建，存在则报错】
x+ ，写读【可读，可写】
xb

#掌握
f.read() #读取所有内容,光标移动到文件末尾
f.readline() #读取一行内容,光标移动到第二行首部
f.readlines() #读取每一行内容,存放于列表中f.write('1111\n222\n') #针对文本模式的写,需要自己写换行符
f.write('1111\n222\n'.encode('utf-8')) #针对b模式的写,需要自己写换行符
f.writelines(['333\n','444\n']) #文件模式
f.writelines([bytes('333\n',encoding='utf-8'),'444\n'.encode('utf-8')]) #b模式#了解
f.readable() #文件是否可读
f.truncate #_ 截取文件
f.writable() #文件是否可读
f.tell()#告知光标所在的位置
f.truncate #截取文件,以字节为单位
f.seek #指定光标移动到某个位置
f.closed #文件是否关闭
f.encoding #如果文件打开模式为b,则没有该属性
f.flush() #立刻将文件内容从内存刷到硬盘
f.name

import oswith open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
data=read_f.read() #全部读入内存,如果文件很大,会很卡
data=data.replace('alex','SB') #在内存中完成修改 write_f.write(data) #一次性写入新文件os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')

import oswith open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
for line in read_f:
line=line.replace('alex','SB')
write_f.write(line)os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')

x = 1
# print(bool(x))
if x:
print('ok')

with open('a.txt',encoding='utf-8') as f:
#不推荐使用：消耗资源（磁盘IO）
lines = f.readlines() #一下读取所有内容
for line in lines:
print(line,end='')
#推荐使用：读取一行，打印一行内容
for line in f:
print(line,end='')

#定义阶段
def tell_tag():
print('===========')def tell_msg(msg):
print(msg)#调用阶段
tell_tag()
tell_msg('hello world')

例如：len(),min(),max()

def 函数名(参数1,参数2,...):
"""注释"""
函数体
return 返回值

def foo():
xyz
print('')
return 1
print('')
return 2

无参：应用场景——只执行一些操作，例如：打印等等
有参：需要根据外部传进来的参数，才能执行相应的逻辑，例如比较大小，统计数量
空函数：设计代码结构

无参

有参：函数体的代码，需要外部传入的值

空函数：定义完函数，不输入函数体内容，直接输入pass

函数的调用：函数名加括号
先找到名字找到函数的内存地址，然后根据名字调用代码

什么时候该有返回值？
调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
什么时候不需要有返回值？
调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
通常无参函数不需要有返回值

在调用函数的过程中，一旦执行到return，就会立刻终止函数，并且把return后的结果当做本次调用的返回值返回
#函数体内可以有多个return，但是只能执行一次

def test():
print('test1')
# return 1
print('test2')
return 2
print('test3')
return 3
res=test()
print('函数调用完毕',res)

返回的值，可以是任意类型

#msg={'name':'wzs','sex':'male'}
msg=['wzs','egon']
def test():
print('test1')
return msg
res=test()
print('函数调用完毕',res)

没有返回值 —— 返回None
不写return
只写return:结束一个函数的继续
return None —— 不常用
返回1个值
可以返回任何数据类型
只要返回就可以接收到
如果在一个程序中有多个return，那么只执行第一个
返回多个值
用多个变量接收：有多少返回值就用多少变量接收
用一个变量接收: 得到的是一个元组（touple）

def test():
return None
res=test()
print('函数调用完毕',res,type(res))
print('函数调用完毕',res)

1 语句形式：foo()
2 表达式形式：3*len('hello')
3 当中另外一个函数的参数：range(len('hello'))

形参：在定义阶段,括号内定义的参数。就相当于变量名
实参：在调用阶段，括号内定义的参数。就相当于变量值
在调用阶段，实参的值会绑定给形参，在调用结束后，解除绑定

位置形参：必须被传值的参数，多少都不行
位置实参：从左到右依次赋值给形参

特性：
1、可以不依赖位置而指明参数给形参传参
2、可以与位置实参混用，需要注意：
1）位置参数必须在位置参数前面
2）不能为一个形参重复传值

注意的问题：
1、默认参数的值，只在定义阶段，赋值一次
2、位置形参应该默认参数的前面
3、默认参数的值应该是不可变类型（数字，字符串，元组）

实参定义形式有两种：1、位置实参 2、关键字实参
针对这种形式的实参个数不固定，相应的，形参也要有两种解决方案
位置实参：* 关键字实参：**

形参中，在*后定义的参数
特性：传值时，必须按照关键字实参的形式传值

# 1、可以对调用
def func():
print('from func')f=func
print(f) ##返回函数的内存地址
f()
# 2、可以当做参数传入一个函数
def wrapper(x):
print(x)
x()
wrapper(func)
# 3、可以当做函数的返回值
def wrapper():
return func
f1=wrapper()
print(f1 is func)
# 4、可以当做容器类型的一个元素
l=[func,1,2] ##当列表的一和元素
print(l) #打印列表
print(l[0]()) ##取出函数这个元素，并执行函数

def max2(x,y):
if x > y:
return x
else:
return ydef max4(x,y,z,o):
res1=max2(x,y)
res2=max2(res1,z)
res3=max2(res2,o)
return res3
res=max4(100,111,222,9888)
print(res)

def f1():
def f2():
def f3():
print('from f3')
f3()
x=1
f2()
print(x)
f1()

x=
def f1(a):
y='abcdefg'
print(locals())
print(globals()) ##在全局作用域 locals() is globals()
print(globals())
print(locals() is globals())
# f1()

x=1000000000
def f1():
def f2():
x=819892011921818
print(x)
# f2() #全局变量，局部临时生效
return f2
f=f1()
# print(f)
# print(x) ##返回变量的值是全局的定义值 def func():
x=123
# f()
x='hello'
func()

global关键字用来在函数或其他局部作用域中使用全局变量。但是如果不修改全局变量也可以不使用global关键字
声明全局变量，如果在局部要对全局变量修改，需要在局部也要先声明该全局变量：（使用global）
在局部如果不声明全局变量，并且不修改全局变量。则可以正常使用全局变量
nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量 ：只能用于局部变量，找离当前函数最近一层的局部变量