强调：只有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')) #因为是b二进制所以要转码，这里用到decode转码
with open('a.txt',mode='at',encoding='utf-8') as f:
f.truncate(3)
f.seek()：指针移动是以字节为单位的
三种模式：只有0模式既可以在t下用也可以在b下用，而1、2两种模式只能在b模式下使用
0（默认的）：参照文件开头
with open('a.txt',mode='rt',encoding='utf-8') as f:
f.seek(3,0) #在3个字节后打印出信息
print(f.tell()) #tell是统计光标在哪里开始运行
print(f.read())
1： 参照指针当前所在的位置
with open('a.txt',mode='rb') as f:
f.read(2) #这里是2个字节，因为用到的b
f.seek(4,1)
print(f.tell()) #tell这里的指针是在6个字节后运行，2+4 =6个字节
print(f.read().decode('utf-8'))
2: 参照文件末尾
with open('a.txt',mode='rb') as f:
f.seek(-5,2) #-5就是光标在尾巴处，往前退5个字节
print(f.tell()) #这里光标显示为9是因为是-5,后退5个字节，光标所以在为3个字符后面就是9个字节
print(f.read().decode('utf-8')) #当碰到b 就需要decode转义下
tail -f access.log
import time
with open('access.log',mode='rb') as f:
f.seek(0,2) #0就是从头开是，2就是参照尾部
while True:
line=f.readline()
if len(line) == 0: #统计line的个数，如果为空
time.sleep(0.1) #让系统睡0.1秒
else:
print(line.decode('utf-8'),end='')
'''
-
什么是函数
在程序具备某一功能的工具=》函数
事先准备好工具=》函数的定义
遇到应用场景、拿来就用=》函数的调用分为两大类：
- 内置函数
- 自定义函数
-
为何要用函数
- 代码冗余
- 程序的组织结构不清晰，可读性差
- 扩展性差
-
如何用函数
函数的使用必须遵循一个原则：-
先定义
定义语法：
def 函数名(参1,参2,参3,...):
"""
文档注释
"""
代码1
代码2
代码3
...
return 值 - 后调用
函数名()
-
'''
#一. 定义阶段: 只检测语法，不执行代码
def func():
print('from func 1')
print('from func 2')
print('from func 3')
print('from func 4')
#二. 调用阶段: 开始执行函数体代码
func()
func()
func()
示范一：
def foo():
print('from foo')
bar() #这里bar没定义所以执行错误
#
foo()
示范二：
def bar():
print('from bar')
#
def foo():
print('from foo')
bar()
#
foo()
#示范三：
定义
def foo():
print('from foo')
bar()
#
def bar():
print('from bar')
调用
foo() #这里不会报错，因为定义是全部定义好之后在执行foo()
三：定义函数的三种形式
1. 无参函数
def func():
print('from func')
#
func() #什么是无参函数，就是直接打印，不需要任何东西，func()，括号内是空的这个就是无参函数
2. 有参函数
def max2(x,y):
x=1
y=2
if x > y:
print(x)
else:
print(y)
#
max2(1,2) #有参还是就是(x,y)这个就是有参数，调用函数给你2个值
max2(3,4)
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(1000,2000) * 12
print(res) #表达式函数就是让return给你一个返回值，让你去调用这个返回值
#
res=len('hello') #其实len就是在调用系统内部函数
print(res)
3 函数的调用可以当作另外一个函数的参数传入
def max2(x,y):
if x > y:
return x
else:
return y
#
res=max2(max2(1,2),3) #这里是函数的return的返回值在调用函数，
print(res)
#首先x=1,y=2 取得2，然后res=max2(2,3) 在进行调用，x=2,y=3 取得3'''
-
什么是函数的返回值
返回值是函数体代码的运行成果 -
为何要有返回值
需要拿到函数的处理结果做进一步的处理，则函数必须有返回值 -
如何用
return 返回值的特点：-
返回的值没有类型限制，也没有个数限制
I: return或者函数没return:返回值None
II: return 值：返回的就是该值本身
III: return 值1,值2,值3：返回元组(值1,值2,值3) - return是函数结束运行的标志，函数内可以有多个return，但只要执行一次函数就立即结束，并且将return后的值当作本次调用的结果返回
-
'''
def func():
return 1,1.2,'aaa',[1,2,3] #这里return的返回值是(1, 1.2, 'aaa', [1, 2, 3])，可以是多个值
pass #pass 这里的return的返回值是none
res=func()
print(res)
def func():
print('aaaa')
return 1
print('bbb')
return 2
print('ccc')
return 3
res=func() #这里说明，return至返回第一个return，后面2个return就不会执行了，只执行第一个
print(res)
一 函数的参数分为两大类：
1. 形参：在定义函数时括号内指定的参数(变量名)，称之为形参
2. 实参：在调用函数时括号内传入的值(变量值)，称之为实参
二者的关系：在调用函数时，实参值（变量值）会传给形参（变量名），这种绑定关系在调用函数时生效，调用结束后解除绑定
def func(x,y): #这行代码就是形参
#x=1
#y=2
# print(x,y)#func(1,2) #这行代码就是实参
print(x)
a=1
b=2
func(a,b) #这行代码就是实参
二：函数参数详解
1. 形参：
1.1 位置形参：在定义阶段，按照从左到右的顺序依次定义的形参
特点：必须被传值
def func(x,y,z): #括号内有内容就是位置形参，这里是x,y,z 所以就是位置形参
print(x,y,z)
func(1,2,3) #这行就是位置实参
func(1,2,3,4) #这行就是位置实参，位置实参不能超过位置形参的个数，不然就报错
func(1,2,) #这行就是位置实参，位置实参不能少于位置形参的个数，不然就报错
1.2 默认参数：在定义阶段，就已经为某个形参赋值，该形参称之为默认形参
特点：在定义阶段就已经有值，意味着调用阶段可以不用为其传值
注意点：位置形参必须放在默认形参的前面
def func(x,y=2): #这里因为有y=2，所以这里就是默认形参
print(x,y)
func(1) #因为这里是默认形参，所以实参就可以传递一个参数
func(1,3333333) #因为这里是默认形参，但是还是可以改默认形参的值
def register(name,age,sex='male'):
print(name,age,sex)
#
register('靓仔',18,)
register('小红',28,)
register('小黑',38,)
register('花姑娘',16,'female')
def func(y=2,x): #因为默认形参，不能在位置形参前面，所以肯定会报错
print(x,y)
#1.3 形参中*与**的用法
1. 形参中带：会将溢出的位置实参存成元组的形式然后赋值其后变量名
def func(x,y,*args):
print(x,y,args) #这里x=1,y=2, args=(3, 4, 5, 6) 因为实参多出来了，只能用元祖形式显示给形参
#
func(1,2,3,4,5,6)
2. 形参中带：会溢出的关键字实参存成字典的格式然后赋值其后变量名
def func(x,y,**kwargs):
print(x,y,kwargs) #这里因为用了2个*，所以kwargs为{'z': 3, 'm': 1, 'n': 2} 这里用字典存着
#
func(1,y=2,z=3,m=1,n=2)
2. 实参
2.1 位置实参: 在调用阶段，按照从左到右的顺序依次传入的值
特点：这种传值方式会与形参一一对应
func(2,1,3) #位置实参就是一一对应，改变位置，这里位置形参的值也会发生改变
2.2 关键字实参: 在调用阶段，按照key=value的格式传值
特点：可以完全打乱位置，但仍然能为指定的形参传值
func(z=3,y=2,x=1) #这里是关键词实参，可以改变位置的，但是结果还是一样的
注意：可以混用关键字实参与位置实参，但是
1. 同一个形参只能被赋值一次
2. 位置实参必须跟在关键字实参的前面
func(1,z=3,y=2) #这个是正确的做法，因为x=1,y=2,z=3
func(1,z=3,y=2,x=333) #这里也是错误的，因为x=1已经被赋值过了，再次赋值肯定会报错
func(x=1,2,z=3) # 报语法错误，因为默认实参不能跟在关键词实参后面
#2.3 实参中*与**的用法
1. 实参中带*：先将实参打散成位置实参，然后再与形参做对应
def func(x,y,z):
print(x,y,z)
#func(1,[2,3]) #报错，因为少了一个z的实参
func([1,2,3]) #func(1,2,3) #用了的实参就是吧作为位置实参来看待,不会改变里面实参的位置
#func(*'hello') #func('h','e','l','l','o') #这里会报错，因为你给你位置形参太多的值了，超过3个了
func(*'hel') #func('h','e','l') #这里给三个值，所以x=h,y=e,z=l
2. 实参中带**：先将实参打散成关键字实参，然后再与形参做对应
def func(x,y,z):
print(x,y,z)
#
func(**{'x':1,'z':3,'y':2}) #func(z=3,y=2,x=1) #就把他当初位置实参看待就行了
def index(x,y,z):
print(x,y,z)
#
def wrapper(*args,**kwargs): # args=(1,2,3,4,5) kwargs={'c':3,'b':2,'a':1}
index(*args,*kwargs) #index((1,2,3,4,5),**{'c':3,'b':2,'a':1}) #index(1,2,3,4,5,a=1,b=2,c=3)
index(1,z=3,y=2)
wrapper(1,2,3,4,5,a=1,b=2,c=3)
#