一、函数基础
1.什么是函数:
函数是组织好的、可重复使用的、用来实现特定功能的代码片段。
2.函数的作用:
(1)提高代码复用性
(2)提高代码的可读性、可管理性、维护性
3.定义函数:
def 函数名(参数列表):
"""函数文档字符串(说明作用)"""
函数体代码
return 返回值 # 可选,没有return默认返回None
注意:(1)函数定义时如果有多个参数,多个参数之间使用逗号“ , ”分隔
(2)return 语句只有返回功能,而没有输出打印的功能,如果要输出,需要结合print()函数来实现
4.调用函数:
函数名(参数)
5.简单案例-函数定义+调用
函数内不确定的数据:设置成参数让外部进行传递
函数的执行结果:在外部定义变量接收
"""
#函数定义
定义语法:
def 函数名称(): #无参无返回值
函数体
def 函数名称(参数): #有参无返回值
函数体
def 函数名称(): #无参有返回值
函数体
return 结果
def 函数名称(参数): #有参有返回值
函数体
return 结果
参数和返回结果如何设计:
看需求
#函数调用
调用语法:
函数名称() #无参无返回值
函数名称(实参) #无参无返回值
变量 = 函数名称() #无参有返回值
变量 = 函数名称(实参) #有参有返回值
"""
#需求1:设计函数计算12345和54321的和,并打印结果
def func1():
result = 12345 + 54321
print(result)
#需求2:设计函数并计算两个数和,并打印结果
def func2(num1, num2):
result = num1 + num2
print(result)
#需求3:设计函数计算12345和54321的和
def func3():
result = 12345 + 54321
return result
#需求4:设计函数并计算两个数和
def func4(num1, num2):
result = num1 + num2
return result
#需求5:调用4个函数
func1()
func2(123,456)
result3 = func3()
result4 = func4(123,456)
6.函数的说明文档
(1) 函数说明文档是写在函数开头,用三个引号包裹的字符串,用于解释函数的功能、参数、返回值等信息,方便调用者清楚函数的具体作用及细节
(2)函数说明文档的作用:方便调用者清楚函数的具体作用及细节,使代码更容易理解、使用和维护
(3)如何添加函数说明文档:
写在函数开头
用三个引号包裹的字符串
用于解释函数的功能、参数、返回值等信息
(4)如何查看函数说明文档:
方式一:通过help函数
help(rectangle_area)
方式二:在pycharm中,鼠标悬浮在函数上,自动展示(推荐)
#定义一个函数:计算传入的字符串中元音字母的个数
"""
需求1:
函数名:count
参数:需要,传递统计的字符串参数,count_str
返回值:需要,返回统计的个数
功能实现:略
"""
def count(count_str):
"""
计算传入的字符串中元音字母的个数
:param count_str:
:return:
"""
count = 0
for i in count_str:
if i in "aeiouAEIOU":
count+=1
return count
count1 = count("abandon")
print(count1)
#定义一个函数:计算传入的班级学员高考成绩列表中最高分、最低分、平均分
"""
需求2:
函数名:count_score
参数:需要,传递统计的字符串参数,score_list
返回值:需要,返回统计的最高分、最低分、平均分(从五大容器中选择封装多个结果,返回容器)
功能实现:略
"""
def count_score(score_list):
"""
计算传入的班级学员高考成绩列表中最高分、最低分、平均分
:param score_list:
:return:
"""
max_score = max(score_list)
min_score = min(score_list)
avg_score = sum(score_list)/len(score_list)
score = {"max":max_score,"min":min_score,"avg":avg_score}
return score
count_score1 = count_score([88,99,66,77])
print(count_score1)
二、函数进阶
1.函数—变量作用域
(1)有哪些作用域:
—— local (局部):在del函数里面创建的变量,就是局部变量
—— Enclosing (嵌套外层):函数里面再套一个函数(嵌套函数)
—— Global (全局):直接写在函数外面
—— Built – in (内置):Python自带的名字
注意:
全局变量:在函数、推导式之外定义的变量,称之为全局变量。
在整个文件中(包括函数内)都可以使用(通常定义在文件的顶部)。
局部变量:在函数、推导式内部定义的变量,称之为局部变量。
只在该函数内部使用外部无法访问,执行完毕后会自动销毁其内部局部变量
(2)作用域特点:
变量在哪定义,它的活动范围基本就在哪
口诀:LEGB(查变量的寻找顺序)
Local(局部)–>Enclosing(嵌套外层)–> Global(全局)–> Built – in(内置)
(3)在局部修改全局变量:
<1>首先,使用global修饰变量
global 变量名称
<2>告知Python解释器,当前操作的是外部全局的变量,当前位置不要重新创建新的变量,直接操作外部全局变量
变量名称 = 新的值
# 全局变量
num = 100
def change_num():
# 声明:下面操作的 num 是全局变量
global num
num = 200 # 修改全局变量的值
print("函数内部num:", num)
# 调用
change_num()
print("函数外部num:", num)
2.函数-参数
(1)传参方式
方式一、位置传参
调用函数时根据函数定义时的位置来传递参数
要求:调用函数时参数顺序与定义函数时参数顺序完全一致
方式二、关键字传参
调用函数时以函数定义时形参作为关键字,以“键=值”的形式来传递参数(不要求顺序)
注意:如果位置参数与关键字参数混用,关键字参数必须在位置参数之后(关键字参数之间,没有顺序要求)
| 写法 | f(值1, 值2, 值3) | f(名1=值1, 名2=值2) |
| 对应依据 | 位置顺序 | 参数名 |
| 顺序是否重要 | ✅ 必须严格对应 | ❌ 可任意排列 |
| 可读性 | 差(值是什么要靠猜) | 强(一眼看懂) |
| 代码量 | 简洁 | 稍繁琐 |
| 易错风险 | 高(顺序错就全错,且不报错) | 低(名字错会直接报错) |
| 维护扩展 | 难(加参数要改所有调用处) | 易(只补需要的那一个) |
| 适用场景 | 参数 ≤ 3 个,且顺序自然 | 参数较多,或类型 / 含义易混淆 |
"""
要求:掌握函数调用时,参数传递的方式
方式一:位置参数
调用函数,传递参数时,参数的顺序和定义函数时完全一致
方式二:关键字参数
调用参数,传递参数时,参数的顺序和定义函数时可以不一致
参数名称=值,参数名称=值
"""
def show_info(name,age,gender,address):
print(f"name={name}")
print(f"age={age}")
print(f"gender={gender}")
print(f"address={address}")
#调用函数:位置参数方式传递参数
show_info("柚子",21,"女","杭州")
print()
#调用函数:关键字参数方式传递参数
show_info(gender="男",age=23,address="杭州",name="柠檬")
print()
方式三、缺省传参/默认参数
在定义函数时,为参数提供默认值,调用函数时,可以不传递有默认值的参数。
注意:默认参数必须放在没有默认值的参数列表的后面,一个函数在定义时是可以设置多个默认参数的。
函数调用时,若果为默认参数传递了值,则会修改默认的参数值;如果没有传递该参数,则直接使用默认值。
def show_info(name,age,gender="女",address="杭州"):
print(f"name={name}")
print(f"age={age}")
print(f"gender={gender}")
print(f"address={address}")
show_info("桃子",25,"女","上海")
print()
show_info("柚子",25)
方式四、不定长传参
不定长参数也叫可变参数,用于函数定义及调用时参数个数不确定(0或多个)的场景
类型:——位置传递
"""
语法:
def 函数名称(*args):
函数体
return 结果
"""
#需求:统计一批数据的最大值、最小值、平均值
#传递的所有实参都被datas变量收集,并封装到一个tuple中
def calc_data(*datas): #datas只是一个形参名称,可自行定义;形参前加*表示组包(将多个参数封装到一个容器中)
print(f"形参的类型是{type(datas)}")
print(f"最小值:{min(datas)}")
print(f"最大值:{max(datas)}")
print(f"平均值:{type(datas)}")
print()
calc_data(1, 2, 3)
calc_data(1, 2, 3,4,5) #实参:需要传递多个位置参数数据
calc_data(1, 2)
calc_data(1, 22, 3,44,5,66,7,88,9,100)
t1 = (12,3,4,5)
calc_data(*t1,1,2,3) #实参前加*表示解包(将容器中的多个数据,提取出来作为多个参数)
注意:
(1) 传递的所有匹配的位置参数都会被args变量收集,这些参数会合并封装为一个元组,args是元组类型(注意并不会封装关键字参数)
(2)args只是约定俗成的变量名,并不是关键字,这里可以使用任何合法的变量名(eg:*data)
——关键字传递
"""
要求:看懂不定长关键字参数的书写形式
语法:
def 函数名称(*args):
函数体
return 结果
"""
#需求:展示用户信息
#传递的所有实参都被datas变量收集,并封装到一个dict中
def show_info(**datas): #datas只是一个形参名称,可以自行定义
print(f"形参的类型是{type(datas)}")
print(datas)
print()
show_info(name="张三",age=23,gender="男",tel="18000000000000")
show_info(name="张三",gender="男",tel="18000000000000")
show_info(gender="男",tel="18000000000000")
show_info(gender="男")
注意:
(1)参数是以“键=值”形式传递的关键字参数,这些“键=值”参数都会被kwargs接受,并合并封装为一个字典类型。
(2)kwargs只是约定俗成的变量名,并不是关键字,这里可以使用任何合法的变量名(eg:**options)
def f(必填, 可选=默认, *数据, 仅关键字, **选项)
↑ ↑ ↑
单个可省 打包成元组 打包成字典
f(1, 2, 3, 4, opt=5, x=6)
3.参数类型
(1)普通参数
eg. float、int、bool、str、list、set、tuple、dict等
(2)特殊参数
def 函数名称(普通参数,函数参数):
函数参数()
def add(a,b):
return a+b
def sub(a,b):
return a-b
def calc(a,b,operator):
"""
对两个数进行四则运算操作
:param a: 第一个数据
:param b:第二个数据
:param operator: 运算的函数
:return: 运算结果
"""
result = operator(a,b)
print(f"计算结果{result}")
calc(10,20,add)
calc(10,20,sub)
4.匿名函数——lambda
(1)概念:匿名函数指的是没有名称的函数,需要通过lambda表达式来声明函数,可以简化简单函数的编写(单行表达式)
(2)为什么使用匿名函数:
——需要定义一个函数:函数只临时使用一下,只使用一次,函数逻辑不复杂
——需要将此函数作为参数传递给另一个函数使用
(3)lambda使用条件:
条件1:有返回值
条件2:函数体只有一行代码
(4)语法格式:
lambda [参数列表]:函数体
(5)注意:
传递的是函数名称,不是调用函数本身;
匿名函数中必须是一个表达式,会自动将表达式的运行结果作为返回值。如果执行的是print()这类无返回值的操作,lambda会返回None;
def calculation(x, y, operator):
"""
对两个数进行四则运算操作
:param x: 第一个数据
:param y: 第二个数据
:param operator: 运算的函数
:return: 运算结果
"""
result = operator(x, y)
print(f'计算结果:{result}')
"""
要求:看懂普通参数和特殊类型的参数
普通参数:
int , float , bool , None type
str , list , tuple , set , dict
特殊参数:
函数
"""
calculation(10, 20, lambda x, y: x + y)
calculation(1234, 1000, lambda x, y: x – y)
"""
内置函数:map(fun,datas)
作用:对一批数据进行批处理
参数:1.加工处理的函数,2.待处理的一批数据
返回:处理后的一批结果序列数据,可以使用list()/tuple()/set()转换成具体的容器
"""
def func(x):
return x.replace('你大爷','**')
# 需求:["你大爷,身体最近好吗?","菜鸡,去你大爷的","会玩吗?你大爷!"],对列表中的敏感数据进行脱敏处理,把你大爷,替换成**
data_list = ["你大爷,身体最近好吗?","菜鸡,去你大爷的","会玩吗?你大爷!"]
result = map(func, data_list)
print(list(result))
补充:map()函数
map(函数, 可迭代对象)
- 作用:把可迭代对象里的每一个元素,依次传给这个函数做处理,返回一个 map 对象(迭代器)
- 特点:懒加载,不会立刻算出全部结果,需要用 list() 转成列表查看
一句话:对序列里每一个元素批量执行同一个函数
5.递归算法
(1)表现:函数调用函数
(2)场景:发现公式中存在函数自己调用自己的情况,可以使用递归算法实现
(3)实现步骤:找递归公式 –> 定义递归函数 –> 设置出口,避免栈内存溢出
"""
递归算法:函数自己调用自己
def func1():
func1()
注意:避免栈内存溢出
递归编写流程:
1.找递归公示
2.定义递归函数
3.设置出口,避免栈内存溢出
"""
# 需求1:计算一个数的阶乘
def func1(n):
# 递归的出口
if n == 1:
return 1
return n*func1(n-1)
print(func1(5))
# 需求2:计算一个数的累加和
def func2(n):
# 递归的出口
if n == 1:
return 1
return n+func1(n-1)
print(func2(5))
6.类型注解
(1)相关定义
——类型注解:是Python中的一种语法特性,用于明确标识变量、函数参数和返回值的数据类型,从而使代码更清晰、更安全、更易维护。
——类型推断:Python解释器自动推断出变量、函数参数和返回值的数据类型的能力,而无需开发者显式声明。
(2)类型的写法:
-变量:
# 基础写法:变量名: 类型 = 值
name: str = "小明"
age: int = 20
score: float = 95.5
is_student: bool = True
# 容器类型注解(Python3.9+可以直接写list)
nums: list[int] = [10, 20, 30]
info: dict[str, int] = {"语文": 88, "数学": 92}
print(name, age, nums)
-函数:
# 函数:接收两个int,返回int
def add(a: int, b: int) -> int:
return a + b
# 调用
res = add(3, 5)
print(res)
# 另一个例子:接收字符串,返回布尔值
def is_long(s: str) -> bool:
return len(s) > 5
print(is_long("hello"))
(3)常见类型的写法
——单个类型:int、float、bool、str、None、list、set、tuple、dict
——多个类型:str | int | None
(4)类型注解的好处
-代码结构更清晰、代码逻辑更安全、易维护
-更准确的代码自动提示
-提前发现代码潜在问题
(5)使用场景
-Python是动态类型语言,添加的类型注解只是提示,并不是强制约束
-类型推断:Python会自动进行类型推断 –> 如果对变量直接赋值、变量运算等场景
-类型注解:函数参数、返回值,推荐使用类型注解
7.模块
了解即可
补充:特殊变量
__all__ = ["名字1", "名字2", "名字3"]
__all__ 是一个列表,用来控制 from 模块名 import * 时,哪些名字会被导入(白名单)。
只对 import * 生效!import 模块、from xxx import 名字 不受它限制。
__name__:判断模块是直接运行还是被导入,控制代码是否执行 取值:__main__ , 模块名称 if __name__ == “__main__”: 测试代码
__name__ == "__main__"
8.软件包
导入包方式:
| import 包名.模块名 | 模块 | 无 | 包名.模块名.功能 |
| from 包名 import 模块名 | 模块 | 无 | 模块名.功能 |
| from 包名 import * | 包下的模块 | 包的__init__.py里的__all__ | 模块名.功能 |
| from 包名.模块名 import 功能名 | 单个功能(类 / 函数) | 无 | 直接 功能名() |
| from 包名.模块名 import * | 模块内的功能 | 模块 py 文件里的__all__ | 直接 功能名() |
注意:注意:在包中导入当前包中的模块时,不要忘记使用相对路径,从当前包中获取功能 相对路径:from .模块名称
网硕互联帮助中心





评论前必须登录!
注册