目录

创建和调用函数

函数以def打头

#!/usr/bin/env python
# encoding: utf-8

def my_func():
    print("MyFunc.")

my_func()

---

函数的参数

参数分为形参与实参，形参是函数声明时候的参数，实参是在调用函数是，传给函数的参数

#!/usr/bin/env python
# encoding: utf-8

my_list = [1, 2, 3]
name = 'zeng'

def my_func(var_list):
    var_list[0] = 99
def my_func2(var_name):
    var_name = 'zeng2'

#传入的是一个对象，因此函数内部的修改会改动list的内容
my_func(my_list)
print(my_list)#[99, 2, 3]

#传入的是一个临时变量var_name，指向传入的参数name
#函数内部对var_name的改变，不会对name有影响
#因此函数内部的修改会改动name指向的内容
my_func2(name)
print(name)#zeng
# my_func2相当于下面的操作
var_name = name
print(var_name)#zeng
var_name = '222'
print(var_name)#222
print(name)#zeng

---

给一个函数写上注释文档

通过三个引号给函数写上内部注释文档，函数的内部注释文档可以通过doc来显示

#!/usr/bin/env python
# encoding: utf-8

my_list = [1, 2, 3]

def my_func(var_list):
    """
    修改var_list的第一个数据项为99
    :param var_list:传入的list
    :return:None
    """
    var_list[0] = 99

my_func(my_list)
print(my_list)
print(my_func.__doc__)

---

函数的返回值

有的时候，函数需要返回值，返回值可以是对象，也可以是值

#!/usr/bin/env python
# encoding: utf-8

name = 'zeng'
def my_func(var_name):
    var_name = 'zeng2'
    return var_name

def my_func2():
    my_list = [1, 2, 3]
    return my_list

res_name = my_func(name)
res_list = my_func2()
print(res_name)#zeng2
print(res_list)#[1, 2, 3]

---

默认参数

默认参数在参数定义的过程中，为形参赋上了初值，如果不对此形参赋值，也能有一个默认的值

#!/usr/bin/env python
# encoding: utf-8

name = 'zeng'
age = 99
def my_func(var_name='zeng', var_age=24):
    print("name:{0}, age:{1}".format(var_name, var_age))

my_func(var_name=name)#name:zeng, age:24
my_func(var_age=age)#name:zeng, age:99
my_func()#name:zeng, age:24

---

可变参数

当不确定参数的个数有多少个的时候，就可以使用可变参数了

#!/usr/bin/env python
# encoding: utf-8

name = 'zeng'
age = 99
def my_func(*param):
    print("有%d个参数" % len(param))
    print("第一个参数值为:", param[0])

def my_func(*param, extra=2):
    print("有%d个参数" % len(param))
    print("第一个参数值为:", param[extra])

my_func('z', 'r', 'l')#有3个参数,第一个参数值为: z
my_func(100, 'z', 'r', 'l', 99, 100)#有6个参数,第一个参数值为: 100
my_func('z', 'r', 'l', extra=2)#有3个参数,第一个参数值为: l

这里*号的作用其实是一种解包的操作

---

global关键字

假设一个函数的内部要修改全局变量的值(一般不建议这么做)，这是可以用关键字global来告诉编译器，让他知道在函数内部所做的修改对全局变量生效

#!/usr/bin/env python
# encoding: utf-8

name = 'zeng'
def my_func():
    global name
    name = 'zeng99'

print(name)#zeng
my_func()
print(name)#zeng99

---

内嵌函数和闭包

内嵌函数

函数中还可以嵌套一个函数

#!/usr/bin/env python
# encoding: utf-8

name = 'zeng'
def my_func():
    print("my_func")
    def my_func_child():
        print("my_func_child")
    def my_func_child2():
        print("my_func_child2")
    my_func_child()
    my_func_child2()

my_func()#my_func my_func_child my_func_child2

闭包

跟内嵌函数不一样的是，外层函数返回了内层函数的函数名，最大的作用就是可以通过给外层函数传不同的参数，区别每次的调用

#!/usr/bin/env python
# encoding: utf-8

name1 = 'zeng1'
name2 = 'zeng2'
child_name1 = 'zeng_child1'
child_name2 = 'zeng_child2'
def my_func(var_father_name):
    print("my_func")
    def my_func_child(var_child_name):
        print("var_father_name:%s, var_child_name:%s" % (var_father_name, var_child_name))
    return my_func_child

f = my_func(name1)
f(child_name1)#var_father_name:zeng1, var_child_name:zeng_child1
f = my_func(name2)
f(child_name2)#var_father_name:zeng2, var_child_name:zeng_child2

一个比较常用的html的例子

#!/usr/bin/env python
# encoding: utf-8

name1 = 'a'
name2 = 'img'
content = 'zeng_child1'
def tag(var_tag_name):
    def add_tag(var_content):
        print("<%s>%s</%s>" % (var_tag_name, var_content, var_tag_name))
    return add_tag

f = tag(name1)
f(content)#<a>zeng_child1</a>
f = tag(name2)
f(content)#<img>zeng_child1</img>

后面高级程序设计技术部分，所用到的装饰器，其实也是闭包的一种体现

---

lambda表达式

Lambda表达式语法：在冒号左边放元还是的参数，可以是多个参数，用逗号隔开；冒号右边是返回值

#!/usr/bin/env python
# encoding: utf-8

name1 = 'zeng1'
def my_func(var_left, var_right):
    return var_left ** 2 + var_right
print(my_func(2, 3))#7

#换成lambda的方法来完成上面函数的功能
#Lambda表达式语法：在冒号左边放元还是的参数，
#可以是多个参数，用逗号隔开；冒号右边是返回值
my_func2 = lambda var_left, var_right : var_left ** 2 + var_right
print(my_func2(2, 3))#7

lambda的作用
1、完成的函数功能很单一时候，是代码看起来更简洁
2、不需要考虑函数名

---

两个内建函数

filter()函数

filter()可以配合Lambda表达式轻松实现从大量的数据中过滤出自己关心的部分
filter()有两个参数，第一个是需要调用的过滤函数，也可以为空，设置为空则把第二个参数中为False的部分给过滤掉；第二个参数是要过滤的数据部分

#!/usr/bin/env python
# encoding: utf-8

tmp = filter(None, [1, 0, True, False])
print(list(tmp) [1, True]

#设置过滤函数
def filter_func(var):
    return not var
tmp = filter(filter_func, [1, 0, True, False])
print(list(tmp)) [0, False]

在这里所使用的过滤函数相当简单，则直接可以考虑用lambda来替代

#!/usr/bin/env python
# encoding: utf-8

tmp = filter(None, [1, 0, True, False])
print(list(tmp))#[1, True]

#设置过滤函数
def filter_func(var):
    return not var
tmp = filter(filter_func, [1, 0, True, False])
print(list(tmp))#[0, False]
tmp = filter(lambda var : not var, [1, 0, True, False])
print(list(tmp))#[0, False]

map()函数

map()函数同样也是两个参数，第一个参数与filter()相同，第二个参数则是要处理的映射序列，比如我们想要把第二个参数的内容全部做平方，则可以这么做

#!/usr/bin/env python
# encoding: utf-8

def map_func(var):
    return var**2
tmp = map(map_func, [1, 2, 3])
print(list(tmp))#[1, 4, 9]

tmp = map(lambda var : var ** 2, [1, 2, 3])
print(list(tmp))#[1, 4, 9]

---

递归

函数在自身内部在满足条件的时候循环调用自己，常用的例子为计算阶乘

#!/usr/bin/env python
# encoding: utf-8

#非递归计算
def not_recursive_func(var):
    res = var
    for i in range(1, var):
        res *= i
    return res
res = not_recursive_func(4)
print(res)#4*3*2*1

#递归计算
def recursive_func(var):
    if var == 1:
        return 1
    else:
        return var * recursive_func(var-1)

res = recursive_func(4)
print(res)#4*3*2*1

---