python-day6

函数

基本概念

1. 一个程序由一个个任务组成；函数就是代表一个任务或者一个功能。
2. 函数是代码复用的通用机制。

Python 函数的分类

1. 内置函数
   我们前面使用的 str()、list()、len()等这些都是内置函数，我们可以拿来直接使用。
2. 标准库函数
   我们可以通过 import 语句导入库，然后使用其中定义的函数
3. 第三方库函数
   Python 社区也提供了很多高质量的库。下载安装这些库后，也是通过 import 语句导
   入，然后可以使用这些第三方库的函数
4. 用户自定义函数
   用户自己定义的函数，显然也是开发中适应用户自身需求定义的函数。今天我们学习的
   就是如何自定义函数。

形参和实参

def printMax(a,b): '''实现两个数的比较，并返回较大的值''' if a>b:
print(a,'较大值')
else:
print(b,'较大值')
printMax(10,20)
printMax(30,5)

上面的 printMax 函数中，在定义时写的 printMax(a,b)。a 和 b 称为“形式参数”，
简称“形参”。也就是说，形式参数是在定义函数时使用的。 形式参数的命名只要符合“标
识符”命名规则即可。
在调用函数时，传递的参数称为“实际参数”，简称“实参”。上面代码中，
printMax(10,20)，10 和 20 就是实际参数。

浅拷贝和深拷贝

浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用。
深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象

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()
print("*************")
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: 41611632
m: 41611632
(10, 20, [888, 6])
m: 41611632
(10, 20, [888, 6])

参数的几种类型

位置参数

def f1(a,b,c):
print(a,b,c)
f1(2,3,4)
f1(2,3) #报错，位置参数不匹配

执行结果：
2 3 4
Traceback (most recent call last):
File “E:\PythonExec\if_test01.py”, line 5, in
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(8,9)
f1(8,9,19)
f1(8,9,19,29)

执行结果：
8 9 10 20
8 9 19 20
8 9 19 29

命名参数

def f1(a,b,c):
print(a,b,c)
f1(8,9,19) #位置参数
f1(c=10,a=20,b=30) #命名参数

执行结果：
8 9 19
20 30 10

可变参数

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

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,20,30,name='gaoqi',age=18)

执行结果：
8 9 (19, 20)
8 9 {‘name’: ‘gaoqi’, ‘age’: 18}
8 9 (20, 30) {‘name’: ‘gaoqi’, ‘age’: 18}

强制命名参数

def f1(*a,b,c):
print(a,b,c)
#f1(2,3,4) #会报错。由于 a 是可变参数，将 2,3,4 全部收集。造成 b 和 c 没有赋值。
f1(2,b=3,c=4)

执行结果：
(2,) 3 4

lambda 表达式和匿名函数

lambda 表达式可以用来声明匿名函数。lambda 函数是一种简单的、在同一行中定义函数
的方法。lambda 函数实际生成了一个函数对象。
lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数
的返回值。
ambda 表达式的基本语法如下：
lambda arg1,arg2,arg3… : <表达式>
arg1/arg2/arg3 为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果。

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 at 0x0000000002BB8620>
9
12 21 32

eval()函数

功能：将字符串 str 当成有效的表达式来求值并返回计算结果。
语法： eval(source[, globals[, locals]]) -> value
参数：
source：一个 Python 表达式或函数 compile()返回的代码对象
globals：可选。必须是 dictionary
locals：可选。任意映射对象

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

递归函数

使用递归函数计算阶乘(factorial)

def factorial(n):
if n==1:return 1
return n*factorial(n-1)
for i in range(1,6):
print(i,'!=',factorial(i))