Python基础课--第九节函数

1 函数简介

• 函数也是⼀个对象
• 函数⽤来保存⼀些可执⾏的代码，并且可以在需要时，对这些语句进⾏多次调⽤
• 函数中保存的代码不会立即执行，需要调用函数代码，才会执行
• 注意：函数名必须符合标识符的规范(可以包含字⺟、数字、下划线但是不能以数字开头)
• print是函数对象 print()是调⽤函数

def fn():

    print('这是我的第一个函数')

# 调用函数
fn()

结果
这是我的第一个函数

2 函数的参数

• 在定义函数的时候，可以在函数名后面的括号里面定义数量不等的形参，多个形参用逗号隔开。

2.1 形参和实参

• 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
• 实参(实际参数)指定了形参，那么在调⽤函数时必须传递实参，实参将会赋值给对应的形参，简单来说有⼏个形参就要有⼏个实参

def s(a,b): # 形参

    print('a =',a)
    print('b =',b)
    print(a,'+',b,'=',a+b)

s(1,2) # 实参

结果
a = 1
b = 2
1 + 2 = 3

2.2 函数的传递⽅式

• 定义形参时,可以为形参指定默认值。指定了默认值以后，如果⽤户传递了参数则默认值不会⽣效。如果⽤户没有传递，则默认值就会⽣效

# 定义形参时,可以为形参指定默认值。
def s(a,b,c=10): # 形参

    print('a =',a)
    print('b =',b)
    print('c =',c)
    print(a,'+',b,'+',c,'=',a+b+c)
# 如果⽤户没有传递，则默认值就会⽣效
s(1,2)

结果
a = 1
b = 2
c = 10
1 + 2 + 10 = 13

# 定义形参时,可以为形参指定默认值。如果⽤户没有传递，则默认值就会⽣效
def s(a,b,c=10): # 形参

    print('a =',a)
    print('b =',b)
    print('c =',c)
    print(a,'+',b,'+',c,'=',a+b+c)
# 如果⽤户传递了参数则默认值不会⽣效。
s(1,2,5)

结果
a = 1
b = 2
c = 5
1 + 2 + 5 = 8

• 位置传参：位置传参就是将对应位置的实参传递给对应位置的形参
• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，⽽根据参数名进⾏传递

# 关键字传参,无位置限制
def fn(a=10, b=20, c=30):
    print('a =', a)
    print('b =', b)
    print('c =', c)
fn(b=3,c=2,a=1)
a = 1
b = 3
c = 2

• 注意：位置传参也可以和关键字传参混合使用，混合使用的时候，必须将位置参数写到关键字参数前面

# 关键字传参和位置传参一起来
def fn(a=10, b=20, c=30):
    print('a =', a)
    print('b =', b)
    print('c =', c)
fn(1,b=3)
结果
a = 1
b = 3
c = 30

2.3 实参的类型

• 函数在调用的时候，解释器不会检查实参的类型，实参的类型可以是任意的对象

def fn(a):

    print('a =',a)
b = 123
b = False
b = None
b = 'python'
b = [1, 2, 3]
b = {'a':1,'b':2}

fn(b)

结果
a = 123
a = False
a = None
a = python
a = [1, 2, 3]
a = {'a': 1, 'b': 2}

• 在函数中对形参重新赋值不会影响其他的变量

def fn4(a):
    # 在函数中对形参赋值，不会影响其他的变量
    a = 20
    print('a =',a)

c = 10
fn4(c)

print('c =', c)

结果
a = 20
c = 10

• 形参在执行的时候，我们通过形参去修改对象时会影响到指向该对象的变量

def fn4(a):
    # 在函数中对形参赋值，不会影响其他的变量,形参在执行的时候，当我们通过形参去修改对象时会影响到指向该对象的变量
    # a = 20

    a[0] = 20
    print('a =',a)

# c = 10
c = [1,2,3]
fn4(c)

print('c =', c)

结果
a = [20, 2, 3]
c = [20, 2, 3]

• • 当在传递可变对象时，不希望在函数内部操作而影响到函数外部，这时考虑传递副本

def fn4(a):
    # 在函数中对形参赋值，不会影响其他的变量,形参在执行的时候，当我们通过形参去修改对象时会影响到指向该对象的变量
    # a = 20

    a[0] = 20
    print('a =',a,id(a))

# c = 10
c = [1,2,3]
# fn4(c)
fn4(c.copy())

print('c =',c,id(c))

结果
a = [20, 2, 3] 2566856548936
c = [1, 2, 3] 2566856524296

• 当在传递可变对象时，不希望在函数内部操作而影响到函数外部，这时考虑传递副本

def fn4(a):
    # 在函数中对形参赋值，不会影响其他的变量,形参在执行的时候，当我们通过形参去修改对象时会影响到指向该对象的变量
    # a = 20

    a[0] = 20
    print('a =',a,id(a))

# c = 10
c = [1,2,3]
# fn4(c)
# fn4(c.copy())
fn4(c[:])

print('c =',c,id(c))

结果
a = [20, 2, 3] 1824585720456
c = [1, 2, 3] 1824585695816

2.4 不定长参数

• 在定义函数的时候，可以在形参的前面加上一个*，这样这个形参将会获取到所有的形参，它会将所有的实参保存到一个元祖中。

# 定义一个函数，来求任意个数的和，如求20,560,1的和
# 在定义函数的时候，可以在形参的前面加上一个*，这样这个形参将会获取到所有的形参，它会将所有的实参保存到一个元祖中。
def s(*a): # 形参
    # 定义一个变量来保存结果
    result = 0
    # 遍历元祖，将元组中的元素进行累加
    for r in a:

        result += r
    print(result)

s(20,560,1) # 实参
结果
581

def fn2(a,b,*c): # 形参

    print('a =', a)
    print('b =', b)
    print('c =', c)

fn2(1,2,3,4,5)
结果
a = 1
b = 2
c = (3, 4, 5)

• 带星号的参数只能有一个
• 可变长参数不一定都要写到最后的，但是注意带星号的参数后面的参数，必须以关键字的形式传参，如果在形参的开头直接写一个星号，则要求我们余下的所有的参数要以关键字的形式来传递

def fn2(a,*b,c): # 形参

    print('a =', a)
    print('b =', b)
    print('c =', c)

fn2(1,2,3,4,c = 5)
结果
a = 1
b = (2, 3, 4)
c = 5

• 两个星号形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典当中，字典当中的key是参数的名字，字典当中的value是参数的值，两个星号形参只能有一个，并且必须写在最后面。*a处理的是位置参数，**a 处理的是关键字参数。

def fn3(**a): # 形参

    print('a =', a)

fn3(b = 2,c = 5,d = 1)
结果
a = {'b': 2, 'c': 5, 'd': 1}

2.5 参数解包

• 传递实参时，也可以在序列类型的参数前面添加*号，这样他会自动的将序列三种的元素依次作为参数传递
• 这里面要求序列中的元素的个数必须和形参的个数一致

def fn(a,b,c):

    print('a =', a)
    print('b =', b)
    print('c =', c)

# 创建一个元组
t = (20,30,40)
# 传递实参时，也可以在序列类型的参数前面添加*号，这样他会自动的将序列三种的元素依次作为参数传递
# 要求是序列中的元素的个数必须和形参的个数一致
fn(*t)
结果
a = 20
b = 30
c = 40

• 可以通过星星对字典解包

def fn(a,b,c):

    print('a =', a)
    print('b =', b)
    print('c =', c)

# 创建一个字典
d = {'a':1,'b':2,'c':3}

fn(**d)
结果
a = 1
b = 2
c = 3