python学习笔记（五）---函数

最新推荐文章于 2023-03-28 16:23:48 发布

零度可乐不长胖

最新推荐文章于 2023-03-28 16:23:48 发布

阅读量471

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/cristiadol/article/details/103095140

版权

python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

函数的定义

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
求绝对值的my_abs函数：

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
也可以有多个返回值：


def Caul(x,y):
	return x+y,x-y

>>> x,y=Caul(3,2)
>>> x
5
>>> y
1
>>>

其实python返回的并不是多个值，而是返回了一个tuple（Python的函数返回多值其实就是返回一个tuple）：

>>> r=Caul(2,3)
>>> r
(5, -1)

定义

在Python交互环境中定义函数时，Python会出现…的提示（一定要注意函数和 if、else 语句的冒号和
缩进！）：

>>> def my_abs(x):                                      
...     if x >= 0:                                      
...         return x                                    
...     else:                                           
...         return -x                                   
...                                                     
>>> my_abs(-9)                                          
9                                                       
>>>

将函数的定义保存为文件。将my_abs（）函数的定义保存到myfunc.py文件中(注意后缀名.py)，将myfunc.py放到当前目录下，用from myfunc import my_abs来导入my_abs()函数，注意myfunc是文件名（不含.py扩展名）：

>>> from myfunc import my_abs                          
>>> my_abs(-9)                                         
9                                                      
>>>

如果没有吧myfunc.py放到当前目录下，系统就找不到该文件：

>>> from myfunc import my_abs
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'myfunc'

在一个文件中可以同时定义多个函数：

def add(x,y):
	return x+y

def myabs(x):
	if x>0:
		return x
	else:
		return -x

>>> from myfunc import add
>>> add(-1,6)
5
>>> from myfunc import myabs
>>> myabs(-5)
5

也可以在其他.py文件中调用函数，例如在hello.py文件中调用myfunc.py文件中的add（）函数：

from myfunc import add
print(add(1,5))

结果

...\Desktop\python>python hello.py
6

参数

默认参数

>>> def caul(x,y=1):
...     return x+y
...
>>> caul(1)
2

无默认值的参数叫做必选参数，有默认值得参数叫做默认参数，默认参数必须放到必选参数后面，否则会报错：

>>> def caul(x=1,y):
...     return x+y
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

默认参数也可以被覆盖：

>>> def caul(x,y=1):
...     return x+y
...
>>> caul(1,2)
3
>>>

多个默认参数时：

>>> def enroll(name, gender, age=6, city='Beijing'):
...     print('name:', name)
...     print('gender:', gender)
...     print('age:', age)
...     print('city:', city)
...

既可以按顺序提供默认参数

>>> enroll('Jack','M',18)
name: Jack
gender: M
age: 18
city: Beijing

除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。

也可以不按顺序：

>>> enroll('Jack','M',city='Shanghai')
name: Jack
gender: M
age: 6
city: Shanghai

但是如果不用city=的形式，则python会按顺序赋值：

>>> enroll('Jack','M',"shanghai")
name: Jack
gender: M
age: shanghai
city: Beijing

而且，如果想要省略age而直接给city赋值得话，下面这种写法也是错的：

 enroll('Jack','M', ,"shanghai")
  File "<stdin>", line 1
    enroll('Jack','M', ,"shanghai")
                      ^
SyntaxError: invalid syntax

默认参数必须指向不变对象！

def add_end(L=[]):
    L.append('END')
    return L

当你正常调用时，结果似乎没有错误：

>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']

当你使用默认参数调用时，一开始结果也是对的：

>>> add_end()
['END']

但是，再次调用add_end()时，结果就不对了：

>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

Python函数在定义的时候，默认参数L的值就被计算出来了，即[ ]，因为他是指向[ ]的。一开始我们不用默认参数而是给定参数值时，L就会指向我们给定的那个[ ] ( [ 1,2,3],[‘x’ , ‘y’ ‘z’] … …)。但是当我们使用默认参数时，L每次指向的都是同一个[ ]，所以’END’一直在叠加下去。

>>> add_end()
['END']
>>> add_end([1,2,3])
[1, 2, 3, 'END']
>>> add_end()
['END', 'END']
>>> add_end(['x','y','z'])
['x', 'y', 'z', 'END']
>>> add_end()
['END', 'END', 'END']
>>>

所以当我们使用默认参数时，要指向不变对象

可变参数
我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。由于参数个数不确定，我们想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

调用的时候，需要先组装出一个list或tuple：

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

如果我们把函数的参数改为可变参数：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

调用函数的方式可以简化成这样：

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84

定义可变参数和定义一个 list 或 tuple 参数相比，仅在参数前面加了一个 * 号。在函数内部，参数numbers接收到的是一个tuple。调用该函数时，可以传入任意个参数，也可以不传入参数：

>>> calc(1, 2)
5
>>> calc()
0

如果想将一个list 或者 tuple 作为可变参数传递进去，需要在list 或者 tuple 前面加 *，否则会出错：

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

*nums表示把nums这个list的所有元素作为可变参数传进去。

注：当有多个参数时，可变参数必须放到参数列表的最后面

def calc(a,*b):
	print('a:',a)
	print('b:',b)

>>> calc('a','b',3)
a: a
b: ('b', 3)

如果放到必选参数前面，就会产生歧义：

def calc(*b,a):
	print('a:',a)
	print('b:',b)

>>> calc('a','b',3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: calc() missing 1 required keyword-only argument: 'a'

3. 关键字参数

用户可以传入0个或任意个关键字参数，这些关键字参数在内部自动组装成一个dict。
关键字参数在参数列表中用 **name 表示：

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去，需要在dict前加 **：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

def person(name, age, **kw):
     print('name:', name, 'age:', age, 'other:', kw)
     kw['university']='Oxford'
     print(kw)

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)

name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
{'city': 'Beijing', 'job': 'Engineer', 'university': 'Oxford'}

>>> extra
{'city': 'Beijing', 'job': 'Engineer'}

注：

关键字参数也要放到必选参数的后面。
关键字参数的‘key’值不用像dict里那样加‘单引号（gender和job）

person('Adam', 45, gender='M', job='Engineer')

4. 命名关键字参数
用户可以传入任意个关键字参数，如果想让用户传入指定个数的关键字参数，需要用到命名关键字参数。
命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

def person(name, age, *, city, job):
    print(name, age, city, job)

调用方式

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

如果 city 和 job 少写其中一个或者都不写，python会报错。

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

命名关键字参数必须传入参数名，也就是必须用city=‘Beijing’ job='Engineer’这种形式，否则将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

命名关键字参数可以有缺省值：

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

于命名关键字参数city具有默认值，调用时，可不传入city参数，也可以传入city参数并覆盖默认值：

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

5. 参数组合
在Python中，这5种参数都可以组合使用。参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

最神奇的是通过一个tuple和dict，你也可以调用上述函数
对于任意函数，都可以通过类似func(args, kw)的形式调用它，无论它的参数是如何定义的。

>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}