Python 学习笔记 Day6

---

函数内存底层分析

众所周知，在Python中，一切都是对象，因此，在我们执行def定义函数之后， 系统就创建了相应的函数对象

#例
def test1():
    print('***')
c=test1()

print(id(test1()))
print(id(c))   #和test1一样

当我们调用变量c的时候，实际上还是调用了test1函数

变量的作用域

变量起作用的范围成为变量的作用域，不同作用域内同名字的变量互不影响
变量主要分两种：全局变量和局部变量

变量	定义	备注
全局变量	在函数和类定义之外声明的变量	1.作用域为定义的模块，即定义位置开始到模块结束 2.全局变量降低了函数的通用性和可读性，所以应该尽量避免全局变量的使用 3.全局变量一般作为常数来使用 4.函数内要改变全局变量的值，需要使用global声明
局部变量	在函数体中声明的变量（包含形式参数）	1.局部变量引用的速度比全局变量快，所以应该优先使用 2.若出现了局部变量和全局变量同名，那么在函数内会隐藏全局变量，然后只使用在函数内的局部变量

a=3               #全局变量
def test1():
    b=4           #局部变量
    print(b*5)

a=3               
def test1():
    b=4         
    global a      
    a=100          #global声明改变全局变量的值
    print(b*5+a)
test1()
print(a)

120
100

a=3               #全局变量
def test1():
    b=4           #局部变量
    global a
    a=100
    print(b*5+a)
    print(locals())   #打印输出的局部变量
    print(globals())  #打印输出的全局变量，返回一个字典
test1()


120
{'b': 4}     #  ← 局部变量
{'__name__': '__main__',   \
'__doc__': None,     \
'__package__': None,    \
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CFA84F1CF8>,     \
'__spec__': None,\
'__annotations__': {},    \
'__builtins__': <module 'builtins' (built-in)>, \
'__file__': 'C:/Users/???/PycharmProjects/untitled5/1.py',     \
'__cached__': None,    \
'a': 100,    \
'test1': <function test1 at 0x000001CFA852D268>} 
# ↑↑↑↑↑↑ 全局变量  ↑↑↑↑↑↑
#翻阅的字典可以看到 'a': 100
#函数也是全局变量   'test1': <function test1 at 0x000001CFA852D268>}

变量的效率测试

局部变量的查询和访问速度比全局变量快，尤其是在循环里，所以在特别需要效率的地方或循环次数很多的时候，我们应该将全局变量转换为局部变量来提高效率

import time
import math
def test01():
    s= time.time()
    for i in range(1000000):
        math.sqrt(30)
    e= time.time()
    print('耗时：{}'.format(e-s))

def test02():
    b=math.sqrt #循环外引用
    s= time.time()
    for i in range(1000000):
        b(30)
    e= time.time()
    print('耗时：{}'.format(e-s))

test01()
test02() 

耗时：0.13364171981811523
耗时：0.09578847885131836  #速度加快了一些

参数的传递

在函数中，参数传递的本质是从实参到形参的赋值操作，所有的赋值操作都是“引用（地址）的赋值”，因此，Python中参数的传递都是引用传递而不是值传递
具体的操作分为2类：
1.对可变对象进行写操作：直接作用于原对象本身
2.对不可变对象进行操作：先产生一个新的对象空间，然后用新的值填充这块空间（起到其他语言值传递的效果）

可变对象	不可变对象
字典、列表、集合、自定义对象等	数字、字符串、元组、布尔值等

浅拷贝和深拷贝

函数	说明
copy()	浅拷贝：不拷贝子对象的内容，只拷贝子对象的引用
deepcopy()	不仅拷贝内容，而且拷贝对象的内存，对子对象的修改不会影响源对象

#浅拷贝
import copy

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)

a: [10, 20, [5, 6]]
b: [10, 20, [5, 6]]
浅拷贝***********
a: [10, 20, [5, 6, 7]]
b: [10, 20, [5, 6, 7], 30]

#深拷贝
import copy

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)

a: [10, 20, [5, 6]]
b: [10, 20, [5, 6]]
深拷贝***********
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6, 7], 30]

传递可变对象

b= [10,20]
print(id(b))
print(b)
print("******************")
def test01(m):
    print(id(m))
    m.append(30)
    print(id(m))
test01(b)        #b的地址没变
print(b)         #可变对象变了，地址没变，说明函数直接作用于原对象本身

2168575844936
[10, 20]
******************
2168575844936
2168575844936
[10, 20, 30]

传递不可变对象

传递不可变对象用的是浅拷贝

a=100
def f1(n):
    print('n:',id(n))
    n=n+200
    print('n:', id(n))
    print(n)
f1(a)
print('a:',id(a))

n: 140711285940352
n: 2127799997072
300
a: 140711285940352

#传递不可变对象，如果拷贝，用的是是浅拷贝
'''
当传递不可变对象的参数时，如果不可变对象里面包含的子对象是可变的
那么当修改了这个子对象中的可变对象后，源对象也会发生变化
'''
import copy

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

def test1(m):
    print('m:',id(m))
    m[2][0]=888
    print(m)
    print('m:',m)
test1(a)
print(a)
print(id(a[2][0])) #地址变了 创建了新对象


140711285937312
a: 2726130146688
m: 2726130146688
(10, 20, [888, 6])
m: (10, 20, [888, 6])
(10, 20, [888, 6])
2726128309680

参数的类型

位置参数

位置参数：按照位置传递的参数

# 函数调用的时候 ，实参默认按照位置顺序传递，其个数要和形参匹配
def f1():
    print(a,b,c)

f1(1,2,3)
f1(1,2)  #个数不匹配，报错

默认值参数

默认值参数：把某些参数设定为默认值，这样该值在传递参数的时候是可以选的参数

def f1(a,b,c=10,d=20): #c默认10 d默认20
    print(a,b,c,d)

f1(1,2,3)
f1(1,2)

1 2 3 20
1 2 10 20

命名参数

命名参数：在传递实参的时候，按照形参的名字传递的参数

def f1(a,b,c=10,d=20):
    print(a,b,c,d)

f1(1,2,3)
f1(1,2,c=100,d=500) #c、d命名参数

可变参数

可变参数：参数数量可以变化的参数

用法	说明
*name	将多个参数放到元组里面
**name	将多个参数放到字典里面

#1个*：元组
def f1(a,b,*c):
    print(a,b,c)

f1(1,2)
f1(1,2,9,6,3,5,4,2,3,661) 

1 2 ()
1 2 (9, 6, 3, 5, 4, 2, 3, 661)

#2个**：字典
def f2(a,b,**c):
    print(a,b,c)

f2(1,2,name='Leo',age=8)

1 2 {'name': 'Leo', 'age': 8}

def f2(a,b,*d,**c): 
    print(a,b,c,d)

f2(1,2,8,9,6,3,100,name='Leo',age=8) #有参数名的对应c,没有的对应d

1 2 {'name': 'Leo', 'age': 8} (8, 9, 6, 3, 100)

强制命名参数

强制命名参数：带参数的可变参数后面增加新的参数必须是强制命名参数

def f2(*d,a,b):
    print(a,b,d)

f2(1,8,9,10,a=1,b=8) #a和b的赋值必须写出来

1 8 (1, 8, 9, 10)

Lambda 表达式

Lambda 表达式是一种只允许包含一个表达式、在同一行定义函数的方法，它不需要为函数取名字就可以使用，Lambda 表达式实际上是生成了一个函数对象
其基本语法如下：

lambda 形参1,形参2,... : <表达式>

f = lambda a,b,c,d:a*b*c*d
#等价于
def f(a,b,c,d):
    return a*b*c*d

print(f(1,2,3,4) )

24

eval()函数

eval()函数经常用来计算Python的表达式，将字符串str当成有效的表达式求值并返回计算结果，其语法如下：

eval(source[,globals[,locals]])

source: 一个Python表达式或函数complie()返回的代码对象
globals：可选，必须是dictionary
locals:可选，任意的映射对象

a=1
b=2
dict1=dict(a=100,b=200)
dict2=dict(c=300,b=400)
e=eval("a+b",dict1)
#eval中提供了globals参数，使用的时候会屏蔽掉外部的a和b
print(e) #输出300

f=eval("a+b+c",dict1,dict2)
print(f) #a取100 b取400 c取300 输出800
#当locals和globals起冲突时，locals是起决定作用的
#所以取locals的b(dict2)

递归函数

递归函数：自己调用自己的函数，在函数体内直接或间接地调用自己，其用法类似与数学归纳法
每个递归函数必须包含两部分：
1.终止条件：表示递归什么时候结束，一般用于返回值，不再调用自己
2.递归步骤：把第n步和n-1步相关联
⭐注：递归函数会创建大量的函数对象，会过量地消耗内存和计算能力，所以要谨慎使用

#错误示范：没有设置终止条件
def test01():
    print('test01')
    test01()
    print('***')
test01()

def test01(n):
    print('test01',n)
    if n==0:       #终止条件
        print("over")
    else:
        test01(n-1)
test01(4)

test01 4
test01 3
test01 2
test01 1
test01 0
over

def test01(n):
    print('test01',n)
    if n==0:
        print("over")
    else:
        test01(n-1)
    print("*********")
test01(4)

test01 4
test01 3
test01 2
test01 1
test01 0
over
*********
*********
*********
*********
*********

#用递归函数算阶乘
def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)
r = factorial(5)
print(r)

120