1.1函数简介
1.1.1什么是函数
函数就是具有某个具体功能的工具
1.1.2为什么要用函数
提供开发效率
减少代码冗余
提高程序的扩展性
1.1.11定义一个函数
def是定义函数的关键字
函数名:函数名的命名规则与变量名一致
1.不能以关键字(******)
2.函数也应该做到见名知意
函数在定义的时候只检测函数体语法 不执行函数体代码
def func():
print('hello')
1.1.12调用函数的固定格式
函数名+括号
函数名只要遇到括号会立即执行函数体代码
代码中遇到函数名加括号 优先级最高
先去执行函数 再看下面的代码
1.2函数的返回值
函数内要想返回给调用者值 必须用关键字return
1.不写return
2.只写return
3.写return None
4.写return返回一个值
5.写return返回多个值
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 不写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)
ps:
1.所有的函数都有返回值,无论你写不写return
python中所有的函数都有返回值 不写的情况下默认返回None
2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行
1.3函数的参数
1.3.1函数参数的两大类型
形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参
实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参
形参与实参的关系
形参就相当于变量名,而实参就相当于变量的值
函数调用传参的过程 就是给形参变量名赋值的过程
ps:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除
只在函数内部有效 函数外部无任何影响
1.3.2函数的注释
def func(x,y): """ 该函数的作用 :param x: 对形参x的解释 :param y: 对形参y的解释 :return: 对函数返回值的解释 """ print('hahaha') return 'heihei' print(help(func)) print(help(len))
1.3.3位置参数
# 位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参 # 位置形参在调用的时候 必须为其传值 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) # 位置参数已经赋值给x了 后面的关键字参数就不能再赋值了
ps:在函数的调用阶段 位置参数和关键字参数可以混合使用
但是必须保证
1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
2.同一个形参不能被多次赋值
1.3.4默认参数
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了 # 在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值 # 在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值 # 在定义阶段 默认值形参必须放在位置形参的后面 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 # m = 222 并没有为函数传参 my_max(111) # 结果为: 111 100 def func(x,y=100): print(x,y)
ps:函数在定义阶段 内部所使用的变量都已经初始化完毕了
不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)
函数无论在什么地方被调用
都会跑到函数定义阶段去执行代码
形参中用到的值都是往函数定义阶段代码往上找
1.3.5可变长参数
可变长参数
站在调用函数传递实参的角度 实参的个数不固定的情况
也就意味形参也不固定
站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数
1.3.51站在形参的角度 看 *
形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名
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,)
1.3.52站在实参的角度 看 *
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
1.3.53站在形参的角度 看 **
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就是关键字的名字指向的值 将字典交给**后面的变量名
1.3.54站在实参的角度 看 **
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)
1.4 函数的对象
1.4.1 函数是第一类对象:指的是函数可以当做数据传递
1.4.11 可以被引用 x=1,y=x
def func(x,y): print(x,y) f=func f(1,2)
1.4.12 可当做函数的参数传入
def foo(): print('from foo') def bar(func): # print(func) func() bar(foo)
1.4.13 可以当做函数的返回值
def foo(): print('from foo') def bar(): return foo f=bar() f()
1.4.14 可以当做容器类型的元素
def foo(): print('from foo') def bar(): return foo l=[foo,bar] print(l) l[0]()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def get(): print('get') def put(): print('put') def ls(): print('ls') cmd=input('>>: ').strip() if cmd == 'get': get() elif cmd == 'put': put() elif cmd == 'ls': ls() def get(): print('get') def put(): print('put') def ls(): print('ls') def auth(): print('auth') func_dic={ 'get':get, 'put':put, 'ls':ls, 'auth':auth } # func_dic['put']() cmd = input('>>: ').strip() if cmd in func_dic: func_dic[cmd]()
1.5 函数的嵌套
1.5.1 函数的嵌套调用
def my_max(x,y): if x >= y: return x else: return y
def my_max4(a,b,c,d): res1=my_max(a,b) res2=my_max(res1,c) res3=my_max(res2,d) return res3
1.5.2 函数的嵌套定义
def f1(): def f2(): print('from f2') def f3(): print('from f3') f3() # print(f2) f2() f1()
1.6 名称空间
名称空间指的是:存放名字与值绑定关系的地方,
1.6.1 内置与全局名称空间
内置名称空间(python解释器启动就有):python解释器内置的名字,max,len,print
全局名称空间(执行python文件时生效):文件级别定义的名字
x=1 def func():pass import time if x == 1: y=2 #局部名称空间(函数调用时生效,调用结束失效):函数内部定义的名字 func()
1.6.2 加载与访问顺序
加载顺序:内置---》全局----》局部名称空间
访问名字的顺序:局部名称空间===》全局----》内置
x=1
print(x)
#print(max) max=2 def func(): # max=1 print(max)
func() x='gobal' def f1(): # x=1 def f2(): # x=2 def f3(): # x=3 print(x) f3() f2() f1()
1.6.3 全局与局部作用域
全局作用域(全局范围):内置名称空间与全局名称空间的名字,全局存活,全局有效,globals()
局部作用域(局部范围):局部名称空间的名字,临时存活,局部有效,locals()
#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=111111111111111111111 print(globals()) print(dir(globals()['__builtins__'])) print(locals() is globals()) def func(): # yyyyyyyyyyyyyyyyyyyyyyyy=22222222 print(globals()) print(locals()) func() x=100 def func(): global x x=1 func() print(x) x='global' def f1(): # x=1 def f2(): nonlocal x x=0 f2() print('===f1 innter--->',x) f1() print(x)
1.6.4 强调两点:
1.6.41 打破函数层级限制来调用函数
def outter(): def inner(): print('inner') return inner f=outter() # print(f) def bar(): f() bar()
1.6.42 函数的作用域关系是在函数定义阶段就已经固定了,与调用位置无关
x=1 def outter(): # x=2 def inner(): print('inner',x) return inner f=outter() # print(f) # x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111 def bar(): x=3 f() # x=11111111111111111111111111111111111111111111111111111111111111111111111111111111 bar() x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111
1.7 闭包函数
闭包函数:
1 定义在函数内部的函数
2 该函数的函数体代码包含对外部作用域(而不是全局作用域)名字的引用
3 通常将闭包函数用return返回,然后可以在任意使用
z=1 def outer(): x=1 y=2 def inner(): print(x,y) # print(z) return inner f=outer() print(f.__closure__[0].cell_contents) print(f.__closure__[1].cell_contents) print(f.__closure__)
def bar(): x=111121 y=2222 f() bar()
def foo(x,y): print(x+y) foo(1,2)
def outter(): x=1 y=2 def foo(): print(x+y) return foo f=outter() f()
1.7.1 闭包的意义:
返回的函数对象,不仅仅是一个函数对象,在该函数外还包裹了一层作用域,这使得,该函数无论在何处调用,优先使用自己外层包裹的作用域
1.7.2 应用领域:
延迟计算(原来我们是传参,现在我们是包起来)
1.7.3 爬页面:闭包函数为我们提供了一种新的为函数传参的方式
import requests #pip3 install requests def get(url): response=requests.get(url) if response.status_code == 200: print(len(response.text)) get('https://www.baidu.com') get('https://www.baidu.com') get('https://www.baidu.com') def outter(url): # url = 'https://www.baidu.com' def get(): response=requests.get(url) if response.status_code == 200: print(len(response.text)) return get baidu=outter('https://www.baidu.com') python=outter('https://www.python.org') # baidu() # baidu() # baidu()