day13:python学习笔记05（函数）

函数是可重用的程序代码块。函数的作用，不仅可以实现代码的复用，更能实现代码的一致性。

函数简介

函数的基本概念：

1. 一个程序由一个个任务组成；函数就是代表一个任务或者一个功能。
2. 函数是代码复用的通用机制。

python函数分类：

1. 内置函数，str()、list()、len()
2. 标准库函数，通过import语句导入库，然后使用其中定义的函数
3. 第三方库函数， Python社区也提供了很多高质量的库，下载安装这些库后，也是通过import语句导入，然后可以使用这些第三方库的函数
4. 用户自定义函数

函数的定义和调用

函数的语法：

1. 我们使用def来定义函数，然后就是一个空格和函数名称，python执行def时，会创建一个函数对象，并绑定到函数名变量上
2. 参数列表：
   (1) 圆括号内是形式参数列表，有多个参数则使用逗号隔开
   (2) 形式参数不需要声明类型，也不需要指定函数返回值类型
   (3) 无参数，也必须保留空的圆括号
   (4) 实参列表必须与形参列表一一对应
3. return返回值：
   (1) 如果函数体中包含return语句，则结束函数执行并返回值
   (2) 如果函数体中不包含return语句，则返回None值
4. 调用函数之前，必须要先定义函数，即先调用def创建函数对象
   (1) 内置函数对象会自动创建
   (2) 标准库和第三方库函数，通过import导入模块时，会执行模块中的def语句

def  函数名 ([参数列表]) :
    '''文档字符串'''
    函数体/若干语句

形参和实参

#形参和实参
def max(a,b):
    '''测试两个数最大值'''
    if a>b:
        print("最大值{0}".format(a))
    else:
        print("最大值{0}".format(b))
max(1,2)

文档字符串（函数的注释）

三个单引号或者三个双引号，help(函数名.doc)可以打印输出函数的文档字符串

返回值

1. 如果函数体中包含return语句，则结束函数执行并返回值
2. 如果函数体中不包含return语句，则返回None值
3. 要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可

#打印n个*，无返回值
def print_star(n):
    print("*"*n)
print_star(5)
#返回两个数平均值的函数
def avg_num(a,b): 
    return (a+b)/2
c = avg_num(1,2)
print(c)

函数也是对象，内存底层分析

执行def定义函数后，系统就创建了相应的函数对象

def print_star(n):
    print("*"*n)
print(print_star)
print(id(print_star))
c = print_star
c(3)

变量c和print_star都是指向了同一个函数对象，执行c(3)和执行print_star(3)的效果是完全一致的，圆括号意味着调用函数。在没有圆括号的情况下，Python会把函数当做普通对象。

变量的作用域

全局变量：

1. 在函数和类定义之外声明的变量。作用域为定义的模块，从定义位置开始直到模块结束。
2. 全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。
3. 全局变量一般做常量使用。
4. 函数内要改变全局变量的值，使用global声明一下

局部变量：

1. 在函数体中（包含形式参数）声明的变量。
2. 局部变量的引用比全局变量快，优先考虑使用。
3. 如果局部变量和全局变量同名，则在函数内隐藏全局变量，只使用同名的局部变量

#案例1：
a = 100
def f1():
    global a   #如果要在函数内改变全局变量的值，增加global关键字
    print(a)   #打印全局变量a的值
    a = 300
f1()
print(a)
#案例2：
a = 100
def f1():
    a = 3   #同名的局部变量
    print(a)
f1()
print(a)
#案例3：
a = 100
def f1(a,b,c):
    print(a,b,c)
    print(locals())   #打印输出的局部变量
    print("+++++++")
    print(globals())   #打印输出的全局变量
f1(2,3,4)
#案例4：测试全局变量和局部变量效率    
import math
import time
 #在特别强调效率的地方或者循环次数较多的地方，可以通过将全局变量转为局部变量提高运行速度。
def test01():
    start01 = time.time()
    for i in range(10000):
        math.sqrt(30)
    end01 = time.time()
    print("耗时{0}".format(end01-start01))
def test02():
    a = math.sqrt
    start02 = time.time()
    for i in range(10000):
        a(30)
    end02 = time.time()
    print("耗时{0}".format(end02-start02))
test01()
test02()

参数的传递

实质上从实参到形参的赋值操作，Python中参数的传递都是“引用传递”，不是“值传递”。

1. 对“可变对象”进行“写操作”，直接作用于原对象本身。
2. 对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间。

#传递可变对象
b = [10,20]
def f2(m):
    print("m",id(m))   #b和m是一个对象
    m.append(30)       #由于m是可变对象，不创建对象拷贝直接修改这个对象
f2(b)
print("b",id(b))
print(b)
#传递不可变对象
a = 100
def f1(n):
    print("n",id(n))
    n = n+200
    print("n:",id(n))
    print(n)
f1(a)
print("a:",id(a))

深拷贝和浅拷贝

copy(浅拷贝)：不拷贝子对象的内容，只拷贝子对象的引用

deepcopy(深拷贝)：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象

#测试浅拷贝和深拷贝
import copy

def testCpoy():
    a= [10,20,[5,6]]
    b = copy.copy(a)

    print("a",a)
    print("b",b)
    b.append(30)
    b[2].append(7)
    print("浅拷贝……")
    print("a",a)
    print("b",b)
def testDeepCopy():
    a = [10,20,[5,6]]
    b = copy.deepcopy(a)

    print("a",a)
    print("b",b)
    b.append(30)
    b[2].append(7)
    print("深拷贝……")
    print("a",a)
    print("b",b)
testCpoy()
testDeepCopy()

传递不可变对象包含的子对象是可变的情况

不可变对象里面包含的子对象是可变的，则方法内修改了这个可变对象，源对象也发生了变化

a = (10,20,[5,6])
print("a:",id(a))

def test01(m):
    print("m",id(m))
    m[2][0] = 888
    print(m)
    print("m:",id(m))
test01(a)
print(a)

参数的几种类型

位置参数：函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。不匹配报错。

def f(a,b,c):
    print(a,b,c)
f(2,3,4)
f(2)

默认值参数：我们可以为某些参数设置默认值，这样这些参数在传递时就是可选的。默认值参数必须位于普通位置参数的后面

def f(a,b,c=10,d=20):
    print(a,b,c,d)
f(1,2)
f(1,2,3,4)

命名参数：按照形参的名称传递参数

def f(a,b,c):
    print(a,b,c)
f(c=1,a=4,b=5)

可变参数：可变数量的参数。1. *param（一个星号），将多个参数收集到一个“元组”对象中。2、**param（两个星号），将多个参数收集到一个“字典”对象中。

def f(a,b,*c):
    print(a,b,c)
f(1,2,3,4,5)

def f1(a,b,**c):
    print(a,b,c)
f1(8,9,name='zmx',age=18)

强制命名参数：在带星号的“可变参数”后面增加新的参数，必须在调用的时候“强制命名参数”。

def f(*a,b,c):
    print(a,b,c)
# f(2,3,4)   会报错，由于a是可变参数，将2,3,4全部收集。造成b和c没有赋值。
f(2,b=3,c=4)

lambda表达式和匿名函数：lambda表达式可以用来声明匿名函数。lambda函数实际生成了一个函数对象。lambda arg1,arg2,arg3… : <表达式>

f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))

g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))

eval()函数：将字符串str当成有效的表达式来求值并返回计算结果，eval(source[, globals[, locals]]) -> value，字符串中含有删除文件的语句慎用

s = "print('abcd')"
eval(s)

a = 10
b = 20
c = eval("a+b")
print(c)

dict1 = dict(a=100,b=300)
d=eval("a+b",dict1)
print(d)

递归函数：自己调用自己的函数，在函数体内部直接或间接的自己调用自己。必须包含：1、终止条件，表示递归什么时候结束 2、递归步骤，把第n步的值和第n-1步相关联；递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时，谨慎使用。

def f(n):
    if n==1:
        return n;
    else:
        return n*f(n-1);
for i in range(1,6):
    print(i,"!=",f(i))

嵌套函数（内部函数）：在函数内部定义的函数

一般在什么情况下使用嵌套函数？

1. 封装 - 数据隐藏 外部无法访问“嵌套函数”。
2. 贯彻 DRY(Don’t Repeat Yourself) 原则 嵌套函数，可以让我们在函数内部避免重复代码。
3. 闭包

def f1():
    print("f1 running")

    def f2():#f2()就是定义在f1函数内部的函数。f2()的定义和调用都在f1()函数内部。
        print("f2 running")
    f2()
f1()
#中文名和英文名（嵌套函数避免代码重复）
def printName(isChinese,name,familyName):
    def inner_print(a,b):
        print("{0}{1}".format(a,b))
    if isChinese:
        inner_print(familyName,name)
    else:
        inner_print(name,familyName)
printName(True,"mengxi","zhu")

nonlocal关键字

nonlocal用来声明外层的局部变量，global用来声明全局变量

a=100
def outer():
    b=10
    def inner():
        nonlocal b   #声明外部函数的局部变量
        print("inner b:",b)
        b=20

        global a   #声明全局变量
        a=1000
    inner()
    print("outer b",b)
outer()
print("inner a",a)

LEGB原则

Local–>Enclosed–>Global–>Built in

Local     指的就是函数或者类的方法内部
Enclosed  指的是嵌套函数（一个函数包裹另一个函数，闭包）
Global    指的是模块中的全局变量
Built in   指的是Python为自己保留的特殊名称。