study-eighth-fun-1

原创于 2020-09-10 12:21:25 发布 · 149 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

本文详细解析了Python函数的定义、参数传递方式、不定长参数及参数解包等核心概念，帮助读者掌握函数的灵活运用。

可变对象

每个对象都保存了三个数据

id(标识)
type(类型)
value(值)
a=[4,5,6]
a[0]=10,#此时a对象还是同一个
a=[1,2,3]#重新赋值，变成了另一个对象

1.函数简介

函数也是一个对象(function)
函数用来保存一些可执行的代码，在有需求的时候对这些代码块多次调用
函数中保存的代码不会立即执行，需要调用函数的时候代码才执行

def 函数名([形参1,形参2,形参3....]):
	代码块

注意：
函数名必须符合标识符的规范(可以包含字⺟、数字、下划线但是不能以数字开头) 。

def fn():
	print('hello world')
fn()#hello world
print(fn)#<function fn at 0x00000210550F2BF8>
print(fn())
#hello world
#None   因为没有return或者return后没有返回值

#fn是函数对象 fn()调用函数

print是函数对象 print()是调⽤函数

2.函数的参数

2.1形参和实参

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

def fn(a,b):

    # a = None
    # b = None
    # print('a =',a)
    # print('b =',b)

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

fn(1,2)
fn(88,666)
#1 + 2 = 3
#88 + 666 = 754

实参可以传递任意类型的对象

def fn(a):

    print('a =',a)


b = 88 
b = [1,2]
b = True
b = 'lihua'
fn(b)
输出：
a=88
a=[1,2]
a=True
a=lihua

在函数中对形参进行赋值，不会影响其他的变量

1.def f(a):
	print('a=',a)
c=10
f(c)
print('c=',c)
输出：a=10,c=10

2.def f(a):
	a=20#相当于默认参数传递
	print('a=',a)
c=10
f(c)
print('c=',c)
输出：a=20,c=10

当我们通过形参去修改对象时(value),会影响到所指向该对象的变量

def f(a):
	a[0]=10
	print('a=',a)
c=[1,2,3]
f(c)
print('c=',c)
输出：a=[10,2,3],c=[10,2,3]#a,c指向同一个对象。

2.2函数的传递方式

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

def fn(a,b,c = 20):

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

fn(1,2,3)#输出：a=1,b=2,c=3.有默认值，传递参数则不生效
fn(1,2)#输出:a=1,b=2,c=20,用户没有传递第三个参数，默认值生效

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

def fn(b = 1,c = 2,a = 20):

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

fn()
输出的是：a=20,b=1,c=2#按照参数名进行传递

默认参数和关键字参数混合使用的时候必须将位置参数写到关键字参数前⾯去
非默认参数不能放在默认参数后面

def fn(a,c=2):
    print('a =', a)
    print('c =', c)

fn(1)#输出:a=1,c=2
fn(1,2)#输出:a=1,c=2
fn(1,3)#输出:a=1,b=3
def fn(c=2,a):
    print('a =', a)
    print('c =', c)

fn(1)#SyntaxError: non-default argument follows default argument(非默认参数不能放在默认参数后面)

3.不定长参数(可变参数)

在定义函数时，可以在形参前⾯加⼀个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到⼀个元组中

def f(*a):#*a接收所有位置的实参，并保存在元组中
	print('a=',a)
f(1,2,3,4)
输出：a=(1,2,3,4)

def s1(*a):

    # 定义一个变量保存结果
    r = 0

    # 遍历元组，将元组当中的数进行相加
    for n in a:

        r += n
    print(r)
#求任意数的和
s1(1,2,3,4,5,6)

带*号的形参只能有⼀个，可以和其他参数配合使⽤

1.def fn1(a,b,*c):

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

fn1(1,2,3,4,5,6)
#输出：
a = 1
b = 2
c = (3, 4, 5, 6)


2.def fn2(a, *b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)


fn2(1, 2, 3, 4, 5, 6)

# TypeError: fn2() missing 1 required keyword-only argument: 'c'，此时找不到传递给c的参数是因为，*a获取了2，3，4，5，6.

fn2(1,2,3,4,5,c=6)#指定一个，但是不能把c=6放到其他位置，因为默认参数(关键字参数)必须放到非默认参数(位置)后面
#输出：
a = 1
b = (2, 3, 4, 5)
c = 6

*形参只能接受位置参数，不能接受关键字参数

def fn3(*a):

    print('a =', a)

fn3(b = 1,d = 2,c = 3)
#输出：TypeError: fn3() got an unexpected keyword argument 'b'

**形参可以接收其他的关键字参数,它会将这些参数统⼀保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值

def fn3(**a):

    print('a =', a)

fn3(b = 1,d = 2,c = 3)
#输出：
a = {'b': 1, 'd': 2, 'c': 3}

**形参只有⼀个，并且必须写在所有参数的后⾯

4.参数的解包

传递实参时，也可以在序列类型的参数前添加*，这样它会⾃动的将序列中元素依次作为参数传递

def f(a,b,c):

    print('a =',a)

    print('b =',b)

    print('c =',c)

 t = (1,2,3)
 f(*t)
 #输出：
 a=1
 b=2
 c=3

def fn1(a,b,c):

    print('a =',a)

    print('b =',b)

    print('c =',c)
d = {'a':1,'b':2,'c':3}

fn1(**d)
#输出：
a=1
b=2
c=3

要求序列中的元素的个数必须和形参的个数⼀致

*args,**kwargs 可变参数