Day6.

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

def g_test01():
    print(2)


g_test01()
c = g_test01
c()

变量的作用域（全局变量和局部变量）

全局变量：在函数和类定义之外声明的变量，作用域为定义的模块，从定义位置开始直到模块结束

a = 3  # 全局变量


def Global_test():
    b = 4  # 局部变量
    global a  # 如果要在函数中改变全局变量的值使用global
    a = 300
    print(locals())  # 打印局部变量
    print(globals())  # 打印全局变量（字典）


Global_test()

局部变量和全局变量效率测试

局部变量的查询和访问速度比全局变量快，优先考虑使用，尤其在循环的时候

在特别强调效率的地方或者循环次数较多的地方，可以将全局变量转变为局部变量提高运行速度

import math
import time


def g_test01():
    start = time.time()
    for i in range(1000000):
        math.sqrt(30)
    end = time.time()
    print('耗时{0}'.format(end - start))


def g_test02():
    b = math.sqrt
    start = time.time()
    for j in range(1000000):
        b(30)
    end = time.time()
    print('耗时{0}'.format(end - start))


g_test01()
g_test02()

参数的传递：函数的参数传递本质上是从实参到形参的赋值参数

python中一切皆对象，所有的赋值操作都是引用的赋值，参数的传递都是引用传递，不是值传递

可变对象：字典列表，集合，自定义对象等

传递可变对象

a = [10, 20]


def g_test01(m):
    print(id(m))
    m.append(30)
    print(id(m))


g_test01(a)

不可变对象：数字，字符串，元组，function等

a = 100


def G_test(n):
    print('n', id(n))
    n = n + 100
    print('n', id(n))


G_test(a)

浅拷贝和深拷贝

内置函数：copy（浅拷贝）deepcopy（深拷贝） 

浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用，修改涉及到子对象，子对象一起修改

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

# 浅拷贝
a = [10, 20, [5, 6]]
b = copy.copy(a)
print(a)
print(b)

b.append(30)
b[2].append(7)  # 对子对象内容的修改影响源对象
print(a)
print(b)

# 深拷贝
a = [10, 20, [5, 6]]
b = copy.deepcopy(a)

b.append(30)
b[2].append(7)  # 对子对象内容修改不影响源对象
print(a)
print(b)

参数传递不可变对象含可变对象

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


def G_test(m):
    print('m:', id(m))
    m[2][0] = 888
    print(m)
    print(m, id(m))


G_test(a)

参数的几种类型

位置参数：需要个数和形参匹配，按位置传递参数

默认值参数：我们可以将某些参数设置默认值，这样这些参数在传递时就是可选的，成为‘默认值参数’，默认值参数必须在其他参数后面

命名参数：通过形参名称来匹配

def f1(a, b, c, d):
    print('{0}-{1}-{2}-{3}'.format(a, b, c, d))


f1(10, 20, 30, 40)  # 位置参数，个数不匹配报错
f1(d=15, b=100, a=10, c=11)  # 命名参数，通过形参名称来匹配


def f2(a, b, c=10, d=15):  # 默认参数必须位于其他参数后面
    print('{0}-{1}-{2}-{3}'.format(a, b, c, d))


f2(1, 3, 4)

可变参数

1.一个星号，将多个参数收集到一个元组对象中

2.两个星号，将多个参数收集到一个字典对象中

星号后添加参数必须定义命名参数

def f1(a, b, *c):  # 元组
    print('{0}-{1}-{2}'.format(a, b, c))


f1(1, 2, 3, 4, 5)


def f2(a, b, *d, **c):  # 元组必须在字典之前
    print('{0}-{1}-{2}-{3}'.format(a, b, d, c))


f2(1, 2, name='zf', age=18)


def f3(*a, b, c): #可变参数后面增加新参数必须定义为命名参数
    print('{0}-{1}-{2}'.format(a, b, c))


f3(1, 2, b=3, c=4)

lambda表达式和匿名函数

f = lambda a, b, c, d: a * b * c * d
print(f(1, 2, 3, 4))

f1 = [lambda a: a * 2, lambda b: b * 3]
print(f1[0](2), f1[1](3))

eval函数

将字符串str当成有效表达式来求值并返回计算结果

语法eval（source，globals，locals）

source：一个python表达式或者函数

globals：可选必须是字典dict

locals：任意映射对象

eval('print("hello")')
a = 10
b = 20
print(eval('a+b'))

dict1 = dict(a=100, b=200)
d = eval('a+b', dict1)
print(d)

递归函数

def g_test01(n):
    print('g_test01:', n)
    if n == 0:
        print('over')
    else:
        g_test01(n - 1)

    print('g_test01****', n)


g_test01(4)