您的位置: 首页  >  文章  >  每日一python（10） - 函数

每日一python（10） - 函数

分类: 文章 • 2025-04-16 18:54:10

文章目录

1 函数的定义和调用

函数定义的语法说明：

  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串 — 用于存放函数说明。 函数内容以冒号起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。return语句执行时，Python跳出函数并返回到调用这个函数的地方。

例如1：使用函数来输出“hello python”

>>> def hello():   #定义一个hello()函数
		print("hello python")    #这个函数的功能是输出hello python

>>> hello()    #调用函数hello()
hello python

例如2：函数中带有参数来求矩形面积

>>> def area(width, height):  #定义一个函数area，用来计算矩形的面积
	return width * height

>>> w = 4
>>> h = 5
>>> print("width = ", w, "height = ", h, "area = ", area(w, h) ) #print语句中调用函数area()
width =  4 height =  5 area =  20
>>>

例3：求两个数中的较大者

def maxTwo(a, b):
    if a > b:
        print(a)
    else:
        print(b)

def maxThree(x, y, z):
    if x > y:
        maxTwo(x, z)
    else:
        maxTwo(y, z)

maxTwo(5, 8)
maxThree(10, 6, 18)

输出结果如下：
每日一python（10） - 函数

2 函数参数传递

在 python 中，类型属于对象，变量是没有类型的，如：
a = [1, 2, 3, 4]
a = “python”

说明：
[1, 2, 3, 4]是List类型，“python”是String类型，而变量a没有类型，它仅仅是一个对象的引用（即指针），可以指向List类型的对象，也可以指向String类型的对象，当然也可以指向其他类型的对象。

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 List，Dict 等是可以修改的对象。在Python的函数传递中，对于不可变类型是按值传递，对于可变类型是按引用传递。

来看两个例子：

>>> a=1
>>> def fun(a):
		a=2

>>> fun(a)
>>> print(a)

打印结果： 1 

>>> a = []
>>> def fun(a):
		a.append(1)
>>> fun(a)
>>> print(a)

打印结果： [1]

说明： 所有的变量都可以理解成是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。

接下来，通过内存地址来观察一下引用a的变化，如下：

a = 1
print("origin:", id(a))                         # 1350574800
def fun(a):
    print("fun_in:",id(a))                      # 1350574800
    a = 2
    print("re-point:", id(a),id(2))             # 1350574832 1350574832

print("fun_out:", id(a), id(1))                 # 1350574800 1350574800
fun(a)
print(a)                                        # 1

从上面的程序执行结果来看： 在执行完 a = 2 之后，a引用中保存的值，即内存地址发生了变化，由原来1对象的所在地址变成了2这个实体对象的内存地址。

a = []
print("origin:", id(a))                                  # 56735816
def fun(a):
    print("fun_in:", id(a))                              # 56735816
    a.append(1)
print("fun_out:", id(a))                                 # 56735816
fun(a)
print(a)                                                 # [1]

从上面的程序执行结果来看： a引用保存的内存地址始终没有发生变化。

注意：

（1） 这里记住的是类型，是属于对象的，而不是变量。而对象有两种：“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings，tuples，和numbers是不可更改的对象，而list，dict等则是可以修改的对象。(这就是这个问题的重点)

（2） 当一个引用传递给函数的时候，函数会自动复制一份引用，这个函数里的引用和外边的引用就没有任何关系了。所以在第一个例子里函数把引用指向了一个不可变对象，当函数返回的时候，外面的引用没有发生任何变化；而第二个例子就不一样了，函数内的引用指向的是可变对象，对它的操作就与定位了指针地址一样，在内存里进行修改。

（3） Python不允许程序员选择采用传值还是传引用。Python参数传递采用的肯定是“传对象引用”的方式。实际上，这种方式相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于通过“传值”来传递对象。

（4） 当人们复制列表或字典时，就复制了对象列表的引用。如果改变引用的值，则就修改了原始的参数。

3 函数的参数

3.1 位置参数

例：设计一个函数求某个数的平方数（x2）

>>> def power(x):
		return x * x

对于power(x) 函数，参数x 就是一个位置参数。

当我们调用power 函数时，必须传入有且仅有的一个参数x ：

>>> power(5)
25
>>> power(15)
225

现在，如果我们要计算x3怎么办？可以再定义一个power3 函数，但是如果要计算x4、x5……怎么办？我们不可能定义无限多个函数。

你也许想到了，可以把power(x) 修改为power(x, n) ，用来计算x的n次方，如下：

>>> def power(x, n):
		s = 1
		while n > 0:
			n = n - 1
			s = s * x
		return s

对于这个修改后的power(x, n) 函数，可以计算任意n次方：

>>> power(5, 2)
25
>>> power(5, 3)
125

说明： 修改后的power(x, n) 函数有两个参数： x 和 n ，这两个参数都是位置参数，调用函数时，传入的两个值，按照位置顺序依次赋给参数x和n 。

3.2 默认参数

新的power(x, n) 函数定义没有问题，但是，旧的调用代码失败了，原因是我们增加了一个参数，导致旧的代码因为缺少一个参数而无法正常调用，如下：

>>> power(5)
Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    power(5)
TypeError: power() missing 1 required positional argument: 'n'

错误提示：调用power()函数缺少一个位置参数n。

这个时候默认参数就可以派上用场了，由于我们经常计算x的平方，所以，完全可以把第二个参数n的默认值设定为2，如下：

>>> def power(x, n=2):
		s = 1
		while n > 0:
			n = n - 1
			s = s * x
		return s

这样，当我们调用power(5) 时，相当于调用power(5, 2) ，如下：

>>> power(5)
25
>>> power(5, 2)
25

而对于n > 2 的其他情况，就必须明确地传入n，比如power(5, 3)，如下：

>>> power(5, 3)
125

从上面的例子可以看出，默认参数可以简化函数的调用。

设置默认参数时，有几点要注意：
一是： 必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；

二是： 如何设置默认参数。
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

使用默认参数有什么好处？最大的好处是能降低调用函数的难度。

下面针对默认参数，看下面的一个问题，有如下一个函数：

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

add_end()
add_end()

想一想，返回结果是什么？？？
每日一python（10） - 函数

想一想，为什么返回结果是上面的样子？？？这是因为：

Python函数在定义的时候，默认参数L的值就被计算出来了，即 []，因为默认参数L也是一个变量，它指向对象是 []（是可变的），每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的 []了。

因此，定义默认参数要牢记一点：默认参数必须指向不变对象！

要修改上面的例子，我们可以用None这个不变对象来实现：

def add_end(L=None):
    if L is None:
        L = []
    L.append('Python')
    return L

add_end()
add_end()

这次的返回结果就是我们预期的结果了，如下：
每日一python（10） - 函数

3.3 可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

我们以数学题为例子，给定一组数字a，b，c……，请计算a + b + c + ……。

要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

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

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

>>> calc([1, 2, 3])
6
>>> calc([1, 3, 5, 7, 9])
25

而如果我们利用可变参数，调用函数的方式就可以写成如下形式：（不必list或tuple）

>>> calc(1, 2, 3)
6
>>> calc(1, 3, 5, 7, 9)
25

所以，这里我们需要将calc函数的参数改成可变参数，如下：

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

我们看到：定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个list或者tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

>>> calc(2, 4, 6, 8, 10)
30
>>> calc()
0

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
6

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个 * 号，把list或tuple的元素变成可变参数传进去：

>>> calc(*nums)
6

注意： 这里 *nums 表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

3.4 关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个list或者tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

例如：

>>> def person(name, age, **key):
		print("name:", name, "age:", age, "other:", key)

函数person除了必选参数name和age外，还接受关键字参数key 。在调用该函数时，可以只传入必选参数：

>>> person('Tom', 30)
name: Tom age: 30 other: {}

也可以传入任意个数的关键字参数：

>>> person("Bob", 28, city = "shanghai")
name: Bob age: 28 other: {'city': 'shanghai'}
>>> person('jonana', 32, gender = 'M', job = 'Teacher', city = "Shanghai")
name: jonana age: 32 other: {'gender': 'M', 'city': 'Shanghai', 'job': 'Teacher'}

关键字参数有什么用？它可以扩展函数的功能。比如，在person 函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

>>> extra = {'city':'Shanghai', 'job':'Engineer'}
>>> person('jack', 24, city = extra['city'], job = extra['job'])
name: jack age: 24 other: {'city': 'Shanghai', 'job': 'Engineer'}

当然，上面复杂的调用可以用简化的写法，如下：

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

说明： **extra 表示把extra这个dict的所有key-value用关键字参数传入到函数的**key参数，key将获得一个dict，注意key获得的dict是extra的一份拷贝，对key的改动不会影响到函数外的extra。

3.5 命名关键字参数

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过key检查。

仍以person() 函数为例，我们希望检查是否有city和job参数：

>>> def person(name, age, **key):
		if 'city' in key:
			# 存在city参数
			pass
		if 'job' in key:
			# 存在job参数
			pass
		print('name:', name, 'age:', age, 'other:', key)

但是调用者仍可以传入不受限制的关键字参数：

>>> person('Jack', 24, city = 'Shanghai', addr = 'Puong')
name: Jack age: 24 other: {'addr': 'Puong', 'city': 'Shanghai'}

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

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

我们看到：与关键字参数**key不同，命名关键字参数需要一个特殊分隔符*， *后面的参数被视为命名关键字参数。

调用方式如下：

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

注意： 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错，如下：

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

说明： 由于调用时缺少参数名city 和job ，Python解释器把这4个参数均视为位置参数，但person() 函数仅接受2个位置参数。

另外，命名关键字参数可以有缺省值，从而简化调用，例如：

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

这里，由于命名关键字参数city 具有默认值，调用时，可不传入city 参数：

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

注意： 使用命名关键字参数时，要特别注意， * 不是参数，而是特殊分隔符。如果缺少 * ，Python解释器将无法识别位置参数和命名关键字参数。

相关推荐