python夯实基础日记-函数详解

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

Python中，“一切都是对象”。实际上，执行def定义函数后，系统就创建了相应的函数对象。我，执行如下程序，然后进行解释：

def print_star(n):
    print('*'*n)

print(print_star)
print((id(print_star)))
c=print_star
c(3)

执行结果：

<function print_star at 0x0000000001CE2EA0>
30289568
***

上面代码执行de时，系统中会创建函数对象，并通过 print star这个变量进行引用

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

变量起作用的范围称为变量的怍用域，不同作用城内同名变量之间互不影晌，变量分为：全局变量、局部变量。

全局变量：

1.在的数和定义之外声明的变量。作用域为定义的模块，从定义位置开始直到横块

2.全局变量降低了函数的通用性和可读性。尽量免全局变量的使用

3.全局量一般做常量使用。

4.函数内要改变全局变量的值，使global声明一下

局部变量：

1.在函数体中（包含形式数参数）声明的量

2.局部变量的引用比全局变量快，优先考虑使用

3.如果局变量和全局变量同名，则在函数内隐藏全局变量，只使用同可名的局部变量

a = 3  # 全局变量


def test01():
    b = 4  # 局部变量
    print(b * 10)
    global a #如果要在函数内改变全局变量的值，需要增加global关键字声明
    a=300 #局部变量的a
    print(a)


test01()
test01()
# print(b)会报错，因为b是局部变量
print(a)

输出局部变量和全局变量

a = 3  # 全局变量

def test01():
    b = 4  # 局部变量
    print(b * 10)
    global a #如果要在函数内改变全局变量的值，需要增加global关键字声明
    a=300 #局部变量的a

    print(locals())  #打印输出局部变量
    print(globals())  #打印输出全局变量


test01()
test01()
# print(b)会报错，因为b是局部变量
print(a)

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

局部变量的查询和访问速度比全局变量快，优先考虑使用，尤其是在循环的时候。
在特别强调效率的地方或者循环次欠数较多的地方冋以甬过将全局变量转为局部变量提高运行速度

#测试局部变量，全局变量的效率
import math
import time
def test01():
    start =time.time()
    for i in range(10000000):
        math.sqrt(30)
    end = time.time()
    print('耗时{0}'.format(end-start))

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

test01()
test02()

78、参数的传递_传递可变对象_内存分析

函数的参数传递本质上就是：从实参到形参的赋值操作。 Python中“一切皆对象”，所有的赋值操作都是“引用的赋值”。所以，Python中参数的传递都是“引用传递”，不是“值传递”，具体操作时分为两类

1.对“可变对象”进行“写操作”，直接作用于原对象本身。

2.对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间。（起到他语言的“值传递”效果，但不是“值传递”）

可变对象有：

字典、列表、集合、自定义的对象等

不可变对象有：

数字、字符串、元组、 function等

传递可变对象的引用

传递参数是可变对象（例如：列表、字典、自定义的其他可变对象等），实际传递的还是对象的引用。在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象。

#传递可变对象的引用
b=[10,20]
def f2(m):
    print('m',id(m))   #b和m是同一个对象
    m.append(30)   #由于m是可变对象，不创建对象拷贝，直接修改这个对象
    
f2(b)
print(('b:',id(b)))
print(b)

79、传递不可变对象的引用

传递参数是不可变对象（例：int、foat、字符串、元组布尔值），实际传递的还是对象的引用。在”赋值操作”时，由于不可变对象无法修改，系统会新创建一个对象

#传递不可变对象的引用
a=100
def f1(n):
    print('n:',id(n))#传递进来的是a对象的地址
    n+=200#由于a是不可变对象，因此创建新的对象n
    print('n:',id(n))#n已经变成了新的对象
    print(n)
f1(a)
print('a',id(a))

80、浅拷贝和深拷贝_内存分析

为了更深入的了解参数传递的底层原理，我们需要讲解一下“浅拷贝和深拷贝，我们可以使用内置函数：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]
'''

81、参数的传递_不可变对象含可变子对象_内存分析

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

例1：

#传递不可变对象时，如果发生拷贝，是浅拷贝

a=10
print('a:',id(a))

def test01(m):
    print('m:',id(m))#浅拷贝
    m=20#赋值一个新对象
    print(m)
    print('m:',id(m))

test01(a)

例2：

#传递不可变对象时，若不可变对象里面包含的子对象是可变的，则方法内修改了这个可变队形，源对象也发生了变化

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

def test01(m):
    print('m:',id(m))#传入不可变对象是浅拷贝
    #m[0]=20 这样会报错,因为元组不可变
    m[2][0]=888
    print(m)
    print('m:',id(m))

test01(a)
print(a)
'''
a: 39370544
m: 39370544
(10, 20, [888, 6])
m: 39370544
(10, 20, [888, 6])
'''

82、参数的类型_位置参数_默认值参数_命名参数

位置参数

函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。按位置传递的参数，称为：“位置参数”

def f1(a,b,c):
    print(a,b,c)

f1(2,3,4)
f1(2,3)#报错，位置参数不匹配 TypeError: f1() missing 1 required positional argument: 'c'

默认值参数

我们可以为某些参数设置默认值，这样这些参数在传递时就是可选的。称为“默认值参数”。默认值参数放到位置数后面。

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

f1(2,3)
f1(2,3,4)
'''
2 3 10 20
2 3 4 20
'''

命名参数

我们也可以按照形参的名称传递参数，称为“命名参数”，也称“关键字参数”

def f1(a,b,c):
    print(a,b,c)

f1(2,3,4)
f1(c=10,b=15,a=1)
'''
2 3 4
1 15 10
'''

83、可变参数_强制命名参数

可变参数

可变参数指的是“可变数量的参数”。分两种情况：

1.* param（一个星号），将多个参数收集到一个“元组”对象中

2. **param（两个星号），将多个参数收集到一个“字典”对象中

def f1(a,b,*c):
    print(a,b,c)

f1(8,9,19,20)

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

f2(8,9,name='gaoqi',age=18)

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

f3(8,9,30,31,name='gaoqi',age=18)
'''
8 9 (19, 20)
8 9 {'name': 'gaoqi', 'age': 18}
8 9 (30, 31) {'name': 'gaoqi', 'age': 18}
'''

强制命名参数

在带星号的“可变参数”后面增加新的参数，必须是“强制命名参数”

def f1(*a,b,c):
    print(a,b,c)

#f1(2,3,4)会报错，由于a是可变参数，将2，3，4全部收集。\
# TypeError: f1() missing 2 required keyword-only arguments: 'b' and 'c'
f1(2,b=3,c=4)

'''
(2,) 3 4
'''

84、lambda表达式和匿名函数

lambda表达式可以用来声明匿名函数。 lambda函数是一种简单的、在同一行中定义函数的方法， lambda函数实际生了一个函数对象。

lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。

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))
'''
<function <lambda> at 0x00000000003F2EA0>
9
12 21 32
'''

85、eval()函数

功能：将字符串str当成有效的表达式来求值并返回算结果。
语法：eval(source,globals[,locals])-> value

参数

source：一个Python表达式或函数compile()返回的代码对象

globals：可选，必须是dictionary

locals：可选。任意映射对象

#测试eval()函数
s="print('abcde')"
eval(s)

a,b=10,20
c=eval('a+b')
print(c)

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

'''
abcde
30
300
'''

86、递归函数

递归函数指的是：自己调用自己的函数，在函数体内部直接或间接的自己调用自己。递归类似于大家中学数学学习过的“数学归纳法去”。每个递归函数必须包含两个部分：

1.终止条件
表示递归什么时候结束。一般用于返回值，不再调用自己。
2.递归步骤
把第n步的值和第n-1步相关联

递归函数由于会创建大量的函数对象、过量的耗内存和运能力。在处理大量数时，谨慎使用。

#测试递归函数的基本原理 先进后出，后进先出
def test01(n):
    print('test01：',n)
    if n==0:
        print('over')
    else:
        test01(n-1)
    test02()#每层递归结束的时候，都打印一次，从最后一次开始打印

def test02():
    print("test02")

test01(4)
'''
test01： 4
test01： 3
test01： 2
test01： 1
test01： 0
over
test02
test02
test02
test02
test02
'''

87、用递归实现阶乘计算

def factorial(n):
    if n ==1:
        return 1
    else:
        return factorial(n-1)*n
     
n=5
a=factorial(n)
print('{}的阶乘为{}'.format(n,a))
'''
5的阶乘为120
'''

递归实现斐波那契数列

def fibs(n):
    if n == 1 or n==2 :
        return 1
    else:
        return fibs(n-1)+fibs(n-2)
n=6
a=fibs(n)
print('斐波那契数列第{}项的值为{}'.format(n,a))
'''
斐波那契数列第6项的值为8
'''