python中的函数是什么意思,python中的函数和方法的区别

　　Yyds干货库存

　　Python 1中的函数。工作回顾要求：写一个Python代码，生成一个随机的4位验证码。

　　事先：定义一个字符串。

　　1 str= 23456789 abcdefghikmnpqrstuvwxyzabcdefghjklmnpqrstuvwxyz 编写Python代码：

　　思考：如果只生成4个字符的验证码，怎么可能只从字符串中读取4次(while loop，for loop)？

　　思考：如果从str1字符串中随机读出4个字符？Random.randint()生成随机数。

　　思考：如果从字符串中提取一个字符？答：使用索引下标，str1[索引下标]

　　导入random# 1，定义一个字符串str 1= 23456789 abcdefghijkmnpqrstuvwxyzabcdefghjklmnpqrstuvwxyz code= # 2，写一个循环，对于range(4)中的I只循环4次：# 0 1 2 3 # 3，随机得到一个字符index=random.randint(0，Len(str1)-1) code=str1[index]# 4。打印4位随机验证码打印(代码)。二。Python中的函数和用法。第一步。为什么需要函数？在Python的实际开发中，我们只是出于“使我们的代码可重用”的目的而使用函数

　　该函数有两个功能：

　　模块化编程

　　代码重用

　　在编程领域，编程可以分为两类：模块化编程；面向对象编程。

　　2.什么是函数？所谓函数就是一个==名为==，==独立的代码段(一段连续的代码)==，可能会给调用它的程序一个==返回值==。

　　命名：在Python中，大多数函数都是命名函数。当然，Python中也有匿名函数。

　　执行特定功能的独立代码段：在实际的项目开发中，您必须在定义功能之前进行思考。该功能被定义为完成一个操作或一个功能。(功能的作用必须具体)

　　返回值：很多函数在执行后会通过Return关键字将一个结果返回到调用它的地方。

　　3.函数的定义基本语法：

　　Def函数名([参数1，参数2，]):函数体.【返回返回值】4。函数的调用在Python中，函数和变量一样，都是在使用前定义的。

　　# Define function def函数名([参数1，参数2，]):函数体.【返回返回值】#调用函数函数名(参数1，参数2，)5.通过一个栗子介绍功能用Python代码写一个问候程序。

　　第一步：遇到老师，打招呼打印(“你好”)。第二步：遇到老师，打招呼打印(“你好”)。第二步：遇到老师，打招呼打印(“你好”)。虽然上面的程序可以满足程序的要求，但是我们发现我们的代码做了很多重复的工作。能否进一步优化上面的代码，避免代码的重复编写。

　　升级：用Python代码写一个问候程序(函数——写一次用多次)

　　# Define函数(封装函数)def greet(): print (hello) # Call函数#遇见老师，打招呼打招呼()#遇见老师，打招呼打招呼()#遇见老师，打招呼打招呼()升级：用Python代码写一个问候程序，可以实现对不同人的不同问候。

　　#定义一个函数，定义一个参数def greet(name): print(f{name}，hello) #调用函数#认识张老师，问好问候(老张)#认识李老师，问好问候(老李)#认识王老师，问好问候(老李)

　　#用name参数定义一个函数，函数执行后有一个返回值def greet(name): #执行一系列相关操作返回name ，hello #调用函数# Say hello to print(greet(老张)#老张，hello #遇到李小姐，Say hello to print( \ 030；31;40m\t 问候(老李) \033[0m)#遇到王小姐，问好打印( \ 033[0；36;40m\t greet(老王) \033[0m )终端颜色参考：https://www.cnblogs.com/zhuminghui/p/9457185.html

　　6.谈论回报价值

　　1:如果一个函数像两个return(如下图)，程序怎么执行？

　　定义return_num():

　　返回1

　　返回2

　　result=return_num()

　　打印(结果)# 1

　　答：只执行第一个return，因为return可以退出当前函数，导致return下面的代码不被执行。

　　2:如果一个函数有多个返回值，代码怎么写？

　　答：在Python中，理论上一个函数只能返回一个结果。但是如果我们让一个函数同时返回多个结果，我们可以使用返回元组的形式。

　　定义return_num():

　　返回1，2

　　result=return_num()

　　打印(结果)

　　print(type(result))# class tuple

　　3:用两个num1和num2参数封装一个函数，求两个数的四个运算结果。

　　四则运算：加减乘除。

　　定义大小(num1，num2):

　　jia=num1 num2

　　jian=num1 - num2

　　cheng=num1 * num2

　　chu=数量1 /数量2

　　归贾、建、成、楚

　　#调用size方法

　　打印(尺寸(20，5))

　　三。Python函数中的文档

　　1、什么是文档？

　　思考：定义好函数后，程序员如何编写程序快速提示函数？

　　答：评论。

　　思考：如果代码很多，我们需要在很多代码中找到这个函数定义的位置才能看到注释吗？想更方便的看到功能怎么办？

　　答案：==功能描述文档(功能描述文档也叫功能文档描述)==

　　2.定义函数的文档。

　　定义功能的文档

　　# 1，定义菜单功能

　　定义菜单():

　　及格

　　# 2.定义添加通讯录的操作方法。

　　def add_student():

　　功能描述文档：add_student方法不需要传递任何参数，其功能是添加通讯录

　　及格

　　# 3.定义删除通讯录的操作方法。

　　def del_student():

　　及格

　　# 4.定义修改通讯录的操作方法。

　　def modify_student()。

　　及格

　　# 5.定义通讯录查询的操作方法。

　　def find_student():

　　及格

　　调用函数的文档

　　帮助(功能名称)

　　案例：调用add_student()方法

　　帮助(添加学生)

　　运行结果：

　　3.封装一个函数，生成指定长度的验证码。

　　#定义一个generate_code()函数

　　定义生成代码(编号):

　　“”generate_code方法主要用于生成指定长度的验证码。它有一个num参数，需要传递一个int类型的数值。其返回返回一个num长度为“”的随机验证码。

　　随机导入

　　#步骤1:定义字符串

　　str 1= 23456789 abcdefghijkmnpqrstuvwxyzabcdefghjklmnpqrstuvwxyz

　　#第二步：循环num次，这意味着生成一个num length的字符串。

　　代码=

　　对于范围内的I(数量):

　　#步骤3:从字符串中随机抽取num个字符

　　index=random.randint(0，len(str1) - 1)

　　code=str1[index]

　　#步骤4:使用return返回验证码

　　返回代码

　　#求助(检查generate_code的函数和需要传递的参数)

　　#帮助(生成代码)

　　#呼叫功能

　　打印(生成代码(6))

　　第四，函数的嵌套

　　1.什么是函数嵌套？

　　所谓函数嵌套调用，就是在一个函数中==调用另一个函数==

　　2.函数嵌套的基本语法

　　嵌套函数的执行过程：

　　第一步：Python代码遵循一个“顺序原则”，从上到下、从左到右逐行执行。

　　当代码执行到第一行时，在计算机内存中定义一个funcB函数。但是它的内部代码并没有真正执行，所以跳过第二行，继续往下运行。

　　第二步：转到第5行，发现声明了另一个funcA函数。根据函数的定义原理，定义是指内存中声明了这样一个函数，但是没有真正的调用和执行。

　　第三步：代码继续向下执行。第14行找到了funcA()，函数体()的意思是调用funcA函数并执行其内部代码。程序返回到第6行，然后一步一步执行，输出40小节，然后打印funcA函数的函数体部分.然后继续向下执行。遇到funcB函数时，后面有一个括号表示funcB函数的执行，原程序处于等待状态。

　　第四步：进入funcB函数，执行输出。这是funcB函数的函数体部分.代码执行完毕，返回到funcA函数中funcB()的位置，继续向下执行，打印40条。

　　最后，程序完成。

　　3、PyCharm调试技巧

　　Step over(F8):代码一步步向下执行，但是遇到函数后，不进入函数体内部，直接返回函数的最终执行结果。

　　Step into(F7):代码分步执行，但是遇到一个函数，就进入函数体内部，分步执行，直到执行完函数体中的所有代码。

　　4.通过案例描述函数嵌套。

　　百度，搜索Python语言词条

　　嵌套的funcB和funcC函数

　　在执行funcA函数的过程中，如果遇到funcB，跳转到funcB函数继续执行。当funcB完成后，会自动返回到funcA函数，继续向下运行，以此类推，直到funcA函数完成。

　　动词（verb的缩写）函数的应用案例

　　1:使用打印方法打印一条水平线。

　　打印(- * 40)

　　2:案例1升级，可以根据输入的num值生成指定数量的水平线。

　　定义打印行数(数量，长度):

　　print_lines函数主要用于生成多条指定长度的水平线。它有两个参数，num和length，都是int整数数据。num用来控制生成的水平线的数量，Length用来控制生成的水平线的长度

　　对于范围内的I(数量):

　　打印(- *长度)

　　#呼叫功能

　　#帮助(print_lines)

　　print_lines(4，40)

　　案例3:封装一个函数，求3个数的平均值。

　　def average_num(num1，num2，num3):

　　average_num函数主要用于生成三个数的平均值。有三个参数，num1、num2和num3，要求是整数或浮点数据。返回的结果是三个数字的平均值

　　sum=num1 num2 num3

　　#平均

　　返回总和/3

　　#调用average_num方法

　　# help(平均数量)

　　print(average_num(10，20，30))

　　练习：写一个带参数str1的函数，输入 1.2.3.4.5 等信息，使用函数对齐进行处理，要求最终返回结果为 5-4-3-2-1

　　定义函数(str1):

　　#方法1:翻转弦(切片)

　　str1=str1[:-1]

　　返回str1.replace( . , -)

　　#方法二：用分割来切割，然后反向翻转。

　　# list1=str1.split( . )

　　# list1.reverse()

　　#返回-。加入(列表1)

　　#调用函数实现字符串翻转和拼接

　　str1=1.2.3.4.5

　　print(func(str1)) # 5-4-3-2-1

　　不及物动词变量的范围

　　1.变量的范围是什么？

　　变量作用域是指变量的作用域(变量可用的地方和不可用的地方)，可分为局部变量和全局变量两类。

　　2.局部变量和全局变量

　　在Python中，函数外部定义的变量称为全局变量；函数内部定义的变量称为局部变量。

　　#函数外部定义的变量(全局变量)

　　num=10

　　#定义一个函数

　　定义函数():

　　#函数体代码

　　#函数内部定义的变量(局部变量)

　　i=1

　　3.可变范围的范围

　　全局变量：可以直接在整个程序范围内使用。

　　str1=你好

　　#定义一个函数

　　定义函数():

　　#在函数内部调用全局变量str1

　　Print(f 在局部范围内调用str1变量：{str1} )

　　#直接调用全局变量str1

　　Print(f 在全局范围内调用str1变量：{str1} )

　　#调用func函数

　　函数()

　　局部变量：在函数调用过程中定义，在函数运行过程中生效，在函数执行后销毁。

　　#定义一个函数

　　定义函数():

　　#在函数中定义局部变量

　　num=10

　　Print(f 在局部范围内调用num局部变量：{num} )

　　#调用func函数

　　函数()

　　#调用全局范围内的num局部变量

　　Print(f 调用全局范围内的num局部变量：{num} )

　　运行结果：

　　普及小知识：计算机的垃圾收集机制

　　4.全局关键字

　　思考：如果有一块数据要在函数A和函数B中同时使用，该怎么办？

　　答：将这些数据存储在一个全局变量中。

　　案例：如果把通讯录管理系统改成模块化编程模式(程序=函数)，会面临以下问题：

　　#定义全局变量

　　信息=[]

　　#定义funcA函数

　　def funcA():

　　#用global声明全局变量

　　全球信息

　　#向info全局变量添加数据

　　信息附加({.})

　　#定义funcB函数

　　def funcB():

　　#在全局范围内共享全局变量信息

　　对于信息中的I:

　　.

　　这就会引出一个问题：我们能在局部范围内修改全局变量吗？

　　#定义全局变量num=10

　　num=10

　　#定义函数func

　　定义函数():

　　#尝试在局部范围内修改全局变量

　　数量=20

　　#调用函数func

　　函数()

　　#尝试访问全局变量num

　　打印(数字)

　　最终结果：弹出10，所以从运行结果可以看出，理论上没有办法修改函数体内的全局变量，所以必须修改，必须使用global关键字。

　　#定义全局变量num=10

　　num=10

　　#定义函数func

　　定义函数():

　　#尝试在局部范围内修改全局变量

　　全局编号

　　数量=20

　　#调用函数func

　　函数()

　　#尝试访问全局变量num

　　打印(数字)

　　5.多个功能之间的数据共享。

　　#定义全局变量

　　信息=[]

　　# Define funcA函数：向全局变量添加信息

　　def funcA():

　　#用global声明全局变量

　　全球信息

　　#向info全局变量添加数据

　　信息附加({.})

　　# Define funcB函数：查询函数，需要在全局范围内共享通讯录信息。

　　def funcB():

　　#在全局范围内共享全局变量信息

　　对于信息中的I:

　　.

　　6.将一个函数的返回值作为另一个函数的参数。

　　def test1():

　　返回50

　　定义测试2(数量):

　　打印(数字)

　　# 1.保存函数test1的返回值

　　结果=测试1()

　　# 2.将函数返回值所在的变量作为参数传递给test2函数。

　　测试2(结果)# 50

　　七。函数的高级参数

　　1.函数的参数

　　在定义和调用函数时，我们可以根据自己的需要传递参数。在Python中，函数的参数有两种形式：形参实参。

　　==形参：定义函数时，写出来的参数叫形参==

　　==参数：调用函数时，传递的参数称为实际参数==

　　Def greet(name): # name是定义函数greet时写入的参数(parameter)。

　　返回姓名，你好

　　#呼叫功能

　　Name=老王

　　Greet(name) #调用函数时，传递的参数是实际参数。

　　注意：虽然我们喜欢在传递函数时使用与参数名相同的名字。但两者的作用范围不同。Name=老王，代表实际参数。它是一个全局变量，greet(name)函数中的名称实际上是定义函数时声明的变量，所以它实际上是一个局部变量。

　　2.函数的参数类型

　　位参量

　　理论上，当定义一个函数时，我们可以为它定义多个参数。但是，当函数被调用时，我们还应该传递多个参数，这些参数通常是相互对应的。

　　定义用户信息(姓名、年龄、地址):

　　打印(f 我叫{name}，今年{age}岁，家住{address} )

　　#呼叫功能

　　用户信息(汤姆，23，纽约)

　　注意：位置参数强调参数传递的位置必须一一对应，不能颠倒。

　　关键词(特定于Python)

　　函数调用，以“key=value”的形式指定。可以让功能更加清晰易用，同时也消除了参数的顺序要求。

　　定义用户信息(姓名、年龄、地址):

　　打印(f 我叫{name}，今年{age}岁，家住{address} )

　　#调用函数(使用关键字参数)

　　User _ info(姓名= Tom ，年龄=23岁，地址=纽约)

　　3.函数定义期间的默认参数(参数的默认值)

　　默认参数也称为默认参数，用于定义函数和提供参数的默认值。调用函数时，默认参数的值可能不会被传递(注意：所有位置参数必须出现在默认参数之前，包括函数定义和调用)。

　　User _ info(姓名、年龄、性别=男性):

　　打印(f 我叫{name}，今年{age}岁，性别{gender} )

　　用户信息(李林，25)

　　用户信息(振华，28)

　　用户信息(婉儿，18，女性)

　　记住：当我们定义默认参数时，我们必须把它们写在参数列表的最后一面。

　　4.可变长度参数

　　不定长参数也称为可变参数。它用于您不确定调用时将传递多少参数的情况(您可以不传递任何参数)。这时候用==packing location parameter==或者==packing keyword parameter==来传递参数就非常方便了。

　　包装位置参数

　　def用户信息(*参数):

　　# print(args) # tuple类型数据，需要传递参数的顺序。

　　打印(f 我叫{args[0]}，今年{args[1]}岁，住在{args[2]} )

　　#调用函数，传递参数

　　用户信息(汤姆，23，纽约)

　　包关键字参数

　　def user_info(**kwargs):

　　# print(kwargs) # dictionary类型数据，传递参数没有顺序要求，格式要求key=value value。

　　打印(f 我的名字是{kwargs[name]}，我{kwargs[age]}岁，住在{kwargs[address]} )

　　#调用函数，传递参数

　　用户信息(姓名=汤姆，地址=纽约，年龄=23岁)

　　kw=关键字参数

　　总结一下，无论是包裹位置投递还是包裹关键词投递，都是一个分组包裹的过程。

　　Python包：是将多个数据分组为元组或字典的过程。

　　八。Python解包(元组和字典)

　　1.什么是拆包？

　　Python解包：就是把元组或者字典里的数据分离出来，然后交给其他变量。

　　解包：对于一个函数中的多个返回数据，去除元组、列表或字典，直接获取里面数据的过程。

　　2.元组的解包过程

　　定义函数():

　　#通过一系列操作返回一个元组

　　返回100，200 #元组类型数据

　　#在两个变量接收元组中定义每个数组(解包)

　　num1，num2=func()

　　#打印数字1和数字2

　　打印(数字1)

　　打印(num2)

　　3.字典的拆包过程

　　记住：在解包一个字典的时候，你只能解包每个元素的键。

　　Dict1={name :晓明，年龄:18}

　　#拆包的过程(字典)

　　a，b=字典1

　　打印(一份)

　　打印(b)

　　#获取字典中的数据

　　打印(字典1[a])

　　print(字典1[b])

　　4.拆包应用案例

　　案例1:以至少3种方式交换两个变量的值

　　第一种方法是引入一个临时变量。

　　c1=10

　　c2=2

　　#引入临时变量temp

　　温度=c2

　　c2=c1

　　c1=温度

　　打印(c1，c2)

　　第二种方式：用加减法交换两个变量的值(不需要引入临时变量)

　　c1=10

　　c2=2

　　c1=c1 c2

　　c2=c1 - c2

　　c1=c1 - c2

　　打印(c1，c2)

　　第三种方法：只有Python才有的一个特性叫做解包。

　　c1=10

　　c2=2

　　c1，c2=c2，c1

　　原则：

　　步骤1:将c2和c1组成一个元组(c2，c1)

　　步骤2:使用解包特性将元组中的两个元素分别赋给c1和c2。

　　案例2:2:Python中数据传输的案例

　　def func(*args，**kwargs):

　　打印(参数)

　　印刷品(夸脱)

　　#定义一个元组(或列表)

　　元组1=(10，20，30)

　　#定义字典

　　dict1={first: 40， second: 50， third: 60}

　　#要求：将元组传递给*args参数，将字典传递给**kwargs

　　# 如果要将元组传递给*args，必须在tuple1前面加一个*号。

　　# 要想把字典传给**kwargs，必须在dict1前面加两个* *符号。

　　func(*tuple1，**dict1)

　　九。用Python函数编写通讯录系统

　　1.检查通讯录系统的最终效果。

　　2.需求分析

　　需求：进入系统显示系统功能界面，功能如下：

　　添加学生信息。

　　删除学生信息。

　　修改学生信息。

　　查询学生信息。

　　遍历所有学生信息。

　　退出系统

　　该系统有六种功能，用户可以根据自己的需要进行选择。

　　3.功能实现步骤

　　显示功能界面

　　用户输入功能序列号

　　根据用户输入的功能序列号执行不同的功能(功能)。

　　定义函数

　　调用函数

　　4.模块化编程思想。

　　模块化编程思想是最早的编程思想，强调将一个系统分解成若干个功能，每个功能就是一个模块(函数)。当所有的功能开发完成后，系统就完成了。

　　5.用Python开发通讯录管理系统

　　显示功能界面

　　提示用户输入要操作的功能号。

　　根据用户输入的序列号执行相关功能=if. 否则如果.否则。

　　如何保持程序运行，而不是选择一个函数，程序退出=while True。

　　根据用户输入的序列号完成系统中的各项功能。

　　所有函数都有使用前提：一组数据必须共享=info=[{}，{}，{}]

　　学生信息添加函数(add_student())

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。