day10 文件处理指针使用 函数基本使用

一：文件指针

强调：只有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 = read(3)

　　　print(res.decode('utf-8'))

with open（'a.txt',mode='at',encoding='utf-8'）as f:

　　f.truncate(3) 截断文件 从文件开头截取对应字节的内容，删除其他内容

文件指针的移动

f.seek():指针移动是以字节为单位的

三种模式

0 相对文件开头移动指针(默认):只有0模式可以在写文本文件和bytes文件时都可以使用，其他模式只能用在b模式

with open('a.txt',mode='rt‘，encoding='utf-8') as f:

　　f.seek(3,0) 移动3个字节

　　print(f.tell())

　　print(f.read())

1相对于当前指针位置移动指针位置

with open('a.txt',mode='rb‘) as f:

　　f.read(2)

　　f.seek(4,1) 从第二个字节再往后移动4个字节

　　print(f.tell())

　　print(f.read().decode('utf-8'))

2相对于文件末尾移动指针位置

with open('a.txt',mode='rb‘) as f:

　　f.seek(-7，2)  移动倒数第七个字节后面

　　ptint(f.tell())

　　print(f.read().decode('utf-8'))

小练习：

循环检测文件是否有增加内容的程序

import os

with open('a.txt',mode='rb') as f:

　　f.seek(0,2)

　　

　　while True:

　　　　l=f.readline()

　　　　if len(l) == 0:

　　　　　　os.sleep(0.5)

　　　　　　continue

　　　　else:

　　　　　　print(l.decod('utf-8'),end='')

二 函数

1.什么是函数

在程序具备某一功能的工具=》函数

事先准备好工具=》函数的定义

遇到应用场景/拿来就用=》函数的调用

　　分为两大类：

　　1.内置函数

　　2.自定义函数

2.为什么要用函数

　　1.代码冗余

　　2.程序的组织结构不清晰，可读性差

　　3.扩展性差

3.如何用函数

　　函数的使用必须遵循一个原则

　　1.先定义

　　定义语法：

　　　　def 函数名（参1，参2，参3，参4.。。）：

　　　　　　‘’‘

　　　　　　　注释

　　　　　　’‘’

　　　　　　代码1

　　　　　　代码2

　　　　　　代码3

　　　　　　return 值

　　2.后调用

　　　　函数名（）

一。定义阶段：只检测语法，不执行代码

def func（）

　　print（‘from func1’）

　　print（‘from func2’）

二。调用阶段：开始执行函数体代码

func（）

func（）

示例

def foo()

　　print('from foo')

　　bar() #报错 没有定义bar（）函数

foo()

def bar（）

　　print（‘from bar’）

def foo()

　　print('from foo')

　　bar()

foo() 定义函数前后关系无所谓，因为执行代码先完成所有函数的定义，再做函数的调用

三。定义函数的三种形式

1.无参函数

def func（）：

　　print（‘from func’）

func（）

2.有参函数

def max2（x,y）:

　　x=1

　　y=2

　　if x > y:

　　　　print(x)

　　else:

　　　　print(y)

max2(1,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)

esle:

　　return y

res=max2(1000,2000)*12

print(res)

3.函数的调用可以当作另外一个函数的参数传入

def max2（x,y）:

　　if x > y:

　　　　return x

　　else:

　　　　return y

res = max2(max(1,2),3)

print(res)

四。返回值

1.什么是函数的返回值

　　返回值是函数体代码的运行成果

2.为何要有返回值

　　需要拿到函数的处理结果做进一步的处理，则函数必须有返回值

3.如何用 return 返回值的特点：

　　1.返回的值没有类型限制，也没有个数限制

　　I：return或者函数没return：返回值None

　　II：return值：返回的就是该值本身

　　III：return 值1，值2，值3:返回元组（值1，值2，值3）

　　2.return是函数结束运行的标志，函数内可以有多个return，但只要执行一次函数就立即结束，并且将return后的值当作本次调用的结果返回

　　def func（）：

　　　　return 1，1.2，‘aaa’，[1，2，3]

　　　　pass

　　res = func()

　　print(res) 把返回值保存成元组

def func():

　　print('aaa')

　　return 1

　　print('bbb')

　　return 2

　　print('ccc')

　　return 3　

func()

　　　

五。函数的参数氛围两大类

1.形参：在定义函数时括号内指定的参数（变量名），称之为形参

2.实参：在调用函数时括号内传入的值（变量值），称之为实参

二者的关系：在调用函数时，实参值（变量值）会传给形参（变量名），这种绑定关系在调用函数时生效，调用结束后解除绑定

def func（x,y）:

　　x=1

　　y=2

　　print(x,y)

fun(1,2)

print(x) 访问不到x 因为x只在函数内调用到

a=1

b=2

func(a,b)

二。函数参数详解

1.形参：

1.1位置形参：在定义阶段，按照从左到右的顺序依次定义的形参

特点：必须被传值

def func（x,y,z）:

　　print(x,y,z)

fun(1,2,3)

func(1,2) 少传了，报错

func（1，2，3，4）多传了 报错

1.2默认参数：在定义阶段，就已经为某个形参赋值，该形参称之为默认形参

特点：在定义阶段就已经有值，意味着调用阶段可以不用为其传值

注意点：位置形参必须放在默认形参的前面

def fun（x,y=2）:

　　print(x,y)

fun(1) 不传y，默认2

func（1，2222）

1.3形参中*与**的用法

1。形参中带*：8号会讲溢出的位置参数存成元组的形式然后赋值其后变量名

def func（x,y,*args）:

　　print(x,y,args)

func(1,2,3,4,5,6)

2.形参中带**：**会把溢出的关键字实参存成字典的格式然后赋值其后变量名

def func(x,y,**kargs):

　　print(x,y,kwargs)

func(1,y=2,z=3,m=1,n=2)

2.实参

2.1位置实参：在调用阶段，按照从左到右的顺序依次传入的值

特点：这种传值方式会与形参一一对应

func（2，1，3）

2.2关键字实参，在调用阶段，按照key=value的格式传值

特点：可以完全打乱位置，但仍然能为指定的形参传值

注意：可以混用关键字实参与位置实参，但是

1.同一个形参只能被赋值一次

2.位置实参必须跟在关键字实参的前面

func（1，z=3,y=2）

fun(1,z=2,y=2)

func(1,z=3,y=2,x=333) 报错，x赋值两次

func（x=1,2,z=3） 语法错误，位置实参要在关键字实参之前

2.3实参中*与**的用法

1.实参中带*：先将实参打散成位置实参，然后再与形参做对应

def func（x,y,z）:

　　print(x,y,z)

func(1,[2,3]) 报错，少传一个参数

func（*[1，2，3]） # func（1，2，3）

func（*‘hello’） #func('h','e','l','l','o') 报错，多传了参数

func（*‘hel’） # func（‘h','e','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的输入参数格式

　　　　　　　　　　　　　　#index(1,z=3,y=2)

wrapper(1,2,3,4,5,a=1,b=2,c=3)

wrapper（1，z=3,y=2）