python入门第六节（变量、参数的传递、浅拷贝和深拷贝、参数的类型、lambda表达式、eval（）函数、递归函数）

变量
参数的传递
浅拷贝和深拷贝
参数的类型
lambda表达式
eval()函数
递归函数

变量

全局变量

局部变量

#测试全局变量、局部变量
a=3  #全局变量

def test01():
    b=4  #局部变量
    print(b*10)
    a=300
    print(a)  #打印局部变量下的a

test01()
print(a)  #打印全局变量下的a


#结果
40
300
3

#测试全局变量、局部变量
a=3  #全局变量

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

test01()
print(a)  #打印全局变量下的a

#结果
40
300

#测试全局变量、局部变量的效率

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()

#结果
耗时1.1194298267364502
耗时0.8801467418670654

参数的传递

#测试参数的传递
#传递可变对象

a=[10,20]
print(id(a))
print(a)
print("*********************")

def test01(m):
   print(id(m))
   print(m)
   m.append(300)
   print(id(m))
   print(m)


test01(a)

#结果
1602837827912
[10, 20]
*********************
1602837827912
[10, 20]
1602837827912
[10, 20, 300]

#测试参数的传递
#传递不可变对象

a=100
print(id(a))
print(a)
print("*********************")

def test01(m):
   print("m:",id(m))   #传递进来的是a对象的地址
   print(m)
   m=m+200             #由于a是不可变对象，因此创建新的对象m
   print("m:",id(m))   #m已经变成了一个新的对象
   print(m)


test01(a)
print("a:",id(a))

#结果

1626896544
100
*********************
m: 1626896544
100
m: 2202538847984
300
a: 1626896544

浅拷贝和深拷贝

#测试浅拷贝、深拷贝

import copy
def testCopy():
    '''测试浅拷贝'''
    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)

testCopy()
testDeepCopy()

#结果
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6]]
浅拷贝....
a: [10, 20, [5, 6, 7]]
b: [10, 20, [5, 6, 7], 30]
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6]]
深拷贝....
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6, 7], 30]

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

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)

#结果
a: 2126467278312
m: 2126467278312
(10, 20, [888, 6])
m: 2126467278312
(10, 20, [888, 6])

参数的类型

位置参数

默认值参数

命名参数

#测试参数的类型：位置参数、默认值参数、命名参数

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

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

test02(2,3)
test02(12,5,6)

#结果
10-20-30-40
40-30-10-20
2-3-10-15
12-5-6-15

可变参数

强制命名参数

#测试参数的类型：可变参数、强制命名参数
def f1(a,b,*c):
    print(a,b,c)

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

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

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

f1(8,9,15,20)
f2(8,9,name='li',age=18)
f3(8,9,20,15,name='li',age=18)
f4(2,b=4,c=5)

#结果
8 9 (15, 20)
8 9 {'name': 'li', 'age': 18}
8 9 (20, 15) {'name': 'li', 'age': 18}
(2,) 4 5

lambda表达式

#测试lambda表达式、匿名函数

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

#结果
6
12 24

eval()函数

#测试eval()函数
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)

#结果
abcde
30
300

递归函数

#测试递归函数的基本原理

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

test01(4)

#结果
test01: 4
test01: 3
test01: 2
test01: 1
test01: 0
over
test01*** 0
test01*** 1
test01*** 2
test01*** 3
test01*** 4

#使用递归函数计算阶乘

def factorial(n):

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


result=factorial(5)
print(result)

#结果
120