第三篇、Python函数

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