python3之函数

最新推荐文章于 2025-06-30 11:41:16 发布

原创最新推荐文章于 2025-06-30 11:41:16 发布 · 238 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python #函数

Python3 专栏收录该内容

61 篇文章

订阅专栏

1. 函数

代码的复用：函数

生活：场景_行为操作：[可以]做一件事情：有一个功能[执行|不执行]。
生活中_{具备一种行为} 行为只有在执行的时候才会操作。吃饭—去吃—吃饭的操作
生活中行为-> 编程语言：抽象-> 函数。定义函数 — 具备了一个功能 — 调用的时候执行操作。

基本语法

【定义/声明函数、调用函数】
define 定义

def  函数名称():
	函数中要执行的代码

扩展：文件开头使用三个引号的多行注释：解释说明当前这个python文件的操作说明。
函数的开头使用三个引号的多行注释：解释说说明当前这个函数的操作说明,其他可以查看的时候：通过__doc__查看说明文字。

例：

#函数的声明定义：
def eat():
	print(“函数中要执行的代码”)


#调用执行函数
eat()

备注：变量和函数有什么区别？

变量

变量指程序中临时存储数据的一个容器，给变量赋值可以使用赋值运算符，使用变量中的数据~可以通过变量名称直接操作数据。

函数

函数指程序中的一个代码块，包含多行代码{0~n行代码}。代码块要操作就得需要一个名称；这个名称就是一个变量。函数名称：就是代码块的名称。函数名称就是一个变量。

这个变量只是存储了函数的[内存]位置：并没有存储函数的代码。
直接打印变量->看到的是函数在内存中的地址如：<function eat at 0x000001A426C51F28>。
执行函数中的代码：变量(),代码才会执行。

小总结：
函数：还原的是生活中的行为操作。
函数的声明定义：声明定义函数~并不会执行其中的代码。

def 函数名称():
    函数中要执行的代码
def eat():
    print(“中午去吃什么，是一个世纪难题”)

函数的调用执行：函数必须通过名称调用才能执行包含的代码
函数名称() 执行指定名称的函数。eat() 执行了eat函数。
命名规范：函数名称的命名规范和变量一致！
函数的意义：模仿生活中的行为。

代码中，函数四种情况：

不需要提供数据，不需要返回结果
需要提供数据，不需要返回结果
不需要提供数据，但是需要返回结果
需要提供数据，需要返回结果。
行为：函数
提供的数据：函数的参数，放在函数声明后面的括号中
返回的结果：一般在函数中通过return返回。return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

怎么定义函数

[通过什么样的方式确定的定义函数]

代码中出现可能重复的代码->需要定义函数：重复代码
代码中出现操作功能的代码->需要定义函数：注册、登录、喂食…

一个函数尽量只做一件事情！让函数足够简单~函数的复用性最高！
定义了一个吃饭的函数[吃饭、锻炼活动]
调用：吃晚饭
吃午饭->调用？-- 不适合函数的复用。

怎么定义函数[定义函数的名称、参数、返回值]

问题：我怎么知道函数叫神马名称？我怎么知道定义什么参数？我怎么知道它要不要返回值？
问题的源头：不是程序在操作你，而是你在操作程序！你对程序代码的操作思路不明确！
解决的思路：代入生活场景，分析函数叫什么名称，执行时需要什么资源，要不要返回结果。

案例
展示登录注册界面，并且获取用户的选项。（此界面展示3个功能选项，登录、注册、退出）。
分析：
函数名称：show_login
函数参数：无
返回结果(返回值)：choice

二、函数参数及解包

函数参数

函数中的参数处理：参数的操作在python中被强化了，参数的功能非常强大。

1 位置参数

# 1 位置参数
def test1(p1, p2, p3):
    print(p1, p2, p3)


# 调用执行时，传递的实际参数按照位置顺序给形式参数进行赋值
test1(10, 20, 30)

2. 默认参数

# 2 默认值参数：定义函数的参数时，可以给参数赋值
# 如果函数参数中出现了默认值参数~一般默认值参数放在普通参数的后面
def test2(n1, n2, opra="+"):
#def test(n1, opra="+", n2):
    print("计算n1:[%s]和n2[%s]进行opra[%s]运算" % (n1, n2, opra))


# 默认值参数~如果实际参数传递了实际数据，就使用传递的数据；
# 如果默认值参数~没有传递实参，直接使用默认数据进行运算
test2(10, 20)
test2(10, 20, "/")

ps:设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

默认参数很有用，但使用不当，也会掉坑里。默认参数有个最大的坑，演示如下：
先定义一个函数，传入一个list，添加一个END再返回：

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']

很多初学者很疑惑，默认参数是[]，但是函数似乎每次都“记住了”上次添加了’END’后的list。
原因解释如下：
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用None这个不变对象来实现：

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

现在，无论调用多少次，都不会有问题：

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

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

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

3. 实参关键字参数

例：

# 3. 实参关键字参数[可选]：主要目的是为了提高代码的可读性。
def test3(p1, p2, p3):
    print(p1, p2, p3)


# 实参关键字参数，调用时可以根据参数名称进行赋值[打破位置参数要求的顺序]
test3(10, 20, 30)  # 按照默认的位置顺序赋值
test3(p2=20, p1=10, p3=30)  # 按照形参名称赋值[可以打乱位置顺序]

4. 命名关键字参数

例：

# 4. 实参强制关键字参数：提高代码的可读性
def test4(*, p1, p2, p3):
    print(p1, p2, p3)


# 实参传递数据时，形式参数中符号* 后面的所有参数~都要使用k=v的关键字参数方式传递数据
test4(p1=10, p2=20, p3=30)

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

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

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

>>> 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

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

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

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

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

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

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个作为特殊分隔符。如果缺少，Python解释器将无法识别位置参数和命名关键字参数：

def person(name, age, city, job):
    # 缺少 *，city和job被视为位置参数
    pass

5. 可变参数

可变参数：函数在执行过程中，可以接受0~N个参数,在函数内部，参数numbers接收到的是一个tuple。
例:

def test(*args):  # args: arguments 参数
    print("可变参数，在普通参数前面添加一个符号*")
    print("test()函数就可以接受0~n个参数进行操作")
    print(args)

    for x in args:
        print(x)

    print("**********************")

test()
test("hello")
test("hello", "jerry")
test(1, 3, 5)
test(1, 1, 2, 3, 5, 8, 13, 21)

Python允许你在list或tuple前面加一个*号，把list、tuple或set的元素变成可变参数传进去：

nums = [1, 2, 3]
test(*nums)

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

6. 可变关键字参数

例：

# 2. 可变关键字参数
def test2(**kwargs): # keyword arguments=>kwargs
    print("可变关键字参数，就是在普通参数的前面添加符号**")
    print("可变关键字参数，可以接受多个k=v的参数数据")
    print("并且可以接受0~n个k=v的数据")
    print("并且将数据包含在字典中")
    print(kwargs, kwargs.get('name'))

test2(name="tom")
test2(name="shuke", age=62)
test2(name="jerry", age=18, gender="男")

函数的参数：万能形参

例：

# 3. 函数的参数：万能形参
def test3(*args, **kwargs):
    print(args, kwargs)

# 号称可以接受任何参数：在满足规范的情况下
test3()
test3("hello")
test3("hello", name="jerry")
test3("hello", "world", name="tom")
test3(name="tom")
#test3(name="tom", "hello")

参数组合

在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)

在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

>>> 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，你也可以调用上述函数：

>>> 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': '#'}

所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

三、解包

解包: 将组合数据类型拆分。
例：

def test(p1, p2):
    print(p1, p2)

正常调用:

test(10, 20)

非正常调用，列表解包

nums = [10, 20]
# 列表参数前面添加一个*符号，表示将列表拆分成一个一个独立的数据传递
test(*nums)  # test(*nums) 相当于--> test(10, 20)

非正常调用：字典解包

nums2 = {'p1': 100, 'p2': 200}
test(**nums2)  # test(**nums2) 相当于--> test(p1 = 100, p2 = 200)

可变参数及list解包

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


nums = (1, 2, 3)    # nums可以为list、tuple、set
res = calc(*nums)  # 解包
print(res)