目录:
-
一、函数的概述和意义
- 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="1095581956@qq.com")
(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
# →→→→→→
# →→→→→→
# →→→→→→