python函数基础学习
函数的定义与调用：
def 函数名（参数1，参数2）：
‘’’函数注释’’’
print(‘函数体’)
return 返回值
定 义：def关键字开关，空格之后接函数名和圆括号，最后冒号结尾
def 是固定且不可变的
函数名：函数名是包含字母、数字、下划线的任意组合，（不能以数字开头）
函数调用： 返回值 = 函数名 （参数1，参数2）
函数返回值：
1- return的作用：结束一个函数的执行
2- 首先返回值可以是任何的数据类型
3- 函数可以有返回值：如有返回值，必须要用变量接受才有效果
也可以没有返回值：
- 不写return 的时候，函数返回值为 None
- 只写一个return的时候，函数返回值为 None
- return Nonede 时候，函数返回值为None(几乎不用)
4- return返回一个值（一个变量）
5- return返回多个值（多个变量）：多个值之间用逗号隔开，以元组的形式返回
接受：可以用一个变量接受，也可以用多个变量接收（返回几个就用的几个变量）
函数的参数：
1- 实参和形参：
形参：是函数定义时候定义的参数
实参：函数调用的时候传进的参数
2- 传递多个参数：
可以传递多个参数，多个参数之间用逗号隔开。
从传参的角度上，调用函数是传参数有两种方式：
- 按照位置传参数
- 按关键字传参数
用法：1-位置参数必须在关键字参数的前面
2-对于一个参数只能赋值一次
3- 默认参数：
用法：为什么要用默认参数？将变化比较小的值设置成默认参数
定义：默认参数可以不传，不传的时候用的就是默认值，如果传会覆盖默认值
默认的值是在定义函数的时候就已经确定了
3- 动态参数：
按位置传值多余的参数都会有args统一接收，保存为一个元组（tuple）的形式
按关键字传值接收多个关键字参数，由 kwargs 接收，保存为一个字典（dict）的形式
小结 ：
1.定义：def 关键词开头，空格之后接函数名称和圆括号()。
2.参数：圆括号用来接收参数。若传入多个参数，参数之间用逗号分割。
参数可以定义多个，也可以不定义。
参数有很多种，如果涉及到多种参数的定义，应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。
如上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序
3.注释：函数的第一行语句应该添加注释。
4.函数体：函数内容以冒号起始，并且缩进。
5.返回值：return [表达式] 结束函数。不带表达式的return相当于返回 None
def 函数名(参数1,参数2,*args,默认参数,**kwargs):
"""注释：函数功能和参数说明"""
函数体
……
return 返回值
python函数进阶学习
三元运算符
结果 + if + 条件 + else + 结果
一、命名空间和作用域
命名空间的本质：存放着名字与值得绑定关系
命名空间一共分为三种：
全局命名空间
局部命名空间
内置命名空间
三者之间得加载与取值顺序：（命名空间和作用域是分不开的）
加载顺序：内置命名空间（运行前加载）->
>全局命名空间（运行中：从上到下加载） ->
>局部命名空间（运行中：调用才加载）<
取 值 ：
在局部调用：局部命名空间->全局命名空间->内置命名空间
在全局调用：全局命名空间->内置命名空间
作用域：
为什么要有作用域的概念：
为了函数内的变量不会影响到全局
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域
全局作用域：包含内置名称空间，全局名称空间，在整个文件的任意位置都能被引用，全 局有效
局部作用域：局部名称空间，只能在局部 范围内生效
站在全局看：使用名字：
如果全局有用全局的：如果全局没有用内置的
二、函数嵌套与作用域链
函数的嵌套调用：
1 #函数的嵌套调用 2 3 def max2(x,y): 4 5 m = x if x>y else y 6 7 return m 8 9 10 11 def max4(a,b,c,d): 12 13 res1 = max2(a,b) 14 15 res2 = max2(res1,c) 16 17 res3 = max2(res2,d) 18 19 return res3 20 21 22 23 ...max4(23,-7,31,11)...
嵌套定义：定义在内部的函数无法直接在全局被调用
为了保护内部函数，确定内部函数只能在外部函数中被调用
def animal(): def tiger(): print(‘ bark ’) print(‘ eat ’) tiger() animal()
函数的作用域链：
三、函数名的本质(——内存地址)
1- 可以被引用
2- 可以被当作容器类型的元素
3- 可以当作函数的参数和返回值（可以当做普通变量使用）
四、闭包
内部函数包含对外部作用域而非全局作用名字的引用。（函数对上层域名字的引用）
def func(): name = ‘eva’ def inner(): print(name)
装饰器
装饰器的本质：一个闭包函数
装饰器的功能：在不修改原函数及其调用方式的情况下对原函数的功能镜像扩展
语法糖：
1 import time 2 3 def timer(func): 4 5 def inner(): 6 7 start = time.time() 8 9 func() 10 11 print(time.time() - start) 12 13 return inner 14 15 @timer# ==> func1 = timer(func1)===> 语法糖 16 17 def func1(): 18 19 print(‘in func1’) 20 21 func1()
·开放封闭原则：对扩展开放，对修改封闭
1- 对扩展是开放的
为什么要对扩展开放呢？
我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任 何更新和修改。所以我们必须允许代码扩展，添加新功能。
2- 对修改是封闭的
为什么要对修改封闭呢？
就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。
装饰器完美的遵循了这个开放封闭原则。
装饰器的主要功能和固定格式：在不改变函数的调用方式的基础上函数前后添加某些功能。
固定格式：（固定万能格式）
1 def timer(func): 2 3 4 5 def inner(*args,**kwargs): 6 7 8 9 ...执行函数之前要做的... 10 11 12 13 re = func(*args,**kwargs) 14 15 16 17 ...执行函数之后要做的... 18 19 20 21 return re 22 23 24 25 return inner
带参数的装饰器：
def outer(flag): def timer(func): def inner(*args,**kwargs): if flag: print(“执行函数之前要做的”) re = func(*args,**kwargs) if flag: print(“执行函数之后要做的”) return re return inner return timer @outer(False) def func(): print(111) func()
多个装饰器修饰同一个函数：
def wrapper1(func): def inner(): print(‘wrapper1,before func’) func() print(‘wrapper1,after func’) return inner def wrapper2(func): def inner(): print(‘wrapper2,before func’) func() print(‘wrapper2,after func’) return inner @wrapper1 @wrapper2 def f(): print(‘in f’) f()
递归与二分算法
递归：在一个函数里调用这个函数本身
1 import sys 2 3 print(sys.setrecursionlimit(100000))
递归实现三级菜单：
1 menu = { 2 ‘北京’:{ 3 ‘海淀’：{ 4 ‘五道口’：{ 5 ‘soho’：{}, 6 ‘网易’：{}, 7 ‘google’：{}, 8 }, 9 ‘中关村’：{ 10 ‘爱奇艺’：{}, 11 ‘汽车之家’：{}, 12 ‘youku’：{}, 13 }， 14 ‘上地’：{ 15 ‘百度’:{}, 16 }, 17 ‘昌平’: { 18 ‘沙河’：{ 19 ‘老男孩’：{}, 20 ‘北 航’：{}, 21 }， 22 ‘天通苑’:{}, 23 ‘回龙观’:{}, 24 }, 25 ‘朝阳’:{}, 26 ‘东城’:{}, 27 }， 28 ‘上海’：{ 29 ‘闵行’：{ 30 ‘人民广场’：{ 31 ‘炸鸡店’：{} 32 }, 33 }, 34 ‘浦东’：{}, 35 }, 36 ‘山东’：{}, 37 } 38 39 def three(dic): 40 for key in dic : 41 print(key) 42 k = input(“>>>>>>>>”) 43 if k in dic: 44 three(dic[k]) 45 three(dic)
二分查找算法：
1 l = [ 2,3,5,10,15,16,18,22,26 ] 2 3 def find ( l,aim,start,end ): 4 5 mid = ( end+start ) // 2 6 7 if (l[mid] > aim): 8 9 end = mid 10 11 return find(l,aim,start,end) 12 13 elif (l[mid] < aim): 14 15 start = mid 16 17 return find(l,aim,start,end) 18 19 else: 20 21 return mid 22 23 print( find( l,15,start=0,end=len(1)-1 ) )
