08-函数

定义函数

函数是能够实现一个具体的功能，是多行代码的集合

def 函数名():
      函数代码

函数的文档说明

• 本质就是注释，这个函数是怎么使用的
• 只不过这个注释，有特定的位置书写要求，要写在特定的位置
• 通过三个双引号的形式给函数添加注释，当鼠标放在函数的时候会自动出现

def function():
    """
    打印输出
    """
    print ("好好学习")

函数参数

• 定义函数的时候是形式参数，调用的时候是实际参数

def func1(a,b):
    c = a + b
    print ("求和的结果是%d" % c)

func1(10,20)

局部变量

• 在函数内部定义的变量，就是局部变量
• 局部变量只能在函数内部使用，不能在函数外部和其他函数中使用
• 局部函数的作用域（作用范围）：当前函数的内部
• 局部变量的生存周期：在函数调用的时候被创建，函数调用结束之后，调销毁

def func2():
    num = 100
    print (num)

全局变量

• 是在函数外部定义的变量
• 可以在函数内部访问全局变量的值
• 但不能在函数内部直接修改全局变量的值，如果想要在内部进行修改，需要添加 global 修饰，即将其变为全局变量

g_num = 200
def func2():
    num = 100
    print (num)

    # 注意global要放在前面
    global g_num
    print ("g_num 的值是%d" % g_num)
    g_num = 20

func2()
print (g_num)

函数返回值

• 返回一个数据值给调用的地方，需要使用关键字 return
• return 关键字的作用，一是将数据值返回，二是遇到 return 程序会终止运行

def add(a,b):
    c = a + b
    return c

result = add(100,200)
print result

函数返回多个数据

• 这种形式默认返回的是元组
• 函数没有 return或者 return 后面没有值，代表返回的是 None

def add2(a,b):
    c = a + b
    d = a - b
    return c,d

resul = add2(20,30)

print ("a + b的结果是%d, a - b的结果是%d" % (resul[0],resul[1]))

函数传参的形式

• 位置传参：之前我们传参的方式都是位置传参
• 关键字传参，指定实参给到哪个形参，注意点：关键字必须是函数的形参名，关键字传参必须放在位置传参的后面

def func3(a,b,c):
    print ("a = %d" % a )
    print ("b = %d" % b)
    print ("c = %d" % c)

func3(c = 300,a = 100,b = 200)

• 混合使用：关键字实参要放到位置实参的后面

func (10, b = 20, c = 30)

缺省参数

• 缺省参数，形参，在函数定义的时候，给形参一个默认值，这个形参就是缺省参数
• 注意点：缺省参数要写在普通参数的后面
• 特点：在函数调用的时候，如果给缺省参数传递参值 ，使用的是传递的实参值，如果没有传递，使用默认值

def func(a,b,c = 30):
    print ("a = %d" % a )
    print ("b = %d" % b)
    print ("c = %d" % c)

func(10,20)

不定长参数

• 即传递的参数个数不定
• 在形参前边加上一个 *，该形参变为不定长元组形参，可以接收所有的位置实参，类型是元组
• 在形参前边加上两个 `*，该形参变为不定长字典形参，可以接收所有的关键字实参，类型是字典

def func4(*args,**kwargs):
    print(args)
    print (kwargs)

func4(1,2,3,4,5)
func4(a = 1,b = 2,c = 3,d = 4)
func4(1,2,3,a = 4,b = 5,c = 6)

输出结果如下所示：

不定长参数.png

• 注意点：函数定义中的 args 和 kwargs 可以是任意的形参变量，不过习惯使用 args 和 kwargs

函数形参的完整格式

• 完整参数格式是：普通形参 缺省形参 不定长元组形参 不定长字典形参

这种形式相对较好

def func5(a, *args, b = 5):
    print (a)
    print (b)
    print (args)

func5(2,3,4,5,6,b = 4)

拆包

• 组包：将多个数据值，给到一个变量，如：a = 1, 2, 3
• 拆包：将容器的数据分别给到多个变量，需要注意：数据的个数和变量的个数要保持一致，如a = 1, 2, 3 ; b，c，d = a ;
• 注意点：数据的个数需要与变量的个数保持一致
• 拆包的一个重要作用就是交换变量的值

a = 1,2,3;
b,c,d = a;

print (b)
print (d)
print (c)

e,f = [10,20]
print (e)
print (f)

my_dict = {"name":"lin","age":10}
g,h = my_dict

print (g)
print (h)

# 交换数值 
a, b = b, a

引用

• 在Python中，值是靠引用来传递的
• 可以通过 id() 来判断两个变量是否为同一个值的引用，可以将 id() 值理解为内存地址标识
• 赋值运算符可以改变变量的引用
• a = 10，将数据 10 存储到变量a中，本质是将数据10所在内存的引用地址保存到变量 a 中
• b = a，将变量 a 中保存的引用地址给到 b

my_list = [1,2,3]
my_list1 = my_list

print (my_list, id(my_list))
print (my_list1, id(my_list1))

my_list.append(4)
print (my_list, id(my_list))
print (my_list1, id(my_list1))

可以发现当 my_list 变化以后，my_list1 也变化了

引用举例.png

类型的可变与不可变

• 在不改变变量引用的前提下，能否改变变量中引用中的数据
• 如果能改变是可变类型，如果不能改变是不可变类型
• 不可变类型：int、float、bool、str、tuple
• 可变类型：list、dict
• python 中的内存优化，是对于不可变类型进行的

引用做参数

当引用做为函数的参数传递时，当在函数内部修改了参数，则在外部访问时参数也修改了

def func5(a):
    a.append(4)

func5(my_list2)
print (my_list2)

递归函数

如果一个函数在内部不调用其他的函数，而是调用自己本身的话，这个函数就是递归函数，但必须要有退出条件

def getAge(num):
    if (num == 1):
        return 18
    return  getAge(num - 1) + 2

print (getAge(1))
print (getAge(2))
print (getAge(3))
print (getAge(4))

匿名函数

使用 lambda 关键字定义的函数就是匿名函数
格式如下：

lambda 参数列表：表达式

• 匿名函数中不能使用 if 语句、while 循环、for 循环，只能编写单行的表达式
• 匿名函数中不能写 return

主要可以分为以下几种：

1. 无参数无返回值

def  函数名():
       函数代码

lambda:函数代码

2. 无参数有返回值

def  函数名():
       return 1 + 2

lambda: 1 + 2

3. 有参数无返回值

def 函数名(a, b):
      print(a, b)

lambda a, b: print(a, b)

4. 有参数有返回值

def 函数名(a, b):
      return a + b

lambda a, b: a + b

和之前的代码对比如下所示：

# 无参有返回值

def fun2():
    return 1 + 2

f2 = lambda :1 + 2
print (f2())

# 有参无返回值

def func3(name):
    print (name)

f3 = lambda name:print(name)
f3("lin")

# 有参有返回值
def func4 ( *args):
    return args

f4 = lambda *args:args
print (f4(1,2,3,4,5))

匿名函数的应用

下面是用匿名函数代替普通函数的用法

def my_calc(a, b ,func):
    print ("其他的函数代码：")
    num = func (a,b)
    print (num)

def add(a, b):
    return a + b

my_calc(10,20,add)
# 与上面代码的功能相似
my_calc(10,20,lambda a,b: a + b)
my_calc(10,20, lambda a,b: a - b)
my_calc(10,20, lambda a,b: a / b)

列表排序

1. 根据某个 key 值进行排序

mylist = [
    {"name":"d","age":10},
    {"name": "a", "age": 11},
    {"name": "b", "age": 5},
    {"name": "c", "age": 2}]

# x表示列表中的每个数据
mylist.sort(key = lambda x:x["name"])
print mylist

mylist.sort(key = lambda x:x["age"])
print mylist

输出结果如下所示：

列表排序.png

2. 根据多个条件进行排序，排序规则：key = lambda 形参：(排序规则1，排序规则2)

下面是先按照名字排序，再根据年龄排序

mylist.sort(key = lambda x:(x["name"],x["age"]))
print mylist

列表推导式

• 可以快速生成一个列表
• 规则如下：

变量 = [生成数据的规则 for 临时变量 in xx]

• 每循环一次，应付创建一个数组

1. 普通格式

mylist1 = [i for i in range(5)]
print mylist1

2. 加 if 条件

mylist1 = [i for i in range(5) if i % 2 == 0]

高阶函数

把函数作为参数传入，这样的函数被称为高阶函数，高阶函数是函数式编程的体现，函数式编程就是指这种高度抽象的编程范式

def sum_num(a, b, f):
    return  f(a) + f(b)

result = sum_num(10, - 6, abs)
print result

内置高阶函数

map函数

list = [1,2,3,4,5]

def func(x):
    return x ** 2

list2 = map(list,func)
print list2

reduce函数

reduce(func, list)， 其中func必须有两个参数，每次func计算的结果继续和序列的下一个元素做累积计算