一、昨日内容回顾

昨日内容回顾

其他模式补充

r+

w+

a+

文件内光标移动

在rt模式下read内n表示的读取字符的个数

其他情况及其他方法内n表示都是字节数

f.read(n)

f.seek(offset,whence)

offset:指定光标的偏移量

whence:模式

0:相对于文件开头 t和b下都可以正常使用

1:相对于光标所在的当前位置 只能在b模式下使用

2:相对于文件末尾 只能在b模式下使用

牢记:中文在utf-8中用3个bytes表示,英文用一个bytes

检测文件是否被修改

打开文件 利用f.seek(0,2)将光标移动到文件末尾

利用while循环

再利用readline()来读取末尾内容

在通过if判断看readline()是否有值,有值说明文件新增了内容

通过字符串的格式化输出将新增的文件内容输出给检测程序

查看当前光标移动了多少字节

f.tell()

截断文件内容

f.truncate() 括号内输入的数字 表示的是字节数

将内存中的文件内容直接刷到硬盘

f.flush()

硬盘删除的数据原理

文件修改

两种方式

第一种将文件内容先读取到内存在内存中完成修改,然后重新覆盖原文件

优点:硬盘上始终只有一个文件

缺点:内存很有可能会溢出 当文件内容过大的情况下

第二种重新创建一个新的文件,将老文件的内容一行行读入内存完成修改

直接写到新的文件中,利用os模块将原文件删除,将新文件的名字改为来文件的名字

优点:内存中始终只有文件的一行内容 不占用内存

缺点:硬盘上在某一时刻会出现两个文件

函数

什么是函数

函数就是具有某个具体功能的工具

为什么要用函数

提供开发效率

减少代码冗余

提高程序的扩展性

定义一个函数

def是定义函数的关键字

函数名:函数名的命名规则与变量名一致

1.不能以关键字(******)

2.函数也应该做到见名知意

函数在定义的时候只检测函数体语法 不执行函数体代码

def func():

print('hello')

调用函数的固定格式

函数名+括号

函数名只要遇到括号会立即执行函数体代码

代码中遇到函数名加括号 优先级最高

先去执行函数 再看下面的代码

今日内容

函数基本使用

函数的参数

二、函数简介

s = 'hello'

# print(len(s)) # len() 内置函数:python提前给你的写好了的函数 你直接调用即可

#

# n = 0

# for i in s:

# n += 1

# print(n)

l = [1,2,3,4,5]

# my_len() # 函数必须先定义后调用 定义了的函数可以在任意位置调用

def my_len(): # 自定义函数

n = 0

for i in s:

n += 1

print(n)

# res = len(s)

# print(res)

res = my_len()

print(res)

len(s)

len(l)

# s = 'hello world'

# l = [1,2,3,4,5,6]

# my_len()

# print(len(s),len(l))

"""

我们自己写的函数现在的问题

1.没有返回值 只能固定的执行打印操作

2.只能够固定的统计某一个容器类型的长度

"""

三、函数的返回值

# def func():

# return 'asfjsfda'

# res = func()

# print(res)

# 函数内要想返回给调用者值 必须用关键字return

"""

不写return

只写return

写return None

写return返回一个值

写return返回多个值

"""

# 不写return:函数默认返回None

# def func():

# print('hahaha')

# res = func()

# print(res)

# 只写return:return除了可以返回值之外 还可以直接结束整个函数的运行

# 只写return 返回的也是None(None就表示什么都没有)

# def func():

# l = ['jason','egon','tank']

# while True:

# for i in l:

# if i == 'egon': # 当i为egon的时候 直接结束函数运行

# # break

# return

# # print('asdasdkljlsjadl') # 这一行代码拥有都不会运行

# print(i)

# res = func()

# print(res)

# 写return None:跟上面的只写return是一样的

# def func():

# return None

# res = func()

# print(res)

# 写return返回一个值:这个值可以是python任意数据类型

# def func():

# return '123'

# def func1():

# return [1,2,3]

# def func2():

# return {'name':'jason'}

# def func3():

# return (1,)

# def func4():

# return {1,2,3,4,5}

# def func5():

# return True

# print(func(),func1(),func2(),func3(),func4(),func5())

# 写return返回多个值:return会自动将多个值以元组的形式返回给调用者

"""

1.为什么组织成元祖返回

函数不希望自己处理的结果被修改

2.如何不返回元祖

"""

def func():

return 1,2,3,4 # 返回的是(1, 2, 3, 4)

# res = func()

# print(res)

def func1():

return 'a','b','c' # ('a', 'b', 'c')

res = func1()

print(res)

def func2():

return [1,2,3],[1,2,3],[1,2,3] # ([1, 2, 3], [1, 2, 3], [1, 2, 3])

res1 = func2()

print(res1)

def func3():

return {'name':'jason'},{'username':'tank'},{'user_name':'egon'} # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})

res2 = func3()

print(res2)

# 返回多个值 并且不想让return帮你做处理 自己手动加上你想返回的数据类型符号

def func4():

return [[1,2,3,4],[1,2,3,4],[1,2,34]]

res = func4()

print(res)

"""

1.所有的函数都有返回值,无论你写不写return

python中所有的函数都有返回值 不写的情况下默认返回None

2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行

"""

四、函数的参数概要

"""

positional arguments:位置参数

param 参数

required 需求的

"""

s = 'hello'

l = [1.2,3,4]

# print(len(s))

# print(len(l))

def my_len(args): # 需要0个参数

print(args)

n = 0

for i in args:

n += 1

return n

# res = my_len()

# print(res)

# my_len(l) # 给my_len传了一个参数

# my_len('asda')

print(my_len('hello'))

print(my_len('hello world'))

print(my_len([1,2,3,4,5]))

"""

函数参数的两大类型

形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参

实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参

形参与实参的关系

形参就相当于变量名,而实参就相当于变量的值

函数调用传参的过程 就是给形参变量名赋值的过程

注意:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除

只在函数内部有效 函数外部无任何影响

函数的简易结构

def 函数名(形参1,形参2...):

'''函数的注释 用来描述该函数的作用以及各个形参的类型'''

函数体代码1

函数体代码2

...

return 函数的返回值

"""

def func(x,y):

"""

该函数的作用

:param x: 对形参x的解释

:param y: 对形参y的解释

:return: 对函数返回值的解释

"""

print('hahaha')

return 'heihei'

print(help(func))

print(help(len))

五、位置参数

# 求两个数的大小 返回大的那个

# 位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参

# 位置形参在调用的时候 必须为其传值

def my_max(x,y):

print(x,y)

if x > y:

return x

else:

return y

# res = my_max(1) # 在调用函数的时候 少一个实参不行

# res = my_max(1,2,3) # 在调用函数的时候 多一个实参也不行

# res = my_max(20,10)

# 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参

# print(res)

# 第一种直接按照位置传 一一对应

# 第二种指名道姓的传 >>>:关键字传参

# my_max(y=20,x=10)

# my_max(10,y=20) # 位置和关键字混合使用

# my_max(20,y=40)

my_max(20,y=40,x=30)

"""

注意:在函数的调用阶段 位置参数和关键字参数可以混合使用

但是必须保证

1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)

2.同一个形参不能被多次赋值

"""

六、默认值参数

# 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了

# 在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值

# 在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值

# 在定义阶段 默认值形参必须放在位置形参的后面

# def my_max(x,y=100):

# if x > y:

# return x

# return y

# # res = my_max(200)

# res1 = my_max(200,1000)

# res2 = my_max(y=200,x=1000)

# print(res2)

# def register(username,age,gender='male'):

# print(username,age,gender)

# register('jason',18)

# register('tank',28)

# register('egon',84)

# register('kevin',58)

# register('xiaohou',17,'female')

# 默认值参数的应用场景

# 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参

# def info(username,hobby,l=None):

# if l == None:

# l = []

# l.append(hobby)

# print('%s 的爱好是 %s'%(username,l))

# info('jason','study')

# info('tank','生蚝')

# info('kevin','喝腰子汤')

# info('egon','女教练')

# 解决方法1

# info('jason','study',[])

# info('tank','生蚝',[])

# info('kevin','喝腰子汤',[])

# info('egon','女教练',[])

# 解决方法2

# info('jason','study')

# info('tank','生蚝')

# info('kevin','喝腰子汤')

# info('egon','女教练')

# m = 100

# def my_max(x,y=m):

# print(x,y)

# m = 222

# my_max(111)

def func(x,y=100):

print(x,y)

"""

函数在定义阶段 内部所使用的变量都已经初始化完毕了

不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)

函数无论在什么地方被调用

都会跑到函数定义阶段去执行代码

形参中用到的值都是往函数定义阶段代码往上找

"""

七、可变长参数

# 可变长参数

# 站在调用函数传递实参的角度 实参的个数不固定的情况

# 也就意味形参也不固定

# 站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

# 站在形参的角度 看 *

# 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名

# def func(x,y,*z):

# print(x,y,z) # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)

# func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)

# 站在实参的角度 看 *

# def func(x,y,z):

# print(x,y,z)

# # l = [1,2,3]

# # a,b,c = l

# # func(a,b,c)

# # func(*[1,2,3,4,5,6]) # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)

# func(*(1,2,3)) # 等价于func(1,2,3)

# def func(x,*z):

# print(x,z)

# func(1,*{1,2,3}) # *在形参中只能接收多余的位置实参 不能接收关键字实参

# *只能将列表 元组 集合 字符串

# *的内部你可以看成是for循环

# 站在形参的角度看 **

# def func(x,y,**z):

# print(x,y,z) # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}

# func(x=1,y=2,z=1,a=1,b=2,c=3)

# **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字

# 字典的value就是关键字的名字指向的值 将字典交给**后面的变量名

# 站在实参的角度看 **

def func(x,y,z):

print(x,y,z)

# func(12,3,4)

# func(x=1,y=2,z=3)

# d = {'x':1,'y':2,'z':333}

# func(x=1,y=2,z=3)

# func(**d) # 等价于func(x=1,y=2,z=333)

# **会将字典拆封成 key = value的形式

"""

总结 * 与 **

*在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名

**在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名

*:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数

(*就看成是for循环取值)

**:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

"""

# 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行

# def func1(*x,**y):

# print(x,y)

# func1(1,2,3,4,5,6,x=1,y=2,z = 3)

"""

注意python推荐形参*和**通用的写法

"""

def func2(*args,**kwargs):

print(args,kwargs)

func2(1,2,3,4,5,6,x=1,y=2,z = 3)