Python函数核心概念：从入门到精通

Cyyyy_g

于 2025-05-30 12:14:04 发布

阅读量421

点赞数 11

分类专栏： python手把手教学——学完秒变大神文章标签： python 开发语言

本文链接：https://blog.csdn.net/Cyyyy_g/article/details/148321972

版权

python手把手教学——学完秒变大神专栏收录该内容

7 篇文章

订阅专栏

一、基础篇：函数核心概念

1. 函数定义与调用

关键字：使用 def 定义函数，包含函数头（参数列表）和函数体（代码块）。

文档字符串：用 '''...''' 注释函数功能，可通过函数名.__doc__ 查看。

模块化：将复杂任务拆分为小函数，提高代码复用性。

示例：

#封装代码块，将代码逻辑组织成独立的功能单元，提高代码的可读性和可维护性。

def greet():    #函数头

    '''显示简单问候语Hello!'''    #文档字符串，用于解释函数

    print("Hello!")    # 定义一个函数，封装打印问候语的逻辑



greet()   # 调用函数，输出 "Hello!"



#模块化设计：分解复杂任务，将程序拆分成多个小函数，便于协作和调试。

def calculate_average(numbers):

return sum(numbers) / len(numbers)



data = [1, 2, 3, 4]

avg = calculate_average(data)  #输出： 2.5

2. 参数传递机制

形参与实参：

形参：函数定义中声明的参数（如 def func(a, b) 中的 `a, b`）。

实参：调用函数时传递的值（如 func(1, 2) 中的 `1, 2`）。

#形参和实参

def  greet_user(username):   #'username'是形参，函数完成工作所需要的信息

    print(f"Hello,{username.title()}!")

greet_user("jesse")   #'jesse'在调用函数时传递给函数的信息。

传递方式：

位置传参：按顺序传递实参（如 func(1, 2)）。

#位置传参

def get_sum(a,b,c):

    sum_1 = a+b+c

    print(sum_1)



get_sum(2,4,6)   #位置传参，按照顺序进行传递参数 【基于实参的顺序进行关联】

                #输出：12

关键字传参：指定参数名传递（如 func(a=1, b=2)）。

#关键字传参

def get_sum(a,b,c):

    sum_1 = a+b+c

    print(sum_1)



#关键字传参，可以不需要按照顺序进行传递参数

get_sum(a=2,c=4,b=6)  

                #输出：12

默认参数：为形参设置默认值，调用时可省略（如 def func(a, b=2)）。

注意：默认参数需放在非默认参数之后。

#默认值

def meassge(a,w=1):   #给形参w设置默认值为1，a没有设置默认值

    print(a)      #【在设置默认值时，只能从后往前设置】

    print(w)



meassge(2)    #当没有给设置默认值的形参指定实参时，自动返回默认值

              #输出:     #没有设置默认值的形参，需要传递参数

              #   2

              #   1

meassge(1,3)    #如果给形参指定了实参值，则返回指定的实参

              #输出:

              #   1

              #   3

3. 可变参数与关键字参数

可变参数（*args）：接收任意数量的位置参数，封装为元组。

#可变参数(*args):同一个函数只能有一个可变参数

def sum_numbers(*args):  # args会变成元组

    total = 0

    for num in args:   #函数体内，可变参数args保存了所有的参数，是元组类型

        total += num

    return total



#可变参数不支持使用关键词赋值

print(sum_numbers(1,2,3))  # 输出： 6    

print(sum_numbers(5,10))    # 输出： 15

可变关键字参数（**kwargs）：接收任意数量的关键字参数，封装为字典。

#可变关键词参数（**kwargs）    

def build_profile(**kwargs):  # kwargs变成字典

    print("用户信息：")

    for key, value in kwargs.items():  

        print(f"- {key}: {value}")



build_profile(name="小明", age=18, city="北京")

# 输出：

# 用户信息：

# - name: 小明

# - age: 18

4. 返回值与函数类型

return 语句：终止函数并返回值，可返回任意类型（单个值、元组、列表等）。

#返回函数的计算结果

#函数可以返回任意类型的值（如整数、字符串、列表、字典等），甚至是多个值（实际返回一个元组）。

def add(a, b):

    return a + b  # 返回两数之和，return将函数内部的计算结果传递给调用者。



result = add(3, 5)  # result = 8



#终止函数执行

#当函数执行到return时，会立即退出函数，后续代码不再运行。

def check_positive(num):

    if num > 0:

        return "正数"

return "非正数"  # 若执行到此处，说明num <= 0



print(check_positive(5))  # 输出：正数

print(check_positive(-3)) # 输出：非正数



#返回多个值

#通过逗号分隔多个值，return会将其打包为元组返回。调用时可通过解包获取值。

def calculate(a, b):

    return a + b, a - b, a * b  # 返回元组 (和, 差, 积)



sum_result, diff_result, prod_result = calculate(10, 5)

print(sum_result)  # 输出：15



#无返回值时返回None

#若函数没有return语句，或仅有return不带值，默认返回None。

def no_return():

print("执行完毕")



result = no_return()  # 输出："执行完毕"

print(result)         # 输出：None



#在控制结构中使用return

#return可在条件、循环等结构中灵活使用，提前退出函数。

def find_first_even(numbers):

    for num in numbers:

        if num % 2 == 0:

            return num  # 找到第一个偶数后立即返回

    return None  # 未找到时返回None

5.定义参数类型

在传递形参时，形参可以有多个值，当我们需要给形参指定类型时，可以直接定义

#定义形参类型

def get_sum(a,b,c : str):   #将形参c定义为字符串类型（str）

    sum_2 = a*b*c

    print(sum_2)



get_sum(2,4,'-')   #输出：--------

#定义形参类型

def line(a,b,c):  

    sum_2 = a*b*c

    print(sum_2)



line(2,4,'-')   #输出：--------  

#当调用已定义的函数式

#当形参c关联的实参为字符串时，在函数体内默认形参c为字符串类型

6.混合使用参数口诀：

口诀：普通位置参数 → 默认参数值 → *args（可变参数） → 普通关键字参数 → **kwargs （可变关键字参数）

#混合使用参数顺序

def complex_func(a, b=2, *args, c, d=4, **kwargs):

    print(f"a={a}, b={b}, args={args}, c={c}, d={d}, kwargs={kwargs}")



complex_func(1, 3, 4,5, c=6, name="test")

# 输出：a=1, b=3, args=(4,5), c=6, d=4, kwargs={'name': 'test'}

7. 列表传递与修改

函数直接操作原始列表，修改永久生效。

若需保护原列表，可传递切片副本（如 func(list[:])）。

def append_item(lst, item):

    lst.append(item)



nums = [1, 2, 3]

append_item(nums, 4)

print(nums)  # 输出：[1, 2, 3, 4]（原始列表被修改）

8. 模块化编程：模块与导入

一、模块（Module）的基本概念

模块是一个包含Python代码的 `.py` 文件。通过将函数存储在模块中，可以实现：

（1）. 代码复用：多个程序可共享同一模块

（2）. 代码组织：将逻辑相关的函数分类存放

（3）. 命名空间管理：避免函数名冲突

二、创建模块

假设我们创建一个名为 `greeting.py` 的模块，包含以下内容：

# greeting.py

def greet(name):

    """显示简单的问候语"""

    print(f"Hello, {name.title()}!")



def greet_formal(name, title):

    """显示正式问候"""

    print(f"Good day, {title} {name}!")

三、导入模块的 5 种方式

（1）. 导入整个模块

import greeting # type: ignore



greeting.greet("alice")       # 输出: Hello, Alice!

greeting.greet_formal("smith", "Dr")  # 输出: Good day, Dr Smith!

#优点：完全避免命名冲突

#缺点：每次调用需要写模块名前缀

（2）. 导入特定函数

from greeting import greet



greet("bob")  # 直接使用函数名

#优点简化调用

#仅导入明确指定的函数

（3）. 使用别名（Alias）

#给函数起别名

from greeting import greet_formal as gf

gf("curie", "Prof")  # 输出: Good day, Prof Curie!



#给模块起别名

import greeting as gr

gr.greet("david")  # 输出: Hello, David!



#适用场景：均适用于模块名较长时简化代码

（4）. 导入所有函数（慎用！）

from greeting import *



greet("eva")

greet_formal("frank", "Mr")

#优点：快速访问所有功能

#缺点：可能引起命名冲突,减低代码可读性

#建议：仅在小项目或临时测试中使用

（5）. 模块的层级导入

对于包（Package）中的模块：

#对于包（Package）中的模块：

from my_package.tools import greeting # type: ignore

#需在目录中创建**init**.py文件（可以是空文件）来声明包