目录:
- 一、函数的概述和意义
- 1、函数的概述和意义
- 二、函数的声明和调用
- 1、函数的声明语法
- 2、函数的格式
- 3、函数的调用执行
- 三、函数的参数
- 1、形式参数和实际参数
- 2、位置、关键字、默认、可变参数(万能参数)
- 3、函数的声明语法
- 四、函数的返回值
- 1、返回一个数据
- 2、返回一组数据
- 3、返回多个数据
- 五、函数和变量
- 1、函数的访问
- 2、全局变量和局部变量
- 3、可变与不可变类型作为全局变量的访问和修改
- 六、函数之间互相调用
- 七、函数的递归调用
创作不易，各位看官，点个赞收藏、关注必回关、QAQ、您的点赞是我更新的最大动力！
一、字符串介绍
1、函数的概述和意义函数描述的是生活中的一种行为，如人有吃饭的行为 在程序中声明函数，相当于生活中学习一个行为 函数声明完不会立即执行 生活中人吃饭的行为~具备，不是立即执行。 生活中通过调用行为方式执行这个行为过程 软件是解决生活中的设计问题，通过编程语言还原生活场景 生活中的行为方式，就是编程语言中的函数
函数本质上就是描述生活中的行为，在语法中封装了代码块，提高代码的复用性！
二、函数的声明和调用
1、函数的声明语法def 函数的名称([函数的参数]):
“””文档注释：描述函数的作用”””
函数中的代码
[return 函数的返回结果]一个完整的函数，主要包含这样几个部分
(1) 函数的名称：是一种标识符，遵循变量的命名规则
(2) 函数的参数
(3) 函数中的代码：以前写过的代码~ 现在出现在函数中，提高代码的复用性
(4) 函数的返回值
文档中，使用方括号表示可选[可有可无]
def：英文单词缩写-define 定义的意思;固定语法
函数的名称：标识符~变量的命名规则[下划线命名法]
函数后面的小括号：固定语法 包含参数
函数的参数：可选~参数可以有，也可以没有
函数中的代码：一行或者多行代码，放在函数中 return：函数的执行结果，可选 函数的注释：文档注释
| 注意 |
|---|
| 1.函数名称必须遵循 标识符 规则 数字，字母，下划线，并且不能以数字开头，不能 使用关键字 |
| 2.函数先定义后调用 |
| 3.函数不调用是不执行的 |
| 4.函数可以调用多次 |
| 5.函数的调用 函数名() |
"""
函数的基本语法
规范
函数声明前后 空两行
函数中要添加 文档注释
函数的名称：遵循变量的命名规则
下划线命名法 | 驼峰命名法
函数的声明：
声明后的函数不会立即执行
表示代码中~已经具备这个行为了！
"""
import os
def show_login():
"""文档注释：这个函数式展示登录菜单的"""
os.system("cls")
print(" 登录界面")
print("■"*30)
print(" 1、会员登录")
print(" 2、用户注册")
print(" 3、退出系统")
print("■"*30)
# 执行函数
show_login()
2、函数的格式
| 函数是描述生活中的行为的 生活那么多行为？怎么描述？ 生活中的行为(做一件事)一般 有四种 |
|---|
| 1、不需要资源，不需要结果 不带参数和返回值得函数 – 刷新网页 |
| 2、需要资源，不需要结果 带参数，不带返回值得函数 – 新电影信息 |
| 3、不需要资源，但是需要结果 不带参数，带返回值的函数 – 取快递 |
| 4、需要资源，需要结果 带参数，带返回值的函数 – 取快递 货到付款 |
"""
函数是描述生活中的行为的
生活那么多行为？怎么描述？
生活中的行为(做一件事)一般有四种
1、不需要资源，不需要结果
网页卡顿，刷新一下[行为]
需要我提供资源，需要给我汇报结果
2、需要资源，不需要结果
我要知道今天新电影信息
需要我提供资源：视频
需要给我汇报结果：不需要汇报
3、不需要资源，但是需要结果
老弟，帮我拿一下快递，在东门。
需要我提供资源：不需要
需要给我结果：快递！
4、 需要资源，需要结果
老弟，帮我取一下那个货到付款的快递
需要我提供资源：需要
需要给我结果：需要
"""
# ① 不需要资源，不需要结果
def flush():
print("刷新一下网页")
print("再看看是不是卡顿")
print("确认画面流畅，声音清晰")
# 调用
# flush()
# ② 需要资源，不需要结果
def get_movie(name):
print("今天上线了什么电影？")
print("电影名称是什么呀？")
print("获取到新电影名称：", name)
# 调用 需要先给函数送资源
# get_movie("《卢本伟》")
# get_movie()
# ③ 不需要资源，需要结果[返回结果，使用return返回]
def get_ssd():
print("老弟，帮我取一下快递")
return "闪迪512M SSH固态硬盘"
# 调用
r = get_ssd()
# print("得到我的快递：", r)
# ④ 需要资源，需要结果：比较~类似 input()函数
def get_keyboard(money):
print("老弟，帮我取一下机械键盘：阿米洛~花丹娘")
print("给你钱，货到付款", money)
return "阿米洛花旦娘 机械键盘"
# 调用
kb = get_keyboard(1500)
print("获取到物品：", kb)
3、函数的调用执行
| 1.函数在声明后，是不会立即执行的 |
| 2.函数必须通过函数名称，调用才能执行函数中的代码 |
| 3.多次调用函数，不同的调用过程互相独立的！不会互相影响 |
"""
函数的操作
计算器案例
什么时候需要定义函数
什么时候函数需要参数
什么时候函数需要返回结果[返回值]
当程序中需要一个重复使用的功能，定义函数
当功能在执行时需要资源，定义参数
计算器：计算数据~ 需要数据x2，需要运算符号
当执行的结果，在后续代码中需要：打印提示付款信息
计算机：总结金额~ 需要返回结果打印信息
"""
def calculation(num1, num2, opra):
"""
这是一个计算器函数
:param num1 参与运算的第一个数据
:param num2 参与运算的第二个数据
:param opra 参与运算的符号
:return 返回运算的结果
"""
result = ""
if opra == "+":
result = int(num1) + int(num2)
elif opra == "-":
result = num1 - num2
elif opra == "*":
result = num1 * num2
elif opra == "/":
result = num1 / num2
return result
# 调用执行函数
# ① 芹菜 4.5一斤，购买8斤
pay = calculation(4.5, 8, "*")
print(f"您购买的商品，总计金额：{pay}")
# ② 鸡蛋 0.4块1个，购买30块的鸡蛋
eggs = calculation(30, 0.4, "/")
print(f"您话费30块钱购买了{eggs+1}个鸡蛋")
三、函数的参数
"""
函数的参数
形式参数
实际参数
"""
def print_ticket(goods_name, count, price, pay):
"""
打印小票
:param goods_name 购买商品名称
:param count 购买的商品数量
:param price 商品单价
:param pay 商品付款金额
"""
print("~~~~~~~~~~~~~~~~~")
print(f"购买商品：{goods_name}")
print(f"购买数量：{count}")
print(f"商品单价：{price}")
print(f"应付金额：{price*count}")
print(f"实际付款：{pay}")
print(f"找零：{pay-price*count}")
print("~~~~~~~~~~~~~~~~~")
input("小票打印完成...")
# 打印购买小票
# (1) 位置参数操作
# print_ticket("利群", 2, 13, 30)
# (2) 关键字参数操作
# print_ticket(goods_name="帝豪", count=3, price=10, pay=50)
# (3) 默认值参数
def show_info(name, age, gender="male"):
"""
展示用户信息
:param name 用户姓名
:param age 用户年龄
:gender male 用户性别
"""
print(f"用户姓名: {name}")
print(f"用户年龄：{age}")
print(f"用户性别：{gender}")
# 调用执行
# show_info("jerry", 16, "female")
'''
用户姓名: jerry
用户年龄：16
用户性别：female
'''
# show_info("tom", 18)
1、形式参数与实际参数
2、位置、关键字、默认、可变参数
| 在 Python 中函数参数的定义方式有一下 4 种方式 |
|---|
| 1.位置参数 |
| 2.关键字参数 |
| 3.默认参数 |
| 4.可变参数(*args,**kwargs) |
（1）位置参数
在我们在传参的时候，实参传递的顺序按照形参定义的顺序进行传递的传参方式
（2）关键字参数
| 关键字参数的调用方式解决了两个问题： |
|---|
| ① 参数的传递，更加明确，那个数据传递给那个形式参数的 |
| ② 代码的可读性得到了提升，调用函数时明确的通过 key 知道这个 value 的作用 |
我们在传参的时候，以形参等于实参的形式忽略形参定义的顺序进行传参的传参方式。
练习：创建一个求和函数,使用关键字参数传递
注意:关键字参数和位置参数同时使用时，关键字参数必须在位置参数后面定义
位置参数不能在关键字参数后面
（3）默认参数
| 是在我们定义参数时候，我们给形参一个默认值，在我们调用函数的时候，如果不给有默认 值的形参传参，会自动采用默认值 当某个值变化小的时候，我们就可以使用默认参数 |
| 练习：创建一个保存用户信息的函数,使用默认参数传递 |
|
（4）可变参数
| Python 给我们提供了可变参数类型。能处理比当初声明时更多的参数： |
|---|
| 1、元组参数（*args） *args arguments 会将传入的参数变成元组 接受0~n个数据 |
| 2、字典参数[可变关键字参数]（**kwargs） **kwaargs key word arguments 多个 key-value 参数 会将传入的参数变成字典 |
| 3、强制关键字参数 (name,*,age) 严格的提高代码的可读性 name是一个普通位置参数 * 分割符号，后面都是关键字参数[必须] |
| 4、万能参数 (*args, **kwargs): 理论上可以接受任意格式的参数 |
（1）元组参数 (*args)
| 通过给形参前面添加*使参数变成一个元组，所有传递的参数变成元组的元素 |
| 注意： args 参数名称可以任意命名，但是一般我们叫他 args |
"""
查看学员资料
"""
u1 = {"name": "tom", "age": 17}
u2 = {"name": "jerry", "age": 15}
u3 = {"name": "shuke", "age": 18}
u4 = {"name": "beita", "age": 19}
u5 = {"name": "yihu", "age": 18}
u6 = {"name": "luqiya", "age": 16}
# (1) 借助组合数据类型
# 需求：定义一个函数，查看1,2,3,...用户的资料
def chk_information(user_lst):
"""
查看用户资料的函数
"""
for user in user_lst:
print(f"姓名：{user['name']}")
print(f"年龄：{user['age']}")
# chk_information([u1, u2])
# print("-------------------------")
# chk_information([])
# print("-------------------------")
# chk_information([u1, u2, u3, u4])
# (2) python中提供了一种新的语法：不确定个数~ 可变参数
def chk_information2(*users): # 接受0~n个数据
"""
查看用户资料的函数
"""
print(users) # 传递给函数的数据~ 类似组合数据~包装在一个元组中
for user in users:
print(f"姓名：{user['name']}")
print(f"年龄：{user['age']}")
print("################################查看完毕")
# 调用
chk_information2() # 查看0个用户
chk_information2(u1) # 查看1个用户
chk_information2(u1, u2)
chk_information2(u1, u2, u3, u4, u5)
*具有打散序列的功能
（2）字典参数 (**kwargs)
| 通过给形参前面添加**使参数变成一个字典，所有传递的参数变成字典的键值对，这里传参 要求键等于值的形式 |
| **kwargs 结果类型是字典，传递值是以 key=value 方式传入 |
"""
可变关键字参数
针对变化较大的数据
提高代码可读性
"""
def show_information(user):
"""
查看个人资料
"""
for key, value in user.items():
print(f"{key} : {value}")
print("###############查看个人资料完毕\n")
# u1 = {"name": "damu", "gender": "male"}
# show_information(u1)
# u2 = {"name": "xiaoliu", "age": 18}
# show_information(u2)
# 可变关键字参数
# 可变参数：*args arguments 多个参数
# 可变关键字参数：**kwargs key word arguments 多个key-value参数
def show_information2(**kwargs):
# 可变关键字参数，将接受到的数据包装成了一个字典
for key, value in kwargs.items():
print(f"{key} --> {value}")
print("用户资料查看完毕\n")
# 1.解决了数据变化的问题
# 2.解决了代码可读性的问题key描述具体数据value的作用
show_information2(name="大牧", gender="男")
show_information2(name="小刘", age=18)
** 具有打散字典的功能
注意事项：**kwargs 必须放在*args 后面
函数参数总结：
定义函数时参数的顺序: 位置参数，元组参数，默认参数，字典参数
（3）强制性关键字参数 (name, ,＊, age)
# 强制关键字参数：严格的提高代码的可读性
def show(name, *, age, gender, email):
"""
展示用户资料的函数
name是一个普通的位置参数
* 分隔符号，后面的都是关键字参数[必须]
"""
print(f"姓名:{name}")
print(f"年龄：{age}")
print(f"性别：{gender}")
print(f"邮箱：{email}")
# 函数的调用：形式参数*符号，后面的所有参数~必须按照key=value的方式传递
show("稳稳", age=19, gender="男", email="[email protected]")
（4）万能参数 （*args, **kwargs）
# 语义上的万能参数: 理论上可以接受任意格式的参数
def test(*args, **kwargs):
"""
测试函数
*args，接受可变参数
**kwargs，接受可变关键字参数
"""
print(args)
print(kwargs)
'''
函数的定义规范~通常先有位置参数，后面是关键字参数
'''
# 0个参数
test()
# 1个位置参数
test("name")
# 2个位置参数
test("tom", "jerry")
# 1个位置参数，1个关键字参数
test("tom", friend="jerry")
# 特殊:首先是违反了规范，万能参数不接受这样的参数
# test(name="tom", 18)
四、函数的返回值
| 所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果。调用者根据需求 利用返回值做不同的操作 |
|---|
| 1、返回单个数据 |
| 2、返回一组数据 |
| 3、返回多个数据 |
（1）返回单个数据
#1、返回单个数据
def test1():
return "Python"
a = test1()
print(a) # Python
（2）返回一组数据
#2、返回一组数据
def test2():
return ["Python","Java"]
b = test2()
print(b) # ['Python', 'Java']
（3）返回多个数据
#3、返回多个数据
def test3():
return "Python","Java","PHP"
n1,n2,n3 = test3()
print(n1,n2,n3) #Python Java PHP
| 注意 |
|---|
| 1.如果函数不写返回值，默认返回 None |
| 2.return 关键字有两个作用，一个作用是返回内容，另一个作用是结束此方法(return 后面的 代码不会执行，因此一般不建议在 return 后面写代码) |
| 3.函数中如果有两个 return, 则只会执行第一个 return |
五、函数的变量
1、函数的访问
| 函数中可以访问函数外部的变量 |
| 函数中可以访问函数内部的变量 |
| 一个函数中不能访问另一个函数中的变量 |
2、全局变量和局部变量
| 全局变量 | 公共数据 | 声明在函数外部 |
| 局部变量 | 只能在当前函数访问，外部访问不了 | 声明在函数内部 |
"""
全局变量和局部变量
函数是我家，维护你我他！
结论1：函数中可以访问函数外部的变量
函数中可以访问自己函数中的变量
"""
# (1) 变量的访问
game = "篮球场"
def girl():
"""姑娘"""
# 1.访问game
print("跳舞:", game) # 能不能访问到? ① 1
# 2. 访问函数中的变量
obj = "SK 2 神仙水"
print("补水：", obj) # 能不能访问到? ② 2
def boy():
"""男孩"""
# 1. 访问game
print("打篮球：", game) # ①
# 函数中的变量：访问当前函数的变量
com = "电脑"
print("写完项目：", com) # ②
# 访问其他函数的变量
print("那个姑娘在用什么？", obj) # ③
boy()
3、可变与不可变类型作为全局变量的访问和修改
"""
全局变量的访问
"""
# 1、不可变类型，全局变量的访问
name = "tom"
def test():
# 访问全局变量
print("访问全局变量：姓名", name)
test()
def test2():
# 修改全局变量,python提供了固定语法~引入并修改全局变量
# global 全局、全部的意思，固定语法
global name
name = "jerry"
test2()
print("修改全局变量 ", name) # jerry
# 2、可变类型，全局变量的访问
lst = list()
def lsttest():
# 访问全局变量
print("访问全局变量：", lst)
lsttest()
def lsttest2():
# 修改全局变量:可变类型~不用global依然可以修改内部的数据！
lst.extend(["LOL", "王者", "魂斗罗"])
lsttest2()
print(lst)
六、函数之间互相调用
def fun1():
fun2()
print("我是函数1")
def fun2():
fun1()
print("我是函数2")
七、函数之间递归调用
| 如果一个函数在内部调用他自己，这个函数就是递归函数。 |
| 使用递归函数的条件 |
| 1. 必须留出口 |
| 2. 自己调用自己 |
def print_num(num):
#出口
if num == 0:
return
print(num)
num = num - 1
print_num(num) # 调用自己
print("→→→→→→")
print_num(3)
# 3
# 2
# 1
# →→→→→→
# →→→→→→
# →→→→→→