python3:初识函数+文件处理补充

1、文件处理
f=open('a.tat','r',encoding='utf-8')#以读取的方式打开文件，文件不存在不会创建，以文本的方式读取文件，会自动decode，
#以文件方式操作文件，会自动进行decode encode
f=open('a.txt','rb')  #以读取bytes方式读取文件
print(f.read().decode('utf-8')) #解码成为utf-8模式 ,以bytes操作文件不会自动decode  ecdoce
f=open('a.txt','w',encoding='utf-8') #如果存在，会新建一个文件然后覆盖原来的，不存在会创建一个文件
f.writable() #文件是否可写，布尔值
f.readable()#文件是否可读，布尔值
#r 模式只能读，不能写，w模式只能写，不能读
f.writelines(['111\n','222\n']) #把列表的值写入文件 ，执行换行符
f=open('a.txt','a',encoding='usf-8')#文件不存在，创建文件；文件存在，代开文件  光标跳到文件末尾，a的方式只能追加的写
f.tell() #显示光标的位置  文件的操作和光标的位置息息相关
f=open('a.txt','r+') #r+ 能读能写，w+ 能读能写,a+ 能读能追加
#bytes不是最终的二进制，但是会转换成二进制
#文件的打开方式：文件方式打开，会自动的encode、decode，二进制方式打开，需要自己执行，但是操作的是文件的bytes，文件在硬盘上的形式，
#rb wb ab  同时也是r w a 模式，所以他们有的  为bytes的时候也存在
f=open('a.txt','wb')
f.write('你好啊'.encode('utf-8')) #以bytes形式打开，在写入的时候需要手动encode指定字符编码
f.close()#执行之后，会回收操作系统层面的文件，凡是此时f变量还存在，在程序运行之后，f才会回收，执行了f=open()之后，实际执行了两件事情
#1、操作系统层面打开一个文件，2.应用程序方面，有一个变量f ，这种方式有open，一定要有close
with open('a.txt','rb') as f: #可以不用as f  as f的作用就是把打开文件的操作赋值给f
#硬盘中存储了很多格式的文件，图片，视频，音频 等等，但是他们在硬盘中的形态都是bytes类型的，所以在复制   重命名 等等 直接更改的是bytes类型的数据
#应该使用bytes方式操作。复制文件的原理：打开一个新文件，在旧文件中的每一行都复制到新文件中，需要解决路径文件，实用哦个for 循环，是有那个rb方式读取就文件中的每一行，然后以ab方式追加到新文件中
#视频文件  图片  音频 都是形同的原理
#重要的模块：time sys os
#文件的操作
f = open('a.txt', 'r')
f.read(3) # 使用文件模式打开，读取的就是字符数量，3指的是读取3个字符
f = open('a.txt', 'rb') #使用字节方式打开读取的是字节个数，
f.read(3).decode('utf-8')  #字节方式打开，需要decode   有中文的时候，读取2个字节的时候 编码会出现问题，因为中文占3个字节
#read 不指定个数的时候，读取的时候，光标移动到最后，read 会有两种方式，1、字节2、文本，是子啊光标移动的方面
#光标的移动
#seek  tell truncate 以字节的方式移动只有read中可his按照字符的方式移动
f=open('a.txt','r')
f.read()
f.seek(0)#光标移动到行首
f.seek(3)#以文件开头作为参照，距离开头几个字节，光标移动到第3个字节处
f.tell()#显示光标的位置
f.seek(6,0) #0表示开头，是参照物，句酷开头6个字节
f.seek(2,1) #1表示以当前的位置作为参照物
#seek  有3种模式：0  1  2   其中 1  2 只在rb bytes下生效  seek是正控制光标的位置  0 是开头作为参照，1 标识当前位置作为参照，2 标识结尾作为参照
f.seek(0,2) #光标移动到最后，-1 是向左切，1是向右，所以在取值的时候就是要取负值。
#文件操纵自导布尔值
f.readline() #读取的同时自带布尔值，不为空为真，为空为false  所以文件操作自导布尔值
#截断文件
with open('a.txt','r+',encoding='utf-8') as f:
    f.truncate(9)#从文件开头截取9个字节保存下来，剩下的字节都去掉，截的是留下来的，有中文的时候，截取不是3的倍数的时候，报错，截取多了，截取的是空格
2、函数
#函数的分类：内置函数、自定义函数
#函数的使用：1、先定义 2、在调用，调用的方法：函数名()
max(1,2)  #极值
min(1,2)
#定义函数
def name():
    pass #子代码 print(函数名)  显示的是内存地址
#执行函数 函数名()
#定义函数的时候，值检查语法，并不执行代码
def foo():  #定义函数
    print('from foo') #子代码
    bar() #foo中调用了另外一个函数
def bar(): #带你工艺梁歪一个函数
    print('from bar')
foo()  #执行foo函数
#在定义阶段，foo函数存在，定义完成   接下来 定义bar函数，定义完成，，在执行节点，调用foo   print可以执行，bar 已经定义  可以执行   所以不抱错
#函数返回值 retrue 返回值，retrue 后边的值作为函数的返回值，retrue 可写多个，但是只能执行一次，一旦retrue，函数结束，reture 的值会返回，但是只是返回
#如果没有保存这个值，就会被回收，不会显示在屏幕上，需要保存reture的值  需要定一个一个变量 绑定reture的值
def foo():
    print('form foo')
    return 0
foo() #执行函数，得到的返回值是0，
res=foo() #foo()返回0 ，把这个值并当给res
#没有returnner也可以，返回None ，和return None 返回的结果相同，有值的时候返回值，没有值的时候返回None  return 的值没有类型的限制，可以是字典、列表等等
#return的值也可以是多个，字典，字符串 ，列表等等，返回的值是一个元组，把每一个参数作为元组的元素
#return 在函数执行一系列操作的时候，得到一个明确的结果，返回值，需要return；函数只需要一系列的操作，不需要返回，就可以不存在return。
foo(1,2)
#函数的3中形式：1.无参  2、有参   3、空函数  函数的括号内，传递参数，
foo(1,2)*10
foo(foo(1,2),3)
#函数的参数：形参：定义阶段（）中的参数；实参：阶段（）内的参数  实参占用资源
#函数参数
def foo(x,y):
    print(x)
    print(y)
#函数的参数：形参 实参 定义函数时候，括号内的参数形参，调用函数的时候内的参数 实参数 形参变量明，实参变量值，调用阶段 绑定生效
#调用结束后绑定结束
#位置参数：按照位置从左到右依次传值，位置形参必须被传值，多一个不行 少一个不行
#位置行参：位置形参必须被传值，多一个不行 少一个不行
#位置实参：与形参按照位置从左到右一一对应，位置变了之后，兵丁关系变
#关键字实参
def foo(x,y):
    print(x)
    print(y)
foo(x=1,y=2) # x=1,y=2 按照变量名传递参数，成为关键字参数
#位置实参和关键字实参同时存在的时候，位置实参必须在关键字实参的前面；同一个形参传多个值
#默认参数，在定义阶段就已经赋值，如果在调用阶段被传值，这个参数最终的值就是在调用阶段被赋的值
#如果在调用阶段没被传值，就是默认的值，需要默认的时候用，
#默认形参必须放在非默认形参之后；默认参数只在定义阶段定义一次并且只定义一次。
def foo(x,y=11111):
    print(x)
    print(y)
y=222222
#这时候y就是11111，不会编程22222
#默认参数的值应该定义成不可变类型，
#可变参数：可变长参数：指的是实参的个数不固定，形参必须有两种机制分别处理：位置形参溢出：*，关键字实参溢出 **
def foo():
    print(x)
    print(y)
foo(1,2,3,4,5) #对应的处理方式如下
def foo(x,y,*nums):
    print(x)
    print(y)
foo(1,2,3,4,5)#原理如下
#把多出来的位置参数交给*处理成元组，并且绑定nums
foo(a=1,b=2,c=3)#对应的处理方式如下
def foo(x,y,**nums):
    print(x)
    print(y)
#按照关键字定义的参数，交给**处理成字典，绑定nums
#c常用的变量名字是*args  **kwargs
#*args的扩展用法
def foo(x,y,*args):
    print(x)
    print(y)
foo(1,2,*(3,4,50)) #*(3,4,50) 的原始形式就是在被*处理之后的位置参数组成的元组，遇到*之后，就将参数打散，打成位置参数，然后传值
foo(1,*(3,))
foo(*(1,2))
#以上的*（）的形式 都给打散，成为位置参数
#**kwargs
def foo(x,y,**kwargs):
    print(x)
    print(y)
foo(a=1,b=2,**{'c':3,'g':4}) #**后边跟的是列表，key就是打散，value就是值，把字典打散，然后传值
def foo(x,y,*args,**kwargs):
    print(x)
    print(y)
#*xargs 位置形参，**kwxargs 关键字实参 命名关键字定义的参数，必须关键字传参
def foo(x,*args,**kwargs):
    print(x)
    print(y)
foo(1,2,3,4,5,a=9,b=3)
#*args **kwargs
def a(name,age,sex)
    print(name)
    print(age)
    print(sex)
def b(*args,**kwargs):
    print(args)
    print(kwargs)
    a(*args,**kwargs)
b(1,2,4,a=1,b=3)
#说明 args kwargs   可以理解一个变量名字*args,**kwargs  接收所有的参数，b(*args,**kwargs) 接收所有的参数，然后调用了a函数，一旦给函数传递了参数，参数全程参与函数，
#b带参数，a函数也接收了所有的参数，然后执行a函数
#命名关键字参数;在*后面的形参是关键字形参，必须以关键字参数传值
def foo(x,y,*,z=7,h):#*的作用和*args **kwargs不一样，这里的*的意思是规定后边的形参必须以关键字传值，命名关键字参数也可以有默认值，z的默认值是7，也可以在调用的时候传值，
                      #*后边的形参都是命名关键字参数
    print(x)
    print(y)
foo(1,2,h=6)
#混合使用的时候的位置：
#函数本身是第一类对象，可以被当作数据传递，函数可以被当作数据传递
#1、可以被赋值
f=foo
print(f) #显示的是内存地址，
f(x)   #这时候和foo(x) 是相同的
#2、可以当作参数
def a(x):
    print(x)
a(foo)  #foo是函数名
#3、可当做函数的返回：
h=a(foo)
print(h)
#4、当作容器类型的元素
kk={'foo':foo}#kk是一个字典，'foo' 是key，value是foo的内存地址，
kk['foo']()# 通过'foo']找到foo的地址，()是调用这个函数