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)))
map()
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))
filter()
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))
reduce()
区别:
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)
map,filter,reduce
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