1 什么是函数？
函数是组织好的，可重复使用的，用来实现单一或相关功能的代码块。
2 为什么要用函数？
函数可以提高应用的模块性，和代码重复利用率。它包括内置函数与自定义函数
3 函数的分类：内置函数与自定义函数
内置函数：http://www.cnblogs.com/ldq1996/p/8447100.html
自定义函数：
def fun():
pass
fun()
4 如何自定义函数
原则： 先定义后调用
函数在定义阶段都干了什么：只检测语法，不执行代码
定义函数的三种形式：
#1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
#2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
#3、空函数：设计代码结构
#定义阶段 def tell_tag(tag,n): #有参数 print(tag*n) def tell_msg(): #无参数 print(‘hello world‘) #调用阶段 tell_tag(‘*‘,12) tell_msg() tell_tag(‘*‘,12) ‘‘‘ ************ hello world ************ ‘‘‘ #结论： #1、定义时无参，意味着调用时也无需传入参数 #2、定义时有参，意味着调用时则必须传入参数
5 调用函数
如何调用函数
函数的调用：函数名加括号 1 先找到名字 2 根据名字调用代码
函数的返回值
无return->None return 1个值->返回1个值 return 逗号分隔多个值->元组 什么时候该有返回值？ 调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值 通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果 什么时候不需要有返回值？ 调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值 通常无参函数不需要有返回值
函数参数的应用：形参和实参，位置参数，关键字参数，默认参数，*args，**kwargs
#1、位置参数：按照从左到右的顺序定义的参数 位置形参：必选参数 位置实参：按照位置给形参传值 #2、关键字参数：按照key=value的形式定义的实参 无需按照位置为形参传值 注意的问题： 1. 关键字实参必须在位置实参右面 2. 对同一个形参不能重复传值 #3、默认参数：形参在定义时就已经为其赋值 可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参） 注意的问题： 1. 只在定义时赋值一次 2. 默认参数的定义应该在位置形参右面 3. 默认参数通常应该定义成不可变类型 #4、可变长参数： 可变长指的是实参值的个数不固定 而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs ===========*args=========== def foo(x,y,*args): print(x,y) print(args) foo(1,2,3,4,5) def foo(x,y,*args): print(x,y) print(args) foo(1,2,*[3,4,5]) def foo(x,y,z): print(x,y,z) foo(*[1,2,3]) ===========**kwargs=========== def foo(x,y,**kwargs): print(x,y) print(kwargs) foo(1,y=2,a=1,b=2,c=3) def foo(x,y,**kwargs): print(x,y) print(kwargs) foo(1,y=2,**{‘a‘:1,‘b‘:2,‘c‘:3}) def foo(x,y,z): print(x,y,z) foo(**{‘z‘:1,‘x‘:2,‘y‘:3}) ===========*args+**kwargs=========== def foo(x,y): print(x,y) def wrapper(*args,**kwargs): print(‘====>‘) foo(*args,**kwargs) #5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递 可以保证，传入的参数中一定包含某些关键字 def foo(x,y,*args,a=1,b,**kwargs): print(x,y) print(args) print(a) print(b) print(kwargs) foo(1,2,3,4,5,b=3,c=4,d=5) 结果： 1 2 (3, 4, 5) 1 3 {‘c‘: 4, ‘d‘: 5}
6 高阶函数（函数对象）
#函数是第一类对象，即函数可以当做数据传递 def foo(): print(‘foo‘) def bar(): print(‘bar‘) dic={ ‘foo‘:foo, ‘bar‘:bar, } while True: choice=input(‘>>: ‘).strip() if choice in dic: dic[choice]()
7 函数嵌套
def max(x,y): return x if x > y else y def max4(a,b,c,d): res1=max(a,b) res2=max(res1,c) res3=max(res2,d) return res3 print(max4(1,2,3,4))
8 作用域与名称空间
一 什么是名称空间？ #名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方） 二 名称空间的加载顺序 python test.py #1、python解释器先启动，因而首先加载的是：内置名称空间 #2、执行test.py文件，然后以文件为基础，加载全局名称空间 #3、在执行文件的过程中如果调用函数，则临时产生局部名称空间 三 名字的查找顺序 复制代码 局部名称空间--->全局名称空间--->内置名称空间 #需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例 # max=1 def f1(): # max=2 def f2(): # max=3 print(max) f2() f1() print(max)
作用域
#1、作用域即范围 - 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效 - 局部范围（局部名称空间属于该范围）：临时存活，局部有效 #2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下 x=1 def f1(): def f2(): print(x) return f2 x=100 def f3(func): x=2 func() x=10000 f3(f1()) #3、查看作用域：globals(),locals() LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__ locals 是函数内的名字空间，包括局部变量和形参 enclosing 外部嵌套函数的名字空间（闭包中常见） globals 全局变量，函数定义所在模块的名字空间 builtins 内置模块的名字空间
9 装饰器
原则：开放封闭原则 什么是装饰器： 装饰器他人的器具，本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。 强调装饰器的原则：1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式 装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能
#有参装饰器
def auth(driver=‘file‘): def auth2(func): def wrapper(*args,**kwargs): name=input("user: ") pwd=input("pwd: ") if driver == ‘file‘: if name == ‘egon‘ and pwd == ‘123‘: print(‘login successful‘) res=func(*args,**kwargs) return res elif driver == ‘ldap‘: print(‘ldap‘) return wrapper return auth2 @auth(driver=‘file‘) def foo(name): print(name) foo(‘egon‘)
10 迭代器与生成器及协程函数
迭代器
#1、为何要有迭代器？ 对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器 #2、什么是可迭代对象？ 可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下 ‘hello‘.__iter__ (1,2,3).__iter__ [1,2,3].__iter__ {‘a‘:1}.__iter__ {‘a‘,‘b‘}.__iter__ open(‘a.txt‘).__iter__ #3、什么是迭代器对象？ 可迭代对象执行obj.__iter__()得到的结果就是迭代器对象 而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象 文件类型是迭代器对象 open(‘a.txt‘).__iter__() open(‘a.txt‘).__next__() #4、注意： 迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象 #优点： - 提供一种统一的、不依赖于索引的迭代方式 - 惰性计算，节省内存 #缺点： - 无法获取长度（只有在next完毕才知道到底有几个值） - 一次性的，只能往后走，不能往前退
生成器
什么是生成器？ #只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码 def func(): print(‘====>first‘) yield 1 print(‘====>second‘) yield 2 print(‘====>third‘) yield 3 print(‘====>end‘) g=func() print(g) #<generator object func at 0x0000000002184360> 生成器是迭代器 g.__iter__ g.__next__ #2、所以生成器就是迭代器，因此可以这么取值 res=next(g) print(res)
协程函数
#yield关键字的另外一种使用形式：表达式形式的yield def eater(name): print(‘%s 准备开始吃饭啦‘ %name) food_list=[] while True: food=yield food_list print(‘%s 吃了 %s‘ % (name,food)) food_list.append(food) g=eater(‘egon‘) g.send(None) #对于表达式形式的yield，在使用时，第一次必须传None，g.send(None)等同于next(g) g.send(‘蒸羊羔‘) g.send(‘蒸鹿茸‘) g.send(‘蒸熊掌‘) g.send(‘烧素鸭‘) g.close() g.send(‘烧素鹅‘) g.send(‘烧鹿尾‘)
11 三元运算，列表解析、生成器表达式
三元元算
name=input(‘姓名>>: ‘) res=‘SB‘ if name == ‘alex‘ else ‘NB‘ print(res)
列表生成式
#1、示例 egg_list=[] for i in range(10): egg_list.append(‘鸡蛋%s‘ %i) egg_list=[‘鸡蛋%s‘ %i for i in range(10)] #2、语法 [expression for item1 in iterable1 if condition1 for item2 in iterable2 if condition2 ... for itemN in iterableN if conditionN ] 类似于 res=[] for item1 in iterable1: if condition1: for item2 in iterable2: if condition2 ... for itemN in iterableN: if conditionN: res.append(expression) #3、优点：方便，改变了编程习惯，可称之为声明式编程
生成器表达式
#1、把列表推导式的[]换成()就是生成器表达式 #2、示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性 >>> chicken=(‘鸡蛋%s‘ %i for i in range(5)) >>> chicken <generator object <genexpr> at 0x10143f200> >>> next(chicken) ‘鸡蛋0‘ >>> list(chicken) #因chicken可迭代，因而可以转成列表 [‘鸡蛋1‘, ‘鸡蛋2‘, ‘鸡蛋3‘, ‘鸡蛋4‘,] #3、优点：省内存，一次只产生一个值在内存中
12 函数的递归调用
定义：#递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用 #python中的递归 python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化：http://egon09.blog.51cto.com/9161406/1842475 但是python又没有尾递归，且对递归层级做了限制 #总结递归的使用： 1. 必须有一个明确的结束条件 2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少 3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
最大递归深度的设置
import sys sys.getrecursionlimit() sys.setrecursionlimit(2000) n=1 def test(): global n print(n) n+=1 test() test() 虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归
14 面向过程编程与函数式编程
面向过程式编程
#1、首先强调：面向过程编程绝对不是用函数编程这么简单，面向过程是一种编程思路、思想，而编程思路是不依赖于具体的语言或语法的。言外之意是即使我们不依赖于函数，也可以基于面向过程的思想编写程序 #2、定义 面向过程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么 基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式 #3、优点：复杂的问题流程化，进而简单化 #4、缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身 #5、应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd #6、举例 流水线1： 用户输入用户名、密码--->用户验证--->欢迎界面 流水线2： 用户输入sql--->sql解析--->执行功能
函数式编程是使用一系列函数去解决问题，按照一般编程思维，面对问题时我们的思考方式是“怎么干”，而函数函数式编程的思考方式是我要“干什么”。 至于函数式编程的特点暂不总结，我们直接拿例子来体会什么是函数式编程。 最后我们可以看到，函数式编程有如下好处： #优点 1）代码更简单了。 2）数据集，操作，返回值都放到了一起。 3）你在读代码的时候，没有了循环体，于是就可以少了些临时变量，以及变量倒来倒去逻辑。 4）你的代码变成了在描述你要干什么，而不是怎么去干。
