1、函数和过程的定义：
1） 函数定义：函数是逻辑结构化和过程化的一种编程方法。
2） 过程定义：过程就是简单特殊没有返回值的函数。
当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，所以在python中即便是过程也可以算作函数。
3）编写函数的注意事项：
a. 尽量不要使用全局变量。
b. 如果参数是可变类型数据，在函数内，不要修改它。
c. 每个函数的功能和目标要单纯，不要试图一个函数做很多事情。
d. 函数的代码行数尽量少。
e. 函数的独立性越强越好，不要跟其它的外部东西产生关联。
python中函数定义方法： def test(x): "The function definitions" #函数体 x+=1 #函数体 return x #函数体：写在缩进块中 def:定义函数的关键字 test：函数名，需要符合标识符规则 （）：内可定义形参
“：”：不可省略， "":文档描述（非必要）一般在每个函数名字的下面，还要比较多的说明，这个被称为“文档”，在文档中主要是说明这个函数的用途。(三引号的文档内容) x+=1：泛指代码块或程序处理逻辑 return：定义返回值 调用运行：可以带参数也可以不带--函数名()
2. 函数的意义：
1）代码重用
2）保持一致性，易维护
3）可扩展性
3. 函数返回值
返回值数=0:返回None
返回值数=1:返回object
返回值数>1:返回tuple，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值。
函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。类似break作用：return可以结束正在执行的函数。将变量result的值返回，把返回值赋值给变量。如果没有赋值语句，函数照样返回值，但是它飘忽在内存中，我们无法得到，并且最终还被当做垃圾被python回收了。
4.传值方式和参数
1) 传值方式
● 传统方式----函数调用时传参，直接给参数
● 调用函数传值----通过变量间接给参数。要传的值放到元组（或字典）中，赋值给一个变量bars，然后在函数调用时传参add(*bars)的方式，把值传到函数内。有点像收集参数的逆过程。注意的是，元组中元素的个数，要跟函数所要求的变量个数一致。
使用一个星号*，是以元组形式传值，如果用**的方式，是以字典的形式传值。
2) 参数
本质上就是一个“占位符”，当调用一个函数的时候，并不是赋值了一份参数的值来替换占位符，而是把占位符指向了变量，进而指向了对象。换个角度说，就是通过一连串的接力动作，把对象传给了函数。这样说来，你就可以在函数内部改变那个对象了。
a. 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
b. 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
c. 位置参数是标准调用，按照顺序以此对参数进行赋值，实参与形参必须数量一致，位置一一对应。def foo(p1,p2,p3,...)
d. 关键字参数：位置无需固定，位置参数和关键字参数混用的时候，位置参数一定要在关键字参数的左边。
e. 默认参数：def foo(p1=value1,p2=value2,...)由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面。作用是简化调用，只需要把必须的参数传进去。但在需要的时候，又可以传入额外的参数来覆盖默认参数值。
f. 参数组、可变参数：适用于不确定参数个数的时候，def foo(*args) 和def foo(**kargs)
Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。
参数个数的不确定性：输入的参数个数不确定
● 其它参数全部通过*arg，以元组的形式由arg收集起来。即使只有一个值，也是用tuple收集它。特别注意，在tuple中，如果只有一个元素，后面要有一个逗号。还有一种可能，就是不给那个*args传值，也是许可的，这时候*args收集到的是一个空的tuple。
● 如果用**kargs的形式收集值，会得到dict类型的数据，但是，需要在传值的时候说明“键”和“值”，因为在字典中是以键值对形式出现的。
5. 变量
1）其本质也是占位符。变量名命名得符合标识符规则，必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头。通常使小写字母来命名python中的变量，也可以在其中加上下划线什么的，表示区别。
全局变量：在程序的一开始定义的变量，作用域是整个程序
局部变量：在子程序中定义的变量，作用域是定义该变量的子程序。
当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。如果在局部要对全局变量修改，需要在局部也要先声明该全局变量：使用global 变量名。
2）读取变量顺序：如果无global关键字，先局部再全局，对于不可变数据类型的变量无法对全局变量重新赋值，对于可变数据类型的变量，可以对内部元素进行操作；如果有global关键字，先局部，再局部的全局变量，最后再全局，变量的本质就是全局的那个变量，可读取可赋值。
3） global关键字用来在函数或其他局部作用域中使用全局变量。但是如果不修改全局变量也可以不使用global关键字。
nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量。
6. 前向引用
python是解释性语音，函数的定义必须在调用前面。
7.递归函数
递归特性:
a. 必须有一个明确的结束条件
b. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
c. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html
尾递归优化：http://egon09.blog.51cto.com/9161406/1842475
8. Lambda匿名函数：使代码简洁
lambda arg1, arg2, ...argN : expression using arguments
● 在lambda后面直接跟变量
● 变量后面是冒号
● 冒号后面是表达式，表达式计算结果就是本函数的返回值
9. 函数式编程：map(), reduce(), filter()
满足俩个特性任意一个即为高阶函数
1) 函数的传入参数是一个函数名
2) 函数的返回值是一个函数名
map(func,seq)
array=[1,3,4,71,2] ret=[] for i in array: ret.append(i**2) print(ret) #如果我们有一万个列表,那么你只能把上面的逻辑定义成函数 def map_test(array): ret=[] for i in array: ret.append(i**2) return ret print(map_test(array)) #如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么可以这样 def add_num(x): return x+1 def map_test(func,array): ret=[] for i in array: ret.append(func(i)) return ret print(map_test(add_num,array)) #可以使用匿名函数 print(map_test(lambda x:x-1,array)) #上面就是map函数的功能,map得到的结果是可迭代对象 print(map(lambda x:x-1,range(5)))
filter(func,seq)
#电影院聚集了一群看电影bb的傻逼,让我们找出他们 movie_people=['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao'] def tell_sb(x): return x.startswith('sb') def filter_test(func,array): ret=[] for i in array: if func(i): ret.append(i) return ret print(filter_test(tell_sb,movie_people)) #函数filter,返回可迭代对象 print(filter(lambda x:x.startswith('sb'),movie_people))
reduce(func, iterable[, initializer])
from functools import reduce #合并,得一个合并的结果 array_test=[1,2,3,4,5,6,7] array=range(100) #报错啊,res没有指定初始值 def reduce_test(func,array): l=list(array) for i in l: res=func(res,i) return res # print(reduce_test(lambda x,y:x+y,array)) #可以从列表左边弹出第一个值 def reduce_test(func,array): l=list(array) res=l.pop(0) for i in l: res=func(res,i) return res print(reduce_test(lambda x,y:x+y,array)) #我们应该支持用户自己传入初始值 def reduce_test(func,array,init=None): l=list(array) if init is None: res=l.pop(0) else: res=init for i in l: res=func(res,i) return res print(reduce_test(lambda x,y:x+y,array)) print(reduce_test(lambda x,y:x+y,array,50))
区别:
map()是依次处理，对列表每个元素进行处理，结果是处理后的列表，顺序一样。
filter()是遍历元素，进行筛选处理，布尔值为True的的留下来，得出一个筛选后的结果。
reduce()是压缩处理，最后得出一个值。
#map,filter,reduce,可以处理所有数据类型 name_dic=[ {'name':'alex','age':1000}, {'name':'wupeiqi','age':10000}, {'name':'yuanhao','age':9000}, {'name':'linhaifeng','age':18}, ] #利用filter过滤掉千年王八,万年龟,还有一个九千岁 def func(x): age_list=[1000,10000,9000] return x['age'] not in age_list res=filter(func,name_dic) for i in res: print(i) res=filter(lambda x:x['age'] == 18,name_dic) for i in res: print(i) #reduce用来计算1到100的和 from functools import reduce print(reduce(lambda x,y:x+y,range(100),100)) print(reduce(lambda x,y:x+y,range(1,101))) #用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb name=['alex','wupeiqi','yuanhao'] res=map(lambda x:x+'_sb',name) for i in res: print(i)
10、内置函数
all() # 判断序列的所有元素是否布尔值，返回布尔值。e.g. print(all([1,2,""])) -- False any() # 当序列中有某个元素的布尔值为True，返回True。 e.g. print(all([1,2,""])) -- True adb() # 获取绝对值。 e.g. print(abs(-1)) sum() # 加法。 e.g. print(sum([0,4], 2)) -- 6 divmod() # 取商得余数。 e.g. print(divmod(10,3)) --(3, 1) pow(x，y，z) #求次方。两个参数：x**y；三个参数:x**y%z. e.g. print(pow(3,3,2)) -- 1 round() # 四舍五入 e.g. print(round(4.5)) -- 4 bin() # 十进制转换成二进制。e.g. print(bin(3)) -- 0b11 hex() # 十进制转换成十六进制。e.g. print(bin(12)) -- 0xc oct() # 十进制转换成八进制。e.g. print(oct(9)) -- 0o11 float() # 将一个数值或者字符转换成浮点型数值,不提供参数的时候，返回0.0。 e.g. print(float(3)) -- 3.0 int() # 将一个数字或base类型的字符串转换成整数。 dict() # 转换成字典 list() # 转换成列表 tuple() # 转换成元组 set() # 创建一个可变集合。 print(set("qiwsir")) -- {'r', 's', 'q', 'w', 'i'} frozenset() #创建一个不可变集合。 e.g. print(frozenset("qiwsir")) -- frozenset({'w', 'i', 's', 'q', 'r'}) str() # 转换成字符串 format() # 格式化字符串 eval() # 提取字符串的数据结构或者运行字符串的表达式。e.g. dic_str="{'name':'alex'}" d1=eval(dic_str) print(d1['name']) -- alex ； express="3+(4/2-1)*7" print(eval(express)) -- 10.0 bytes() # 将字符（串）转换成对应的字节码， e.g. print(bytes("陈",encoding="utf-8")) print(bytes("陈",encoding="utf-8").decode("utf-8"))编码解码要一致 len() # 返回对象（字符、列表、元组等）长度或项目个数。 enumerate() #对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），利用enumerate可以同时获得索引和值。一般跟for一起使用。list1 = ["22", "33"] for index, item in enumerate(list1): print(index,item) -- 0 22 ， 1 33 map() # 依次处理列表每个元素，结果是处理后的列表，顺序一致。 filter() # 遍历元素，进行筛选处理，布尔值为True的的留下来，得出一个筛选后的结果 slice() # 切片。 e.g. l='qiwsir' print(l[slice(1,4,2)]) -- is reversed() # print(list(reversed([1,2,3]))) sorted() # 同类型比较大小并排序。 e.g. l=[3,6,-1,0] print(sorted(l)) -- [-1,0,3,6] l=['c','a'] print(sorted(l)) -- ['a', 'c'] max() # 返回序列的最大值 e.g. L=[1,334,-2] print(max(L)) -- 334 min() # 返回序列的最小值 e.g. print(min(L)) -- -2 zip() # 从参数中的多个迭代器取元素组合成一个新的迭代器，又称拉链函数 e.g.print(list(zip(('a','b','c','d'),(1,2,3)))) -- [('a', 1), ('b', 2), ('c', 3)] range() # 创建一个整数列表，一般用在 for 循环中。e.g. for i in range(0, 20, 5): print(i) -- 0 5 10 15 chr() # 转换出ASCII表的对应字符。 e.g.print(chr(97)) -- a。 ord() # 转换出ASCII表的对应的编码。 e.g. print(ord('a')) -- 97 hash() # 返回hash值。可哈希的数据类型可变，不可hash的数据类型不可变。一般用于数字校验。 isinstance(a,b) #判断a是否是b的实例。e.g. print(isinstance('as',str)) --True type() # 返回对象的类型 id() #用于获取对象的内存地址。e.g. print(id(1)) -- 1498639840; print(id('1')) -- 8088912 dir() # 打印出某个对象的方法。 help() # 打印方法的详细使用方式。e.g. print(help(all)) globals() # 返回全局变量的字典（包括系统提供的），修改其中的内容，值会真正的发生改变。 locals() # 返回是当前局部变量的字典，修改locals() 中变量值的时候，实际上对于原变量本身是没有任何影响的。 next() object() open() print() property() repr() #将对象转化为供解释器读取的形式。 vars() delattr() hasattr() getattr()
字典的运算：最小值，最大值，排序 salaries={ 'egon':3000, 'alex':100000000, 'wupeiqi':10000, 'yuanhao':2000 } 迭代字典，取得是key，因而比较的是key的最大和最小值 >>> max(salaries) 'yuanhao' >>> min(salaries) 'alex' 可以取values，来比较 >>> max(salaries.values()) 100000000 >>> min(salaries.values()) 2000 但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键 >>> max(salaries,key=lambda k:salary[k]) 'alex' >>> min(salaries,key=lambda k:salary[k]) 'yuanhao' 也可以通过zip的方式实现 salaries_and_names=zip(salaries.values(),salaries.keys()) 先比较值，值相同则比较键 >>> max(salaries_and_names) (100000000, 'alex') salaries_and_names是迭代器，因而只能访问一次 >>> min(salaries_and_names) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: min() arg is an empty sequence sorted(iterable，key=None,reverse=False)
【参考文献】
http://www.cnblogs.com/linhaifeng/articles/6113086.html
http://blog.51cto.com/egon09