{:5.5}python,python5.0是什么
Yyds干货库存
第五章函数本专栏旨在详细讲解python的基本语法，简明总结语法中的重点和难点。针对零基础和初级水平的学习者。通过本栏目的学习，他们可以熟练掌握Python编程，为后续的数据分析、机器学习和深度学习代码能力打下坚实的基础。
本文已收录于Python基础系列专栏：欢迎订阅Python基础系列教程，持续更新。
5.1函数的定义和调用
5.1.1为什么要用函数1，提高代码复用性3354来抽象它，封装成一个函数？
2.把复杂的大问题分成一系列小问题，分而治之——模块化设计的思想。
3.这有利于代码的维护和管理。
顺序公式
# 5的阶乘
n=5
res=1
对于范围(1，n ^ 1)中的I:
res *=i
打印(分辨率)
# 20的阶乘
n=20
res=1
对于范围(1，n ^ 1)中的I:
res *=i
打印(研究)120
432902008176640000抽象成函数
定义因子a(n):
res=1
对于范围(1，n ^ 1)中的I:
res *=i
返回资源
打印(factoria(5))
打印(factoria(20))120
2329020081766400005.1.2函数白盒的定义和调用：输入3354处理——输出
三要素：参数、函数体、返回值。
1.定义
定义nbsp。函数名(参数):
emsp功能体
emsp返回值
#求一个正方形的面积
定义正方形的面积(边长):
square_area=pow(length_of_side，2)
返回square_area2，调用
函数名(参数)
area=面积的平方(5)
area255.1.3参数传递0，并参与实际参数。
参数(形参):定义函数时的参数，实际上是变量名的实参(实参):调用函数时的参数，实际上是变量的值1和位置参数。
按照严格的位置顺序，将参数与实参赋值(关联)通常用于定义函数(x，y，z ),此时实参很少：
打印(x，y，z)
函数(1，2，3)# x=1；y=2；Z=31 2 3真实参与参数的个数必须是一一对应的，一个不能多，一个不能少函数(1，2)—
类型错误回溯(最近一次调用)
模块中的ipython-input-6-2a7da6ff9675
- 1个函数(1，2)
TypeError:函数()缺少1个必需的位置参数：“z”函数(1，2，3，4) -
类型错误回溯(最近一次调用)
模块中的ipython-input-8-748d3d0335e6
- 1个函数(1，2，3，4)
类型错误：函数()采用3个位置参数，但给了4个2个关键字参数
打破位置限制，名值传递(形参=实参)必须符合实参数量。一一对应多用于参数较多的情况。定义函数(x，y，z):
打印(x，y，z)
函数(y=1，z=2，x=3)# x=1；y=2；Z=33 1 2位置参数可以与关键字参数混合使用。但是，位置参数必须在关键字参数之前。Function (1，z=2，y=3) 1 3 2 function (1，2，z=3) 1 2 3不能为同一个参数重复传递值def function(x，y，z):
打印(x，y，z)
函数(1，z=2，x=3)
类型错误回溯(最近一次调用)
模块中的ipython-input-12-f385272db011
三
四
- 5函数(1，z=2，x=3)
类型错误：函数()获得了参数“x”3的多个值，默认参数
在定义阶段将值3354赋给该参数。该参数的公共值在定义阶段被分配3354。此参数的默认参数必须放在非默认参数之后。调用函数时，不能向该参数传递任何值。def register(姓名，年龄，性别=男性)在机器学习库类的方法中非常常见：
印刷体(姓名、年龄、性别)
寄存器( timer ring ，18) timer ring 18male也可以根据正常参数传递值。register (kanye ，40， female) kanye40female的默认参数应该设置为不可变类型(数字，字符串，元组)def函数(ls=[]):
打印(id(ls))
ls.append(1)
打印(id(ls))
打印(ls)
函数()1759752744328
1759752744328
[1]函数()1759752744328
1759752744328
[1，1]函数()1759752744328
1759752744328
[1，1，1]从上面可以看出，列表的地址并没有改变。每一个操作都是对原来的通讯录进行操作，内容发生了变化，就像有了记忆功能。因为默认参数被设置为list的变量类型。
定义函数(ls=Python ):
打印(id(ls))
ls=3.7
打印(id(ls))
打印(ls)
函数()1759701700656
1759754352240
python 3.7 function()1759701700656
1759754353328
python 3.7 function()1759701700656
1759754354352
Python3.7不产生“记忆功能”，每次递增后都会去一个新地址。
使参数成为可选的定义名称(名字，姓氏，中间名=无):
如果中间名：
返回名字中间名姓氏
否则：
返回名字姓氏
打印(姓名( T ， R ))
打印(名称( T ， R ，！))TR
t！R*4，变长参数emsp一个参数名
不知道会传多少个参数*args。此参数必须放在参数列表def foo(x，y，z，*args)的末尾：
打印(x，y，z)
打印(参数)
FO (1，2，3，4，5，6) #冗余参数，打包并传递给args1 2 3
(4，5，6)实参分解def foo(x，y，z，*args):
打印(x，y，z)
打印(参数)
FO (1，2，3，[4，5，6]) #列表被打包成元组并被分配给args1 2 3。
([4，5，6]，)foo(1，2，3，*[4，5，6]) # *把这些列表打散。分解的是列表、字符串、元组或集合1 2 3
(4，5，6)**5，变长参数emsp* * * *克瓦查
def foo(x，y，z，**kwargs):
打印(x，y，z)
印刷品(夸脱)
O (1，2，3，a=4，b=5，c=6) #冗余参数，以字典的形式打包，传递给kwargs1 2 3
{a: 4， b: 5， c: 6}字典参数分解def foo(x，y，z，**kwargs):
打印(x，y，z)
印刷品(夸脱)
foo(1，2，3，* * * { a :4， b: 5， c:6})1 2 3
{a: 4， b: 5， c: 6}可变长度参数的组合使用def foo(*args，**kwargs):
打印(参数)
印刷品(夸脱)
foo(1，2，3，a=4，b=5，c=6)(1，2，3)
{a: 4， b: 5， c: 6}5.1.4函数体和变量作用域函数体是一段只有在函数被调用时才会执行的代码。代码组成和其他代码没什么区别。局部变量3354仅在函数体中定义和起作用。定义多重(x，y):
z=x*y
返回z
多重(2，9)
print(z) #函数完成，局部变量Z已经释放-
NameError Traceback(最近一次调用)
模块中的ipython-input-29-9 a7 FD 4c 0a 9
五
6合1(2，9)
-7print (z) #函数完成，局部变量z已经释放。
错误：名称“z”未定义全局变量3354所有外部定义的全局变量都可以直接在函数体中使用。n=3
ls=[0]
定义多重(x，y):
z=n*x*y
最小二乘附加(z)
返回z
打印(多页打印(2，9))
ls54
[0，54]通过global在函数体中定义全局变量def multipy(x，y):
全球z
z=x*y
返回z
打印(多页打印(2，9))
打印(z)18
85.1.5返回值1。单一返回值
def foo(x):
返回x**2
res=foo(10)
Res1002，元组形式的多个返回值——
def foo(x):
1，x，x * * 2，x * * 3 #用逗号隔开，打包返回。
Print (foo (3)) (1，3，9，27) A，B，C，D=foo (3) #解包和赋值
打印(一份)
打印(b)
打印(c)
印刷(d)1
三
九
23.可以有多个return语句。一旦其中一个被执行，就代表了函数操作的结束。
定义为_假日(天):
if day in [星期日，星期六]:
返回是假日
否则：
返回非假日
打印(欢迎订阅)#将不运行
print(is_holiday(星期日))
print(is_holiday(星期一)是假日
Not holiday4，无return语句，返回值为None
def foo():
印刷品(“我是孙悟空”)
res=foo()
打印(res)我是孙悟空
建议1。函数及其参数的命名是指变量的命名。
小写字母和下划线的组合具有实际意义。2.它应该包括简要解释函数的注释，并且注释遵循函数定义。
def foo():
#此功能的目的是。
3.函数定义前后空两行。
定义f1():
及格
#空两行以示清白
定义f2():
及格
Def f3(x=3): #默认参数赋值：等号两边不需要空格。
及格
# .4.默认参数赋值等号两边不需要空格。
5.2模块化编程思想的函数式编程实例
自上而下，分而治之[问题描述]
肖丹和肖伟羽毛球都打得很好，他们的水平不相上下。肖丹稍微好一点。基本上打100个球，肖丹能赢55次，肖伟能赢45次。但是每一场大赛(一局定胜负，谁先得21分谁就赢)，肖丹赢的概率远大于卡尔文，肖伟很不服气。能通过模拟实验揭示原理【问题抽象】。
1.在肖丹Vs肖伟的二元制中，肖丹每球获胜概率为55%，肖伟每球获胜概率为45%；
2.在每场比赛中，先赢得21个进球(21分)的一方获胜；
3.假设一个独立游戏有n=10000局，肖丹会赢几局？(当n较大时，实验结果真实预期值)
[问题分解]
def main():
#主逻辑
Prob _ a，prob _ b，number _ of _ games=get _ inputs () #获取原始数据
Win _ a，win _ b=sim _ n _ games (prob _ a，prob _ b，游戏数量)#获取模拟结果
Print _ summary (win _ a，win _ b，number _ of _ games) #结果摘要和输出1。输入原始数据
定义get_inputs():
#输入原始数据
Prob_A=eval(input(请输入玩家A每球的获胜概率(0~1):))
prob_B=round(1-prob_A，2)
Number_of_games=eval(input(请输入模拟会话数(正整数):))
打印(模拟比赛总数：，比赛次数)
Print(一名球员每球的获胜概率：，prob_A)
打印( B玩家每球的获胜概率：，prob_B)
返回prob_A，prob_B，number _ of _ games emspemsp单元测试
prob_A，prob_B，number_of_games=get_inputs()
Print (prob _ a，prob _ b，number _ of _ games)请输入球员A每球的获胜概率(0 ~ 1): 0.55。
请输入模拟会话数(正整数):10000。
模拟比赛总人数：1万人
一名球员每球的获胜概率：0.55
b球员每球获胜概率：0.45
0.55 0.45 100002，多游戏仿真
def sim_n_games(prob_A，prob_B，游戏数量):
#模拟多个游戏的结果
Win _ a，win _ b=0，0 #初始化A和b的中奖次数。
对于在(游戏次数)范围内的I:#迭代游戏次数
Score _ a，score _ b=sim _ one _ game (prob _ a，prob _ b) #依次得到模拟游戏的分数。
如果分数_A分数_B:
win_A=1
否则：
win_B=1
return win_A，win _ bi随机导入
def sim_one_game(prob_A，prob_B):
#模拟比赛结果
分数A，分数B=0，0
当游戏未结束时(得分A，得分B):
if random . random()prob _ a:# random . random()产生[0，1]之间的随机小数，均匀分布
score_A=1
否则：
score_B=1
return score_A，score_Bdef game_over(score_A，score_B):
#单场模拟结束条件，一方先达到21分，游戏结束。
返回score_A==21或score _ B==21 emspemsp使用assert——断言以进行单元测试
当assert expression expression的结果为false时，触发异常assert game_over(21，8)==True。
断言game_over(9，21)==True
断言game_over(11，8)==False
assert game_over(21，8)==False -
AssertionError回溯(最近一次调用)
模块中的ipython-input-42-88b651626036
2 assert game_over(9，21)==True
3 assert game_over(11，8)==False
- 4 assert game_over(21，8)==False
assertion error:print(sim _ one _ game(0.55，0.45))
print(sim_one_game(0.7，0.3))
print(sim_one_game(0.2，0.8))(21，7)
(21, 14)
(10，21) print (sim _ n _ games (0.55，0.45，1000))(731269)3。总结并输出结果。
def print_summary(win_A，win_B，游戏数量):
#结果摘要输出
Print(总共模拟了{}场比赛。格式(游戏数量)
Print(玩家A赢了{0}局，占{1:1%} 。格式(win _ a，win _ a/游戏数量)
Print(玩家B赢了{0}局，占{1:1%} 。Format (win _ b，win _ b/number _ of _ games))print _ summary(729，271，1000)共模拟了1000场比赛。
玩家A赢了729场，占72.9%
玩家B赢了271场，占27.1%导入随机
定义get_inputs():
#输入原始数据
Prob_A=eval(input(请输入玩家A每球的获胜概率(0~1):))
prob_B=round(1-prob_A，2)
Number_of_games=eval(input(请输入模拟会话数(正整数):))
打印(模拟比赛总数：，比赛次数)
Print(一名球员每球的获胜概率：，prob_A)
打印( B玩家每球的获胜概率：，prob_B)
返回概率A，概率B，游戏次数
def game_over(score_A，score_B):
#单场模拟结束条件，一方先达到21分，游戏结束。
返回score_A==21或score_B==21
def sim_one_game(prob_A，prob_B):
#模拟比赛结果
分数A，分数B=0，0
当游戏未结束时(得分A，得分B):
if random . random()prob _ a:# random . random()产生[0，1]之间的随机小数，均匀分布
score_A=1
否则：
score_B=1
返回分数A，分数B
def sim_n_games(prob_A，prob_B，游戏数量):
#模拟多个游戏的结果
Win _ a，win _ b=0，0 #初始化A和b的中奖次数。
对于在(游戏次数)范围内的I:#迭代游戏次数
Score _ a，score _ b=sim _ one _ game (prob _ a，prob _ b) #依次得到模拟游戏的分数。
如果分数_A分数_B:
win_A=1
否则：
win_B=1
返回win_A，win_B
def print_summary(win_A，win_B，游戏数量):
#结果摘要输出
Print(总共模拟了{}场比赛。格式(游戏数量)
Print(\033[31m玩家A赢了{0}局，占{1:1%} 。格式(win _ a，win _ a/游戏数量)
Print(玩家B赢了{0}局，占{1:1%} 。格式(赢b，赢b/游戏数量)
def main():
#主逻辑
Prob _ a，prob _ b，number _ of _ games=get _ inputs () #获取原始数据
Win _ a，win _ b=sim _ n _ games (prob _ a，prob _ b，游戏数量)#获取模拟结果
Print _ summary (win _ a，win _ b，number _ of _ games) #结果摘要输出
if __name__==__main__ :
Main()请输入球员A每球的获胜概率(0 ~ 1): 0.52。
请输入模拟会话数(正整数):10000。
模拟比赛总人数：1万人
一名球员每球的获胜概率：0.52
b球员每球获胜概率：0.48
总共模拟了10000场比赛。
【31m玩家A赢了6033场，占比60.3%。
玩家B赢了3967场，占比39.7%。据统计，肖丹和肖伟在14年的职业生涯中交手40次，肖丹以28:12领先。
其中，两人一共打了100场比赛：
肖丹赢了61场，占61%；
肖伟赢了39场，占39%。
5.3匿名函数
1.基本形式
Lambda变量：函数体
2.一般用法
匿名函数最好用在参数列表中，尤其是在key=的情况下
Sort () sorted () ls=[(93，88)，(79，100)，(86，71)，(85，85)，(76，94)]
ls.sort()
Ls [(76，94)，(79，100)，(85，85)，(86，71)，(93，88)] ls.sort (key=lambda x: x [1]) #根据每个元组的第二个数据进行排序
ls[(86，71)，(85，85)，(93，88)，(76，94)，(79，100)]ls=[(93，88)，(79，100)，(86，71)，(85，85)，(76，94)]
Temp=sorted (ls，key=lambda x: x [0] x [1]，reverse=true) #获取降序排序。
temp[(93，88)，(79，100)，(85，85)，(76，94)，(86，71)]max() min()ls=[(93，88)，(79，100)，(86，71)，(85，85)，(76，94)]
n=max(ls，key=lambda x: x[1])
n(79，100)n=min(ls，key=x:x[1])
N(86，71)5.4面向过程和面向对象面向过程3354以过程为中心的编程思想，以“正在发生什么”为主要目标进行编程。emsp冷，编程
面向对象3354把现实世界的东西抽象成对象，更关注“谁受影响”，更贴近现实。ensp血肉之躯，人格化
以公交车为例“面向流程”:公交车的发车是一个事件，公交车到站是另一个事件。
编程的时候，我们关注的是一个事件，而不是车本身。
我们分别为启动和到达编写程序。
面向对象:构造对象“汽车”。
该对象包含一系列“属性”，如功率、服务时间、制造商等。
还包括加油、起步、加速、刹车、转弯、鸣笛、到站、保养等一系列“方法”。
通过对象的行为来表达相应的事件。
来自
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。