函数基础(****)
昨日内容补充点：
检测文件是否被修改：
-
- 打开文件，利用f.seek(0,2)将光标移动到文件末尾
- 利用while循环
- 再利用readline()来读取末尾内容
- 再通过if判断看readline()是否有值，有值说明文件新增了内容
- 通过字符串的格式化输出将新增的文件内容输出给检测程序
查看当前光标移动了多少字节：f.tell()
将内存中的文件内容直接刷到硬盘：f.flash()
硬盘删除的数据原理：
-
- 先将硬盘内容塞满再删除，就能可靠的删除数据
函数
什么是函数？（昨日已经讲过）
为什么要用函数？
提高开发效率、减少代码冗余、提高程序的扩展性
调用函数的固定格式：
- 函数名+括号
- 函数名只要遇到括号会立即执行函数体代码
- 代码中遇到函数名+括号，优先级最高（先去执行函数，再看下面的代码）
函数的基本应用
函数必须先定义后调用，定义过的函数可以在任意位置调用
s = 'hello' print(len(s)) # len()是内置函数
s = 'hello' l = [1,2,3,4,5] print(len(s),len(l))
def my_len(): # 函数的定义、自定义函数 n = 0 for i in l: n += 1 print(n) print(my_len()) my_len() # 函数的调用就相当于使用工具
'''
我们自己写的函数的问题
1.没有返回值，只能固定的执行打印操作
2.只能够固定的统计某一个容器类型的长度
'''
函数内要想返回给调用着值，必须用关键字return
- 不写return：函数默认返回None
def func(): print('hahaha') res = func() print(res)
- 只写return：return除了可以返回值之外，还可以直接结束整个函数的运行
# 只写return，返回的也是None def func(): l = ['jason','egon'] while True: for i in l: if i == 'egon' # 当i为egon的时候，直接结束函数运行 return print('dsadasdadasd') # 这一行代码永远不会执行 print(i) func()
- 写return None：与上面的只写return相同
def func(): return None res = func() print(res)
- 写return返回一个值：这个值可以是任意数据类型
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()...func5()) # 123 [1, 2, 3] {'name': 'jason'} (1,) {1, 2, 3, 4, 5} True
- 写return返回多个值：return会自动将多个值以元祖的形式返回给调用者
def func(): return 1,2,3,4 # 返回的是(1,2,3,4) res = func() print(res) def func() return 'a','b','c' # 返回的是('a','b','c') res = func() print(res) def func() return [1,2,3],[4,5,6],[7,8,9] # 返回的是([1,2,3],[4,5,6],[7,8,9]) res = func() print(res) def func() return {'name':'jason','name':'egon'} # 返回的是({'name':'jason'},{'name':'egon'}) res = func() print(res)
'''
1.为什么组织成元祖返回
函数不希望自己处理的结果被修改（所以跟元祖挂钩了）
2.如何不返回元祖？
自己定义返回值，不让return操作
'''
1）. 返回多个值，并且不想让return帮你做处理,需要我们自己手动加上想要返回的数据类型符号
def func(): return [[1,2,3,4],[1,2,3,4],[1,2,3,4]] res = func() print(res)
2）.自己 给定 形参
s = 'hello' l = [1,2,3,4,5] 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传了一个参数
'''
1.所有函数都有返回值，无论你写不写return（这句话是对的）
python中所有的函数都有返回值，不写的情况下默认返回None
2.光写return或者return None并不是为了考虑返回值，而是为了结束函数的运行
'''
函数参数的两大类型：
形参：在函数定义阶段括号内写的变量名，如上代码中的args
实参：在函数的调用阶段，括号内实际传入的值，叫实际参数，简称实参，如上代码中的 l
形参与实参的关系：
- 形参就相当于变量名，而实参就相当于变量的值
- 函数调用传入参数的过程中，就是给形参变量名赋值的过程
注意：形参和实参的绑定关系只在函数的调用阶段存在，函数运行结束时自动解除关系，只在函数内部有效，函数外部无任何影响
函数的简易结构：
def 函数名(形参1，形参2，....):
''' 函数的注释，用来描述该函数的作用以及各个形参的类型 '''
函数体代码1
函数体代码2
...
return 函数的返回值
def func(x,y): ''' print(help(func)) 该函数的作用 :param x:对形参x的解释 :param y:对形参y的解释 :return: 对函数返回值的解释 ''' print('hahah') return('heihei')
位置参数：
在函数定义阶段，按照位置从左往右依次书写的变量名，叫做函数位置形参
位置形参在调用的时候，必须为其传值；位置实参在函数的调用阶段，传入的参数会按照位置一一对应给形参
传参时，有两种方式：
- 第一种：直接按照位置传参，一一对应
- 第二种：指名道姓传参,关键字传参
my_max(x=10,y=20)、my_max(10,y=20)都行
my_max(y=40,20)、my_max(20,y=40,x=30)都不行
注意：在函数调用阶段，位置参数和关键字参数可以混合使用，但是必须保证
- 1.位置参数必须在关键字参数的前面（越短的越靠前，越长的越复杂的越靠后）
- 2.同一个形参不能被多次赋值
求两个数的大小，返回大的那个：
def my_max(x,y): if x > y: return x else: return y res = my_max(1) # 在调用函数的时候，少一个实参是不行的 res = my_max(1,2,3) # 在调用函数的时候，多一个实参也不行 print(res)
默认值参数：
在函数的定义阶段，形参(变量名)就已经被赋值了
- 在调用时可以不为默认值形参传值，默认使用定义阶段就已经绑定的值；
- 在调用的时候如果可以给默认值形参传参，传了那么就使用已经传的值；
在定义阶段，默认值形参必须放在位置形参的后面
def my_max(x,y=100): if x> y: return x return y res = my_max(200) print(res)
def register(username,age,gender='male'): print(username,age,sexy) register('jason',18) register('tank',28) register('egon',84) register('kevin',58) register('xiaohou',17,'female')
默认值参数的应用场景(*)
当形参接收的值比较单一的情况下，通过可以考虑默认值形参
def info(username,hobby,l=[]): l.append(hobby) print('%s 的爱好是 %s'%(username,l)) info('jason','study') info('tank','生蚝') info('kevin','喝腰子汤') info('egon','女教练') # 面试坑点
执行结果为
jason 的爱好是 ['study']
tank 的爱好是 ['study', '生蚝']
kevin 的爱好是 ['study', '生蚝', '喝腰子汤']
egon 的爱好是 ['study', '生蚝', '喝腰子汤', '女教练']
解决方法1：
def info(username,hobby,l=[]): l.append(hobby) print('%s 的爱好是 %s'%(username,l)) info('jason','study',[]) info('tank','生蚝',[]) info('kevin','喝腰子汤',[]) info('egon','女教练',[])
执行结果为
jason 的爱好是 ['study']
tank 的爱好是 ['生蚝']
kevin 的爱好是 ['喝腰子汤']
egon 的爱好是 ['女教练']
解决方法2：
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','女教练')
执行结果为
jason 的爱好是 ['study']
tank 的爱好是 ['生蚝']
kevin 的爱好是 ['喝腰子汤']
egon 的爱好是 ['女教练']
m = 100 def my_max(x,y=m) print(x,y) m = 222 my_max(111) # 111 100
m = 100 def my_max(x,y=m,z=n) print(x,y,n) m = 222 n = 101 my_max(111) # 报错
'''
如上代码所示：
（暂）函数在定义阶段，内部所使用的变量都已经初始化完毕了，不会因为调用的位置的变化，而影响到内部的值；
函数无论在何地被调用，都会跑到函数定义阶段去执行代码，形参中用到的值都是往函数定义阶段代码往上找；
'''
可变长参数
站在调用函数传递实参的角度来看：实参的个数不固定的情况，也就意味着形参也不固定
站在形参的角度来看：可以用 * 和 ** 来接收多余的（溢出的）位置参数和关键字参数
-
站在形参的角度，看 * ：
形参中的*会将多余的（溢出的）位置实参，统一用元祖的形式处理，传递给 * 后面的形参名
def func(x,y,*z): print(x,y,z) # z = (3,4,5,6) func(1,2,3,4,5,6) # 1 2 (3,4,5,6)
-
站在实参的角度，看 * ：
def func(x,y,z): print(x,y,z) ''' 解压赋值的方法 l = [1,2,3] a,b,c = l func(a,b,c) ''' print(*[1,2,3]) # 等价于func(1,2,3) # * 会将列表打散成位置实参一 一传入func(1,2,3)
def func(x,*z): print(x,z) func(1,z=1) # 报错，*在形参中只能接收多余的位置实参，不能接收关键字实参
def func(x,*z): print(x,z) func(1,*{1,2,3}) # * 只能将列表、元祖、集合、字符串打散 # * 的内部你可以看成是for循环
-
站在形参的角度看**：
def func(x,y,**z): print(x,y,z) func(1,2,3,4,5,6) # 报错
def func(x,y,**z): print(x,y,z) # z = {'z':1,'a':2,'b':3} func(1,2,z=1,a=2,b=3) # 1 2 {'z':1,'a':2,'b':3} # 会接收所有多余的关键字参数，并将关键字参数转换成字典的形式，字典的key就是关键字的名字,字典的value就是关键字的名字指向的值，将字典交给** 后面的变量名
-
站在实参的角度看 **：
def func(x,y,z): print(x,y,z) d = {'x':1,'y':2,'z':333} func(**d) # 结果为1 2 333 ，等价于func(x=1,y=2,z=333) # ** 会将字典拆封成key = value的形式
** 与 * 的总结
* 在形参中能够接收多余的位置参数，组成一个元祖赋值给 * 后面的变量名
** 在形参中能够接收多余的关键字参数，组织成一个字典赋值给** 后面的变量名
* 在实参中能够将列表、元祖、集合、字符串 打散成位置实参的形式传递给函数（ * 就看作是for循环取值）
** 在实参中，能将字典打散成key = value 的形式，按照关键字参数传递给函数
假设需求：你写的函数，无论调用者按照正确传参的方式无论怎么传，你的函数都能够正常执行
def func(*x,**y): print(x,y) func(1,2,3,4,5,6,x=1,y=2,z=3) # 结果为1 2 3 4 5 6 {'x':1,'y':2,'z':3}
'''
注意：python中推荐形参 * 和** 通用的写法
def func( *args,**kwargs) print(args,kwargs) func(1,2,3,4,5,6,x=1,y=2,z=3)
'''
