浅拷贝和深拷贝

**浅拷贝：**不拷贝子对象的内容，只是拷贝子对象的引用。相当于拷贝一个个体

# 测试浅拷贝，深拷贝
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

内存图

**深拷贝：**会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象。相当于拷贝一个家庭。

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)

1
2
3
4
5
6
7
8
9
10
11
12
13

内存图：
传递不可变对象是浅拷贝

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)
1
2
3
4
5
6
7
8
9
10
11

参数的几种类型

位置参数

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

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

f1(2,3,4)
f1(2,3)     #报错，位置参数不匹配
1
2
3
4
5

默认值参数

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

def f1(a,b,c=10,d=20):   #默认值参数必须位于普通位置参数后面
    print(a,b,c,d)

f1(8,9)
f1(8,9,19)
f1(8,9,19,29)
1
2
3
4
5
6

命名参数

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

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

f1(8,9,19)          #位置参数
f1(c=10,a=20,b=30)  #命名参数
1
2
3
4
5

可变参数

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

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='ssl',age=10)


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

f3(8,9,20,30,name='ssl',age=28)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

强制命名参数

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

lambda表达式和匿名函数

lambda表达式可以用来声明匿名函数。lambda函数是一种简单的、在同一行中定义函数的方法。lambda函数实际生成了一个函数对象。
lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。

lambda表达式的基本语法如下：

lambda  arg1,arg2,arg3...  :  <表达式>
arg1/arg2/arg3为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果。
1
2

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](10))# 有点像调用数组
1
2
3
4
5
6

eval()函数

功能：将字符串str当成有效的表达式来求值并返回计算结果。
语法：

eval(source[, globals[, locals]]) -> value
1

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

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

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

dict1 = dict(a=100,b=200)

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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

递归函数

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

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

def test01(n):
    print("test01",n)
    if n==-1:
        print("over")
    else :
        test01(n-1)
test01(4)
1
2
3
4
5
6
7

def factorial(n):
    if n==1:return 1
    return n*factorial(n-1)

for i in range(1,6):
    print(i,'!=',factorial(i))
1
2
3
4
5
6

嵌套函数(内部函数)

嵌套函数：
在函数内部定义的函数！

def  outer():
    print('outer running...')

    def inner():
        print('inner running...')

    inner()

outer()
1
2
3
4
5
6
7
8
9

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

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

nonlocal关键字

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

a =100

def outer():
    b=10

    def inner():
        nonlocal b
        print("inner:",b)
        b=20

        global a
        a=1000
    inner()
    print("outer b:",b)
    print("outer a:",a)
outer()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

LEGB规则

Python在查找“名称”时，是按照LEGB规则查找的：
Local–>Enclosed–>Global–>Built in

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

str ="global"

def outer():
    # str="outer"
    def inner():
        # str="inner"
        print(str)

    inner()

outer()
1
2
3
4
5
6
7
8
9
10
11

依次将几个str注释掉，观察控制台打印的内容