一、文件内指针的移动f.seek
强调：只有t模式下的read（n），n代表的是字符个数，除此以外都是以字节为单位。
with open('a.txt',mode='rt',encoding='utf-8') as f:
res=f.read(4) # 读取前四个字符
print(res)
with open('a.txt',mode='rb') as f:
res=f.read(3) # 读取前三个字节
print(res.decode('utf-8')) #将字节解码
with open('a.txt',mode='at',encoding='utf-8') as f:
f.truncate(3) #截断a.txt中的内容，取前三个字符。此方法用于从文件的首行首字符开始截断，截断文件为 *个字符，无*表示从当前位置截断；截断之后，后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
f.seek():指针移动是以字节为单位
三种模式:只有0模式可以在t模式下都可以使用，1，2只能在b模式下使用。
0（默认）：参照文件开头
with open('c.txt',mode='rt',encoding='utf-8') as f:
f.seek(3,0)
print(f.tell()) #file.tell() 方法返回文件的当前位置，即文件指针当前位置。
print(f.read())
1：参照指针当前所在位置
with open('c.txt',mode='rb') as f:
f.read(2)
f.seek(3,1)
print(f.tell())
print(f.read().decode('utf-8')) #读取的是字节，所以显示的时候需要解码
2：参照文件末尾
with open('c.txt',mode='rb') as f:
f.seek(-3,2)
print(f.tell())
print(f.read().decode('utf-8'))
tail -f acces.log小程序：打开文件，指针跳到文件末尾，不停监测是否有新内容，如果有则显示出来。
先建立文件,如access.log:
aaa
bbb
#文件要直接换一行
再建立一个写入程序，如run.py：
with open('access.log',mode='at',encoding='utf-8') as f: #文件模式为at(追加，字符串模式)
f.write('666
') #
为自动换行符，写入之后则自动换行
编写检测程序：
import time #输入time模块（因为不需要让检测程序一直不停的工作，如果一直不停的循环，CPU占用过多）
with open('access.log',mode='rb') as f: # 只读模式即可
f.seek(0,2) #2即把指针放到文件末尾，0代表指针不做移动
while True: #建立循环
line=f.readline() #readline从文件读取整行，包括 "
" 字符，一行一行读取
if len(line) == 0: # 行的长度等于0，即表示空，没有新增内容
time.sleep(0.1) #计算机休息0.1s
else:
print(line.decode('utf-8'),end='') # 打开是以二进制打开的，所以需要解码过程，且写入程序自带换行符，所以此处打印时，不要再有换行符了
二、函数
1.什么是函数：组织好的，可重复使用的，用来实现单一或相关联功能的代码块。
在程序具备某一功能的工具=》函数
事先准备好工具=》函数的定义
遇到应用场景，拿来就用=》函数的调用
分成两大类：
①内置函数
②自定义函数
2.为什么用函数
Ⅰ代码冗余
Ⅱ程序的组织结构不清晰，可读性差
Ⅲ扩展性差
3.如何用函数
函数的使用必须遵循一个原则：
①先定义 #定义阶段，只检测语法，不执行代码
定义语法：
def 函数名（参1，参2。。。）: #可以没有参数
"""
文档注释
"""
代码1
代码2
。。。
return 值 #可以没有返回值 ，没有return语句相当于返回None
②后调用 #调用阶段，开始执行函数体代码
函数名()
在调用/输出函数之前把相关函数及变量都设置好就可以了。
在定义阶段，只会检测python的语法，不会执行代码。也就是说，只要语法对，就能够定义（至于执行代码时会不会报错再说）。
在调用阶段，才会开始执行函数体代码。
def foo():
print('from foo')
bar()
def bar():
print('from bar')
foo() #代码能够正常运行，只要在调用代码之前把函数定义正确/完整就可以了。
#说明:函数调用可以看作程序执行流程中的一个迂回路径，遇到函数调用时，并不会直接继续执行下一条语句，而是跳到函数体的第一行，继续执行完函数代码块中的所有语句，再跳回原来离开的地方，
三、定义函数的三种形式
1、无参函数
def func():
print('from func')
func()
2、有参函数
def max2(x,y):
if x > y:
print(x)
else:
print(y)
max2(1,2)
3、空函数
def register():
pass
四、调用函数的三种方式
1、语句形式
def func():
print('from func')
func()
2、表达式形式：有返回值的才行
def max2(x,y):
if x > y:
return x
else:
return y
res=max2(2,3)
print(res)
3、函数的调用可以当做另外一个函数的参数传入
def max2(x,y):
if x > y:
return x
else:
return y
res=max2(max2(1,2),3)
print(res)
五、函数的返回值
1.什么是函数的返回值：
返回值是函数体代码的运行成果
2.为何要有返回值
需要拿到函数的处理结果做进一步的处理，则函数必须有返回值
3.如何用：
return返回值的特点：
Ⅰ返回值没有类型限制，也没有个数限制
return或者函数没return：返回值是None
return值：返回的就是该值本身
return值1，值2。。。返回元组（值1，值2）
Ⅱreturn是函数结束运行的标志，函数内可以有多个return，但只要执行一次函数就会立即结束，并且将return后的值当做本次调用的结果返回
def test():
print('111')
return 666
print('222')
return gogogo
test()
print(test())
#输出结果为：
111
111
666
六、函数参数的使用
Ⅰ函数的参数分为两大类：
1.形参：在定义函数时括号内指定的参数（变量名），称之为形参
2.实参：在调用函数时括号内传入的值（变量值），称之为实参
二者的关系：在调用函数时，实参值（变量值）会传给形参（变量名），这种绑定关系在调用函数时生效，调用结束后解除绑定。
Ⅱ函数参数详解
1.形参：
1.1位置形参：在定义阶段，按照从左到右的顺序依次定义的形参
特点：必须被传值
def func(x,y,z):
print(x,y,z)
func(1,2,3) #正常输出
func(1,2,3,4) #报错
func(1,2) #报错
1.2默认参数：在定义阶段，就已经为某个形参赋值，该形参称之为默认形参
特点：在定义阶段就已经有值，在调用阶段可以不用为其传值。
注意点：位置形参必须放在默认形参前面，也就是说非默认参数要放在默认参数的前面。
def fuc(x,y,z=666):
print(x,y,z)
fuc(x=1,y=2)
输出结果为：
1 2 666
1.3形参中*与**的用法：
①形参中带*：*会将溢出的位置实参存成元组的形式然后赋值其后变量名
def func(x,y,*args):
print(x,y,args)
func(1,2,3,4,5,6)
输出结果为：
1 2 (3, 4, 5, 6)
②形参中带**：**会将溢出的关键字实参存成字典的格式然后赋值其后的变量名。
def func(x,y,**kwargs):
print(x,y,kwargs)
func(1,y=2,z=3,m=1,n=2)
输出结果为：
1 2 {'z': 3, 'm': 1, 'n': 2}
def test(a,*args,**kwargs):
print a
print args
print kwargs
test(1,2,3,d='4',e=5)
输出结果：
1
(2, 3) #简单说，对于不是键值对的，*args储存成元组。而有=的，则用**kwargs储存成字典
{'e': 5, 'd': '4'}
2.实参
2.1位置实参：在调用阶段，按照从左到右的顺序依次传入的值（传值的一种格式）
特点：这种传值方式会与形参一一对应
2.2关键字实参：在调用阶段，按照key=value的格式传值
特点：可以完全打乱位置，但仍然能为指定的形参传值
注意：可以混用关键字实参与位置实参，但是
①同一个形参是能被赋值一次
def fuc(x,y,z):
print(x,y,z)
fuc(x=1,y=2,z=3)
输出结果为：
1 2 3
def fuc(x,y,z):
print(x,y,z)
fuc(x=1,y=2,z=3,x=66)
输出结果会报错
②位置实参必须在关键字实参的前面，否则会报语法错误
def fuc(x,y,z):
print(x,y,z)
fuc(1,z=3,y=2)
输出结果为：
1 2 3
def fuc(x,y,z):
print(x,y,z)
fuc(x=1,2,z=3)
输出结果会报错
def fuc(x,y,z):
print(x,y,z)
fuc(1,x=2,z=3)
此种情况也会报错，会显示x被赋值两次
2.3实参中*与**的用法：
①实参中带*：先将实参打散成位置实参，然后再与形参做对应。
def func(x,y,z):
print(x,y,z)
func(1,[2,3]) #会报错
func(*[1,2,3]) #输出结果为1 2 3
func(*'hello') #会报错，因为给了五个值
func(*'hel') #输出h e l
②实参中带**：先将实参打散成关键字实参，然后再与形参做对应
def func(x,y,z):
print(x,y,z)
func(**{'x':1,'z':3,'y':2}) #func(z=3,y=2,x=1)，此处字典key必须与形参名一致!
输出结果为：1 2 3
3.可变长参数
可变长指的是实参值的个数不固定，而实参有按位置和按关键字两种形式定义。
针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs
===========*args===========
def foo(x,y,*args):
print(x,y)
print(args)
foo(1,2,3,4,5)
输出结果：
1 2
(3, 4, 5)
def foo(x,y,*args):
print(x,y)
print(args)
foo(1,2,*[3,4,5])
输出结果为：
1 2
(3, 4, 5)
def foo(x,y,z):
print(x,y,z)
foo(*[1,2,3])
输出结果为：
1 2 3
===========**kwargs===========
def foo(x,y,**kwargs):
print(x,y)
print(kwargs)
foo(1,y=2,a=1,b=2,c=3)
输出结果为：
1 2
{'a': 1, 'b': 2, 'c': 3}
def foo(x,y,**kwargs):
print(x,y)
print(kwargs)
foo(1,y=2,**{'a':1,'b':2,'c':3})
输出结果为：
1 2
{'a': 1, 'b': 2, 'c': 3}
def foo(x,y,z):
print(x,y,z)
foo(**{'z':1,'x':2,'y':3})
输出结果为：
2 3 1
===========*args+**kwargs===========
def foo(x,y):
print(x,y)
def wrapper(*args,**kwargs):
foo(*args,**kwargs)