系统参数与函数说明

程序设计系统参数系统参数是指计算机系统中用来控制和配置系统行为的变量和设置。

它们对于程序设计来说至关重要，可以影响程序的运行效果和性能。

本文将从不同角度介绍几个常见的系统参数。

一、CPU核心数CPU核心数是指计算机处理器中独立的计算核心数量。

它决定了计算机的并行处理能力。

在程序设计中，合理利用多核心可以提高程序的运行效率。

例如，在多线程编程中，可以将任务分配给不同的核心同时运行，从而加快程序的执行速度。

二、内存大小内存大小指计算机系统中的随机存取存储器容量。

内存越大，可以存储的数据量越多，程序的运行速度也会相应提升。

在程序设计中，合理利用内存可以减少磁盘读写操作，提高程序的响应速度。

例如，可以将频繁访问的数据存储在内存中，而不是每次都从磁盘读取。

三、磁盘空间磁盘空间是指计算机硬盘上可供存储数据的空间大小。

磁盘空间的大小决定了程序可以存储的数据量。

在程序设计中，需要合理管理磁盘空间，以避免因空间不足而导致程序崩溃或运行缓慢。

例如，可以定期清理无用的文件，或者使用压缩算法减少数据占用的空间。

四、网络带宽网络带宽是指计算机系统与外部网络通信的速率。

网络带宽的大小决定了程序与外部系统通信的效率。

在程序设计中，需要考虑网络带宽的限制，避免因网络传输速度慢而导致程序延迟。

例如，可以使用数据压缩算法减少网络传输的数据量，或者使用多线程异步操作提高网络通信效率。

五、操作系统类型操作系统类型指计算机系统所使用的操作系统。

不同的操作系统有不同的特点和限制，对程序的运行有一定的影响。

在程序设计中，需要考虑不同操作系统的兼容性，避免使用特定于某个操作系统的功能。

可以使用跨平台的开发工具和技术，确保程序在不同操作系统上都能正常运行。

六、编程语言版本编程语言版本指程序设计所使用的编程语言的版本。

不同版本的编程语言可能有不同的语法和功能特性，对程序的开发和运行有一定的影响。

在程序设计中，需要考虑编程语言版本的兼容性，避免使用不支持或已经废弃的语法特性。

2.1 系统函数ActiveApp语法 ActiveApp(AppID)。

说明把AppID所指定的程序所在的窗口置到前面，并且该窗口将获得输入焦点，即该窗口将接收键盘输入。

参数 AppID为应用程序标识，类型为整型，为由StartApp函数得到的返回值。

示例 ActiveApp(AppID)AlmAck语法AlmAck()说明当前最新报警确认,当前最新报警显示在系统报警窗右侧。

要显示系统报警。

窗，首先要选中系统参数中系统报警检查框。

示例AlmAck()AlmAckAll语法AlmAckAll(DataSourceNo, AreaNo)。

说明对数据库中某一区域报警进行确认。

DataSourceNo 数据源序号，序号从0开始。

AreaNo指定区域号,-1表示所有区域。

示例AlmAckAll(0,-1)//对整个数据库报警进行确认。

AlmLogTimeSet语法AlmLogTimeSet (StartTime)说明报警历史记录或历史报表开始时间设置。

参数StartTime: 报警历史记录或历史报表开始时间，类型为数值型常量、变量或数值型表达式。

该数值为自1970年1月1日零时逝去的秒数。

示例#almlog.AlmLogTimeSet ($CurTime - 7200)；// 报警历史记录开始时间设为前2小时。

//almlog为报警历史记录对象名称。

#almlog.AlmLogTimeSet (LongTime(“2002/1/8 16:50:00”));提示：开始时间可以通过时间控件得到。

Beep语法beep(number)说明蜂鸣器发出叫声。

参数参数number用于指定不同的蜂鸣器响声。

-1,0:为两种报警声。

1～7对应乐谱的中音1至7。

8～14对应乐谱的高音1至7。

示例beep(-1)；//标准报警声。

ChangeGroup语法ChangeGroup（GroupNumber）说明该函数用于实时趋势、历史趋势模板中的变量成组替换，替换量一般为数据库变量。

system()函数参数系统函数是一种内置函数，用于操作系统和程序之间的通信。

在C和C++编程中，system()函数非常常见，可以执行操作系统命令或其他程序，而不必使用其他API和库函数。

system()函数允许程序员在程序中调用外部程序或操作系统命令。

此函数用于调用命令行（控制台）中使用的操作系统命令，并获得命令的输出，以供程序使用。

在 Unix/Linux 操作系统中，这是使用shell 命令的主要方法。

这个函数需要一个字符串参数，该字符串包含要执行的操作系统命令。

这个单个字符串包含所有在命令行上执行的标准命令。

即，该字符串应该是在shell终端上运行的命令。

字符串必须使用双引号括起来。

下面是使用system()函数来调用操作系统命令的示例：```c#include <stdlib.h>#include <stdio.h>int main(void){system("ls");return 0;}```上面的程序使用system()函数调用了“ls”命令，该命令会列出当前目录中的所有文件和文件夹。

系统函数参数system()函数参数可以是任何可以在shell终端上执行的命令，例如：1. 打印文本```csystem("echo 'Hello, world!'"); //输出：Hello, world!```在上面的示例中，使用echo命令打印了"Hello, world!"。

2. 创建文件夹```csystem("mkdir FolderName");```在上面的示例中，使用mkdir命令创建了一个名为FolderName 的文件夹。

3. 创建或删除文件```csystem("touch FileName"); // 创建一个空文件system("rm FileName"); // 删除一个文件```在上面的示例中，使用touch命令创建了一个名为FileName的文件，使用rm命令删除了该文件。

系统参数的名词解释引言：在计算机科学和信息技术领域中，系统参数是一个广泛使用的概念。

它们对于系统的性能、配置和行为都起着重要的作用。

本文将对一些常见的系统参数进行解释和探讨，以帮助读者更好地理解和运用这些概念。

一、操作系统参数在操作系统中，有许多和系统功能、性能相关的参数。

比如，CPU的核心数量、内存容量、虚拟内存大小等。

1. CPU核心数量：是指计算机处理器中物理核心的数量。

核心数越多，计算机的运算能力越强大，可以同时处理更多的任务。

2. 内存容量：指计算机中物理内存的大小。

较大的内存容量可以提高系统对并发任务的处理能力和响应速度，减少交换空间的使用。

3. 虚拟内存：虚拟内存是操作系统在物理内存不足时，将部分数据和程序存储在硬盘上的一种机制。

虚拟内存的大小可以影响系统运行的稳定性和性能。

二、网络参数网络参数是指与网络连接和通信相关的一些设置和选项。

1. IP地址：IP地址是用于唯一标识网络设备的一组数字，它包含网络ID和主机ID。

通过IP地址，计算机可以在网络中进行通信。

2. 子网掩码：子网掩码用于将IP地址划分为网络ID和主机ID。

它决定了网络地址的范围和主机地址的范围。

3. 网关：网关是一个网络节点，为数据包提供路由转发功能，使不同网络之间可以相互通信。

三、数据库参数数据库参数是用于配置和优化数据库性能的设置。

1. 缓冲区大小：缓冲区是数据库用于读写数据的内存区域。

适当增加缓冲区大小可以提高数据库的读写性能。

2. 日志文件大小：日志文件用于记录数据库的操作和变更历史。

适当调整日志文件的大小可以平衡数据库的性能和存储开销。

3. 并发连接数：并发连接数是指数据库可以同时处理的并发连接数量。

适当增加并发连接数可以提高数据库的并发处理能力。

四、系统性能参数系统性能参数是用于配置和优化系统性能的一些设置。

1. 系统负载：系统负载是指系统正在运行和等待处理的任务数量。

合理监控和控制系统负载可以保持系统的稳定和高性能运行。

C语言中的函数与参数传递原理解析C语言是一种广泛应用于系统编程和嵌入式开发的编程语言，函数是其基本的组成部分之一。

在C语言中，函数的定义和参数传递机制对于程序的正确性和效率都具有重要意义。

本文将对C语言中的函数与参数传递原理进行解析。

一、函数的定义和调用在C语言中，函数的定义通常包括函数类型、函数名、函数参数和函数体。

函数类型可以是void（无返回值）或其他基本数据类型，函数名用于唯一标识一个函数，函数参数用于传递数据给函数，函数体则是实现具体功能的代码段。

函数的调用是通过函数名和参数列表来实现的。

当程序执行到函数调用语句时，会跳转到对应函数体的执行位置，执行完函数体后再返回到调用处继续执行。

二、参数传递的方式在C语言中，参数传递可以通过值传递、指针传递和引用传递三种方式来实现。

下面将逐一介绍这三种方式的原理和特点。

1. 值传递值传递是指将实参的值复制给形参，在函数内部对形参的操作不会影响到实参。

这是因为在函数调用时，实参的值会被保存到另一块内存空间中，即栈中的活动记录（activation record）中。

例如，下面的代码演示了值传递的过程：```c#include <stdio.h>void changeValue(int n) {n = 10;}int main() {int num = 5;printf("Before function call: %d\n", num); changeValue(num);printf("After function call: %d\n", num); return 0;}```输出结果为：```Before function call: 5After function call: 5```从输出结果可以看出，虽然在函数内部将形参n的值修改为10，但对实参num的值并没有产生影响。

2. 指针传递指针传递是指将实参的地址传递给形参，形参可以通过指针间接操作实参的值。

excel的函数及其参数概念-回复Excel的函数及其参数概念Excel是一款功能强大的电子表格软件，广泛应用于数据分析、财务规划、商业建模等领域。

Excel的函数是其最为重要的特性之一，可以用于执行各种计算和操作，从而使用户轻松处理和分析大量数据。

本文将详细介绍Excel的函数及其参数的概念，让我们一步一步来了解。

一、Excel函数概述1. 什么是函数？函数是Excel中用于执行特定任务的预定义公式。

它接受一个或多个参数，并返回一个结果。

函数可以执行各种计算，例如求和、平均值、最大值、最小值、统计分析等。

通过使用函数，用户可以快速执行常见的计算和操作，提高工作效率。

2. Excel中的函数分类Excel中的函数按照功能可以分为数学与三角函数、统计函数、文本函数、日期与时间函数、逻辑函数、查找与引用函数、信息函数、工程函数、数据库函数等多个类别。

每个类别下都有许多特定的函数供用户使用。

二、Excel函数的语法结构1. 函数的命名规则Excel的函数名称必须以英文字母开头，并且只能包含英文字母、数字和下划线，不区分大小写。

函数名称后面必须跟随一对括号“()”。

2. 函数的参数每个函数可以接受一个或多个参数，参数之间使用英文逗号分隔。

参数可以是单元格引用、数值、文本、逻辑值或其他函数的结果。

函数根据参数的类型和顺序进行计算，并返回一个结果。

三、Excel函数的常用参数类型1. 单元格引用Excel中的函数可以通过引用单元格的方式使用参数。

参数可以是单个单元格、多个单元格的区域或整个列、行的引用。

例如，SUM(A1:A5)表示求A1到A5单元格的和。

2. 数值函数中可以直接使用数值作为参数。

数值可以是整数、小数或科学计数法表示的数字。

例如，AVERAGE(1, 2, 3)表示求1、2、3这三个数字的平均值。

3. 文本函数中的文本参数必须用引号括起来。

文本可以是字母、数字、符号等字符组成的字符串。

例如，LEFT("Excel", 2)表示返回字符串"Excel"的前两个字符。

系统函数●Abs【函数名称】取绝对值【函数格式】Abs(X)【返回】数据【参数】序号名称类型说明1 X 数据被处理的数据【使用范例】表达式：abs(5)返回：5表达式：abs(-20.4)返回：20.4●Chr【函数名称】字符内码转成字符【函数格式】Chr(X)【返回】字符【参数】序号名称类型说明1 X 数据被转换的字符内码【备注】字符内码必须为小于等于128的整数【使用范例】表达式：Chr(65)返回：A表达式：Chr(97)返回：a表达式：Chr(60)返回：<●ComputerName【函数名称】机器名称【函数格式】ComputerName【返回】字符【参数】<无>【使用范例】若当前使用的机器名为‘Server1’，表达式：ComputerName返回：Server1●CurCwEndDay【函数名称】当前财务终止日期【函数格式】CurCwEndDay【返回】日期【参数】<无>【使用范例】若当前财务终止日期为2004年2月13日，表达式：CurCwEndDay返回：2004-2-13●CurCwMonth【函数名称】当前财务月份【函数格式】CurCwMonth【返回】数据【参数】<无>【使用范例】若当前财务月份为2月，表达式：CurCwMonth返回：2●CurCwStartDay【函数名称】当前财务起始日期【函数格式】CurCwStartDay【返回】日期【参数】<无>【使用范例】若当前财务起始日期为2004年2月1日，表达式：CurCwStartDay返回：2004-2-1●CurCwYear【函数名称】当前财务年份【函数格式】CurCwYear【返回】数据【参数】<无>【使用范例】若当前财务年份为2004年，表达式：CurCwYear返回：2004●CurCxCount【函数名称】查询当前记录号【函数格式】CurCxCount【返回】数据【参数】<无>【使用范例】若取第二条记录，表达式：CurCxCount返回：2●CxIAvg【函数名称】查询处理中某列平均【函数格式】CxIAvg(TableFieldName)【返回】数据【参数】序号名称类型说明1 TableFieldName字符被处理的列【使用范例】则该列的平均值为表达式：CxIAvg(‘被查询单据.定单总数量’) 返回：1093.75●CxICount【函数名称】查询处理中某列当前行数【函数格式】CxICount(TableFieldName)【返回】数据【参数】序号名称类型说明1 TableFieldName字符被处理的列【使用范例】在“按销售员未结定单报表”查询处理中，“定单总数量”列的值如下表所示：则该列当前行数为表达式：CxICount(‘被查询单据.定单总数量’) 返回：8●CxIMax【函数名称】查询处理中某列之最大值【函数格式】CxIMax(TableFieldName)【返回】数据【参数】序号名称类型说明1 TableFieldName字符被处理的列【使用范例】在“按销售员未结定单报表”查询处理中，“定单总数量”列的值如下表所示：则该列的最大值为表达式：CxIMax(‘被查询单据.定单总数量’) 返回：4800●CxIMin【函数名称】查询处理中某列之最小值【函数格式】CxIMin(TableFieldName)【返回】数据【参数】序号名称类型说明1 TableFieldName字符被处理的列【使用范例】则该列的最大值为表达式：CxIMin(‘被查询单据.定单总数量’) 返回：130●CxISum【函数名称】查询处理中某列之和【函数格式】CxISum(TableFieldName)【返回】数据【参数】序号名称类型说明1 TableFieldName字符被处理的列【使用范例】在“按销售员的未结销售定单报表”查询处理中，“定单总数量”列的值如下表所则该列的和为表达式：CxISum(‘被查询单据.定单总数量’) 返回：8750●CxSum【函数名称】查询某列之和【函数格式】CxSum(TableFieldName)【返回】数据【参数】序号名称类型说明1 TableFieldName字符被处理的列【使用范例】在“按销售员的未结销售定单报表”查询处理中，“定单总数量”列的值如下表所表达式：CxSum(‘被查询单据.定单总数量’) 返回：8750●DataMax【函数名称】取两数据之大者【函数格式】DataMax(X,X)【返回】数据【参数】序号名称类型说明1 X数据被处理的数据2 X数据被处理的数据【使用范例】表达式：DataMax(10,20) 返回：20●DataMin【函数名称】取两数据之小者【函数格式】DataMix(X,X)【返回】数据【参数】序号名称类型说明1 X数据被处理的数据2 X数据被处理的数据【使用范例】表达式：DataMin(10,20) 返回：10●DataToStr【函数名称】数据->字符串【函数格式】DataToStr(CurData)【返回】字符【参数】序号名称类型说明1 CurData数据被用来转换的数据【使用范例】表达式：DataToStr(78.9) 返回：’78.9’表达式：DataToStr(90) 返回：’90’●Date【函数名称】现在时间【函数格式】Date【返回】日期【参数】<无>【使用范例】若现在是2004年2月12日，表达式：Date返回：2004-2-12●DateEncord【函数名称】日期运算【函数格式】DateEncord(VDate,VYear,VMonth,VDay)【返回】日期【参数】序号名称类型说明1 VDate日期被运算的日期2 VYear数据用来加的年数3 VMonth数据用来加的月数4 VDay数据用来加的天数【使用范例】表达式：DateEncord([2004-2-12]，2，1，10) 返回：2006-3-22表达式：DateEncord([2004-2-12]，-2，-1，-10) 返回：2002-1-2●Dateminus【函数名称】日期差【函数格式】Dateminus(CurDate, CurDate)【返回】数据【参数】日期,日期序号名称类型说明1 CurDate日期被用来转换的日期2 CurDate日期被用来转换的日期【使用范例】表达式：Dateminus ([2006-12-12], [2006-12-18]) 返回：6●DateTime【函数名称】现在日期时间【函数格式】DateTime【返回】日期【参数】<无>【使用范例】若现在是2004年2月12日15:38:33表达式：DateTime返回：2004-2-12 15:38:33●DateTimeToStr【函数名称】日时->字符串【函数格式】DateTimeToStr(CurDatetime)【返回】字符【参数】序号名称类型说明1 CurDatetime日期被用来转换的日时【使用范例】表达式：DateTimeToStr([2004-2-12 15:38:33]) 返回：’2004-2-12 15:38:33’●DateToStr【函数名称】日期->字符串【函数格式】DateToStr(CurDate)【返回】字符【参数】序号名称类型说明1 CurDate日期被用来转换的日期【使用范例】表达式：DateToStr(2004-2-13) 返回：’2004-2-13’表达式：DateToStr(now) 返回：’2004-2-13’注：now是当前的日期，假设为2004-2-13●DayofWeek【函数名称】星期中的第几天【函数格式】DayofWeek(XmDate)【返回】数据【参数】序号名称类型说明1 XmDate日期被用来处理的日期【备注】星期天是一个星期中的第一天星期六是一个星期中的最后一天（第七天）【使用范例】表达式：DayofWeek(2004-2-13) 返回：6●DayofWeekC【函数名称】星期几（中文）【函数格式】DayofWeekC(XmDate)【返回】字符【参数】序号名称类型说明1 XmDate日期被用来处理的日期【使用范例】表达式：DayofWeek(2004-2-13) 返回：星期五●DayofWeekE【函数名称】星期几（English）【函数格式】DayofWeekE(XmDate)【返回】字符【参数】序号名称类型说明1 XmDate日期被用来处理的日期【使用范例】表达式：DayofWeek(2004-2-13) 返回：Friday●Div【函数名称】整除【函数格式】Div(X,X)【返回】数据【参数】序号名称类型说明1 X数据被除整数2 X数据除整数【使用范例】表达式：Div(20,10) 返回：2表达式：Div(20,3) 返回：6●DjIAvg【函数名称】单据内某列符合条件之平均值【函数格式】DjIAvg(TableFieldName,Condition)【返回】数据【参数】序号名称类型说明1 TableFieldName字符单据列名2 Condition字符取值条件【使用范例】表达式：DjIAvg(‘单据1.数量’，‘单据1.编号=‘‘100’’’)返回：360●DjICount【函数名称】单据内某列符合条件之行数【函数格式】DjICount(TableFieldName,Condition) 【返回】数据【参数】序号名称类型说明1 TableFieldName字符单据列名2 Condition字符取值条件【使用范例】表达式：DjICount(‘单据1.编号’，‘单据1.名称=‘‘AA’’’)返回：3注：单据1.编号为数据型字段。

薪酬常用函数说明➢itemvalue_abs_period()系统函数说明：1、函数描述：返回某个薪酬方案在某个薪资期间的某个薪酬项目的值；2、参数描述：参数1、薪资期间：可选当前HR组织的所有薪资期间；参数2、薪酬方案：可选当前HR组织所有未删除，已启用状态的方案；参数3、薪酬项目：可选当前HR组织下已启用的除了内置人事项目之外的所有薪酬项目；参数4、次数类型：分当绝对次数和相对次数（绝对次数用abs_time表示；相对次数用rel_time表示）；参数5、开始次数；参数6、结束次数；注：次数是非必填项，不选任何次数，表示该期间所有次数的合计；3、函数格式：通过函数向导界面进行参数设置，函数设置结果格式为：itemvalue_abs_period("薪资期间编码", "薪酬方案编码", "薪酬项目编码","次数类型","开始次数","结束次数")4、举例：某公司有两个薪酬方案，“奖金方案”(002)中的依赖项目“应发工资”，需要取”工资方案”(001)的2006年12月的“应发工资”(FSAL004)项目的值：应发工资= itemvalue_abs_period("200612", "001", "FSAL004","","","")➢itemvalue_rel_period()系统函数说明：1、函数描述：返回某个薪酬方案在某个固定间隔薪资期间的某个薪酬项目的值；2、参数描述：参数1、薪资期间：和当前薪酬方案的薪资期间的间隔值，只支持整数；负数表示早几个期间，0表示同一期间，正数表示晚几个期间；参数2、薪酬方案：可选当前HR组织所有未删除，已启用状态的方案；参数3、薪酬项目：可选当前HR组织下已启用的除了内置人事项目之外的所有薪酬项目；参数4、次数类型：分当绝对次数和相对次数（绝对次数用abs_time表示；相对次数用rel_time表示）；参数5、开始次数：当为相对次数时，以当前方案的当前次数为准；0表示等于当前次数，负数表示从当前次数之前几次开始；整数表示当前次数后几次开始；参数6、结束次数；当为相对次数时，以当前方案的当前次数为准；0表示等于当前次数，负数表示从当前次数之前几次结束；整数表示当前次数后几次结束；注：次数是非必填项，不选任何次数，表示该期间所有次数的合计；选择了次数，表示取所选次数之间的所有数据合计；3、函数格式：通过函数向导界面进行参数设置，函数设置结果格式为：itemvalue_rel_period("薪资期间间隔值", "薪酬方案编码", "薪酬项目编码","次数类型","开始次数","结束次数")4、举例：某公司的”工资方案”(001)，本月扣上月的税，即当月的所得税基数，始终取前一个月的应发合计(FSAL004)：所得税基数= itemvalue_rel_period("-1", "001", "FSAL004","","","")➢person_age()系统函数说明：1、函数描述：返回职员的某个人事项目（工龄或者年限）的年数值；2、参数描述：参数1、人事项目3、函数格式：通过函数向导界面进行参数设置，函数设置结果格式为：person_age("人事项目编码")4、举例：某公司根据”集团服务年限”(FPER015)对应的年数，每年500元，计算集团服务奖金：集团服务奖金= person_age("FPER015")*500➢get_adjust_age ()系统函数说明：1、函数描述：返回一个以年为单位的实数，参数之间的计算关系是：年限=（被减数日期- 减数日期）- 调整时间;2、参数描述：参数1、被减数日期；参数2、减数日期；参数3、调整值；3、函数格式：通过函数向导界面进行参数设置，函数设置结果格式为：get_adjust_age("被减数日期","减数日期","调整时间")4、举例：某公司的公司工龄＝当前时间－入司时间－加入公司调整时间，（加入公司调整时间为员工中途离职再入职，不在公司的时间），工龄工资为每年50元，计算工龄工资：工龄工资= get_adjust_age("当前日期","加入公司日期","加入公司调整时间")*50➢get_period_compare_year()系统函数说明：1、函数描述：返回当前薪资期间内的指定日期与所选人事项目日期比较后的整年数值；2、参数描述：参数1、人事项目：支持所有内置日期项目；参数2、日期：1至31之间的正整数，当前薪酬方案的薪资期间中的某日历日，如”15”日或者”30”日等；3、函数格式：通过函数向导界面进行参数设置，函数设置结果格式为：get_period_compare_year(人事项目编码,日期)4、举例：某公司根据员工的”参加工作日期”(FPER028)，与当前薪酬方案的薪资期间的年、月的”15”日这个时间点作比较，每满一年50元，计算员工的工龄工资：工龄＝get_period_compare_year("FPER028","15")工龄工资＝工龄*50➢get_period_ year()系统函数说明：1、函数描述：返回当前薪酬方案的薪资期间的年份；2、参数描述：无参数；3、函数格式：双击进入公式编辑框即可，函数设置结果格式为：get_period_year ()4、举例：某公司根据从2000年至今一共多少年，每年1000元，来计算员工福利费：福利费= ( get_period_year() - 2000) * 1000➢get_period_ month()系统函数说明：1、函数描述：返回当前薪酬方案的薪资期间的月份；2、参数描述：无参数；3、函数格式：双击进入公式编辑框即可，函数设置结果格式为：get_period_month()4、举例：根据当前薪酬方案的薪资期间的月份是否大于等于10月，判断是否发放取暖费：如果( get_period_month() >=10 ) {取暖费= 1000} 否则{取暖费=0}➢get_pref_ result()系统函数说明：1、函数描述：返回指定评估活动的绩效考核成绩（针对已完成状态的评估活动中已审核的绩效数据）；2、参数描述：参数1、活动类型：目标绩效考核:0 ；360度绩效考核:1；综合绩效考核:2 ；汇总方案活动:3；参数2、评估活动：可选绩效系统中已完成状态的评估活动的名称，返回评估活动系统ID；参数3、绩效结果类型：评估总分:0 ，修订总分:1 ，绩效等级:2 ；3、函数格式：通过函数向导界面进行参数设置，函数设置结果格式为：get_perf_result("活动类型值","评估活动ID","绩效结果类型值")4、举例：根据”360度绩效考核”的”评估活动”(活动1)的”修订总分”计算绩效工资为get_perf_result("1","CN2YRAEPEADgAK2zCgrIEr8uN9k=","1")如果(360度绩效考核修订总分>=80) {绩效工资=5000} 否则{绩效工资= 4000}注意：get_perf_result函数，其中“目标考核“的评估活动调用HR权限范围控制隔离的F7，其余评估活动调用用户行政组织范围与委托的HR交集的权限范围控制隔离的F7。

函数简介及函数参数介绍函数的基本定义 什么是函数？ 函数就是具有某个具体功能的⼯具 为什么要⽤函数？ 提⾼开发效率 减少代码冗余 提⾼程序的扩展性 如何定义⼀个函数？ def是定义函数的关键字 函数名：函数名的命名规则与变量名⼀致 1.不能以关键字命名 2.函数也应该做到见名知意 函数在定义的时候只检测函数体内的语法，不执⾏函数体代码def func()print('hello') 调⽤函数的固定格式： 函数名+括号 #func() 函数名只要遇到括号会⽴即执⾏函数体代码 代码中遇到函数名加括号，优先级最⾼ 先去执⾏函数，再看下⾯的代码函数的返回值函数内要想返回给调⽤者值，必须⽤关键字return 1.不写return 2.只写return 3.写return None 4.写return返回⼀个值 5.写return返回多个值不写return：函数默认返回Nonedef func():print('hahaha')res = func()print(res)只写return：return除了可以返回值之外还可以直接结束整个函数的运⾏只写return 返回的也是None(None就表⽰什么都没有)def func():l = ['zhangsan','lisi','wangwu']while True:for i in l:if i == 'lisi': # 当i为lisi的时候直接结束函数运⾏breakreturnprint('asdasdkljlsjadl') # 这⼀⾏代码拥有都不会运⾏print(i)res = func()print(res)写return None:跟上⾯的只写return是⼀样的def func():return Noneres = func()print(res)写return返回⼀个值:这个值可以是python任意数据类型def func():return'123'def func1():return [1,2,3]def func2():return {'name':'zhangsan'}def func3():return (1,)def func4():return {1,2,3,4,5}def func5():return Trueprint(func(),func1(),func2(),func3(),func4(),func5())写return返回多个值:return会⾃动将多个值以元组的形式返回给调⽤者def func():return1,2,3,4 # 返回的是(1, 2, 3, 4)res = func()print(res)def func1():return'a','b','c' # ('a', 'b', 'c')res = func1()print(res)def func2():return [1,2,3],[1,2,3],[1,2,3] # ([1, 2, 3], [1, 2, 3], [1, 2, 3])res1 = func2()print(res1)def func3():return {'name':'zhangsan'},{'username':'lisi'},{'user_name':'wangwu'} # ({'name': 'zhangsan'}, {'username': 'lisi'}, {'user_name': 'wangwu'})res2 = func3()print(res2) 函数返回的结果全部都是元组类型，因为函数不希望⾃⼰处理的结果被修改，那么应该如何返回⼀个⾮元组的结果呢？def func4():return [[1,2,3,4],[1,2,3,4],[1,2,34]]res = func4()print(res)# 把所有的结果当成⼀个结果返回，写成什么样的类型就返回什么样的类型注意： 1.所有的函数都有返回值,⽆论你写不写return python中所有的函数都有返回值不写的情况下默认返回None 2.光写return 或者return None并不是为了考虑返回值⽽是为了结束函数的运⾏函数参数的介绍函数参数的两⼤类型 形参：在函数的定义阶段括号内写的变量名，叫做该函数的形式参数，简称形参 实参：在函数的调⽤阶段，括号内实际传⼊的值，叫做实际参数，简称实参形参和实参的关系 形参就相当于变量名,⽽实参就相当于变量的值 函数调⽤传参的过程就是给形参变量名赋值的过程 注意：形参和实参的绑定关系只在函数的调⽤阶段有效,函数运⾏结束关系⾃动解除，只在函数内部有效，函数外部⽆任何影响函数的简易结构 def 函数名(形参1，形参2，形参3.....): '''函数的注释，⽤来描述该函数的作⽤依旧各个形参的类型''' 函数体代码1 函数体代码2 .... return 函数的返回值位置参数 定义：在函数定义阶段按照位置从左往右依次书写的变量名叫做函数位置形参 位置形参在调⽤的时候必须为其传值求两个数的⼤⼩返回⼤的那个（⽰例）def my_max(x,y):print(x,y)if x > y:return xelse:return yres = my_max(1) #在调⽤函数的时候少⼀个实参不⾏(位置实参)res = my_max(1,2,3) #在调⽤函数的时候多⼀个实参也不⾏（位置实参）res = my_max(20,10) #在函数调⽤的时候传⼊和形参⼀⼀对应的参数（位置实参）res = my_max(y=20,x=10) #在函数调⽤的时候，使⽤关键字传参res = my_max(10,y=20) #位置参数和关键字参数混合使⽤，需要注意的是位置参数必须在前print(res)有上⾯的代码可以得出：位置实参在函数的调⽤阶段，传⼊的参数会按照位置⼀⼀对应给形参，⽽关键字参数则是依对函数形参的名称传的但是必须保证： 1.位置参数必须在关键字参数的前⾯(越短的越靠前,越长的越复杂的越靠后) 2.同⼀个形参不能被多次赋值默认值参数定义：在函数的定义阶段，形参（变量名）就已经被赋值了那么，在调⽤的时候可以不为默认值形参传值,默认使⽤定义阶段就已经绑定的值在调⽤的时候如果可以给默认值形参传值传了那么就使⽤你传的值在定义阶段默认值形参必须放在位置形参的后⾯⽰例：def my_max(x,y=100):if x > y:return xreturn yres = my_max(200) # 只给x传⼀个值为200res1 = my_max(200,1000) #给x传⼀个值为200，给y传⼀个值为1000（位置实参）res2 = my_max(y=200,x=1000) #给x传⼀个值为200，给y传⼀个值为1000（关键字实参）print(res2)def register(username,age,gender='male'): #默认值为maleprint(username,age,gender)register('zhangsan',18)register('lisi',28)register('wangwu',84)register('maliu',58)register('xiaohong',17,'female') #如果为gender传了参数，则⽤⾃⼰传的参数迷⼈⼩⽰例⼀（猜结果）def info(username,hobby,l=[]):l.append(hobby)print('%s 的爱好是 %s'%(username,l))info('zhangsan','学习')info('lisi','⽣蚝')info('wangwu','跑步')info('maliu','打拳')答案zhangsan 的爱好是 ['学习']lisi 的爱好是 ['学习', '⽣蚝']wangwu 的爱好是 ['学习', '⽣蚝', '跑步']maliu 的爱好是 ['学习', '⽣蚝', '跑步', '打拳']View Code这时我们获取的结果是错误的，有两种解决办法第⼀种：def info(username,hobby,l=[]):l.append(hobby)print('%s 的爱好是 %s'%(username,l))info('zhangsan','学习',[])info('lisi','⽣蚝',[])info('wangwu','跑步',[])info('maliu','打拳',[])View Code第⼆种：def info(username,hobby,l=None):if l==None:l=[]l.append(hobby)print('%s 的爱好是 %s'%(username,l))info('zhangsan','学习')info('lisi','⽣蚝')info('wangwu','跑步')info('maliu','打拳')View Code迷⼈⼩⽰例⼆：m = 100def my_max(x,y=m):print(x,y)m = 222my_max(111)答案111100View Code⼩总结：函数在定义阶段内部所使⽤的变量都已经初始化完毕了，不会因为调⽤的位置的变化⽽影响到内部的值函数⽆论在什么地⽅被调⽤，都会跑到函数定义阶段去执⾏代码，形参中⽤到的值都是往函数定义阶段代码往上找可变长参数站在调⽤函数传递实参的⾓度，实参的个数不固定的情况，也就意味形参也不固定站在形参的⾓度可以⽤*和**来接收多余的(溢出的)位置参数和关键字参数站在形参的⾓度看 *形参中的*会将多余的(溢出的)位置实参统⼀⽤元组的形式处理传递给*后⾯的形参名def func(x,y,*z):print(x,y,z) # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)#多余的实参会⽤元组去接收站在实参的⾓度看 *# 如果要传⼊⼀个列表，可以⽤*打散列表去传值def func(x,y,z):print(x,y,z)l = [1,2,3]a,b,c = lfunc(a,b,c)func(*[1,2,3,4,5,6]) # *会将列表打散成位置实参⼀⼀传⼊等价于func(1,2,3,4,5,6)func(*(1,2,3)) # 等价于func(1,2,3)def func(x,*z):print(x,z)func(1,*{1,2,3}) # *在形参中只能接收多余的位置实参不能接收关键字实参# *只能将列表元组集合字符串# *的内部你可以看成是for循环站在形参的⾓度看 **def func(x,y,**z):print(x,y,z) # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}func(x=1,y=2,z=1,a=1,b=2,c=3)# **会接收所有多余的关键字参数并将关键字参数转换成字典的形式字典的key就是关键字的名字# 字典的value就是关键字的名字指向的值将字典交给**后⾯的变量名站在实参的⾓度看 **def func(x,y,z):print(x,y,z)func(12,3,4)func(x=1,y=2,z=3)d = {'x':1,'y':2,'z':333}func(x=1,y=2,z=3)func(**d) # 等价于func(x=1,y=2,z=333)# **会将字典拆封成 key = value的形式总结：* 与 ** *在形参中能够接受多余的位置参数组织成⼀个元祖赋值给*后⾯的变量名 **在形参中能够接受多余的关键字参数组织成⼀个字典赋值给**后⾯的变量名 *:在实参中 *能够将列表元祖集合字符串打散成位置实参的形式传递给函数(*就看成是for循环取值) **:在实参中能将字典打散成key = value的形式按照关键字参数传递给函数注意：python推荐形参*和**通⽤的写法def func2(*args,**kwargs):print(args,kwargs)func2(1,2,3,4,5,6,x=1,y=2,z = 3)。

函数的定义和参数⼀、函数的定义什么是函数在程序中，函数就是具备某⼀功能的⼯具，事先将⼯具准备好就是函数的定义，遇到应⽤场景拿来就⽤就是函数的调⽤为什么要⽤函数函数可以使程序分块化，增加程序的扩展性和可读性怎么⽤函数先定义，后调⽤定义函数def 函数名(): # 定义阶段(造车轮阶段)"""函数注释写在这⾥""" # 函数相当于⼯具, 注释相当于⼯具的说明书<代码块>注意：函数定义阶段，只检测语法，不执⾏函数体代码调⽤函数# 使⽤ # 调⽤阶段(开车阶段)函数名()执⾏函数代码⼆、定义函数的三种⽅式1.⽆参函数在函数阶段括号内没有参数，称为⽆参函数。

注意：定义时⽆参，意味着调⽤时也⽆需传⼊参数。

ef func():print('hello llj')func() # hello llj2.有参函数在函数定义阶段括号内有参数，称为有参函数。

注意：定义时有参，意味着调⽤时也必须传⼊参数ef sum_self(x, y):"""求和"""res = x+yprint(res)sum_self(1,2) # 33.空函数def func():pass三、函数的参数1.形参和实参1.1形参在函数定义阶段括号内定义的参数，称之为形式参数，简称形参，本质就是变量名。

def func(x, y):print(x)print(y)1.2实参func(1, 2)2.位置参数2.1位置形参在函数定义阶段，按照从左到右的顺序依次定义的形参，称之为位置形参。

def func(x, y): #x,y就是位置形参print(x)print(y)2.位置实参func(1, 2)3.关键字实参在调⽤函数时，按照key=value的形式为指定的参数传值，称为关键字实参。

func(y=1, x=2)特点：可以打破位置的限制，但仍能为指定的形参赋值。

fats文件系统函数FATS（File Allocation Table System）文件系统是一种用于存储和管理文件的文件系统。

它最初是由微软开发的，用于FAT12、FAT16和FAT32文件系统。

FATS文件系统提供了一套API（应用程序接口）函数，允许应用程序与文件系统进行交互。

下面是与FATS文件系统相关的一些常见API函数的参考内容。

1. FATFS- 函数原型：FRESULT f_mount(FATFS *fs, const TCHAR*path, BYTE opt)- 函数功能：将FATS文件系统挂载到指定的驱动器上。

- 参数说明：- fs：指向要挂载的FATFS对象的指针。

- path：指向要挂载的驱动器路径的字符串。

- opt：指定挂载选项的标志位。

2. 文件操作函数- 函数原型：FRESULT f_open(FIL *fp, const TCHAR *path, BYTE mode)- 函数功能：打开一个文件。

- 参数说明：- fp：指向FIL对象的指针，用于存储打开的文件。

- path：指向要打开文件的路径的字符串。

- mode：指定打开文件的模式。

- 函数原型：FRESULT f_read(FIL *fp, void *buff, UINT btr,UINT *br)- 函数功能：从文件中读取数据。

- 参数说明：- fp：指向已打开的文件的FIL对象的指针。

- buff：指向存储读取数据的缓冲区的指针。

- btr：要读取的字节数。

- br：存储实际读取字节数的变量指针。

- 函数原型：FRESULT f_write(FIL *fp, const void *buff, UINT btw, UINT *bw)- 函数功能：将数据写入文件。

- 参数说明：- fp：指向已打开的文件的FIL对象的指针。

- buff：指向要写入文件的数据的指针。

- btw：要写入的字节数。

- bw：存储实际写入字节数的变量指针。

第八章系统参数 (2)8.1 设备列表 (3)8.1.1 控制一台本地PLC的参数设定 (3)8.1.2 控制一台远程PLC(remote PLC)的参数设定 (11)8.1.3 如何控制一台远程触摸屏 (remote HMI) (13)8.2 HMI属性 (16)8.3 一般属性 (20)8.4 用户密码 (25)8.5 字体 (27)8.6 扩展存贮器 (29)8.7 打印服务器 (31)第八章 系统参数打开EB8000软件后，单击菜单“编辑/系统参数设置”，则可以打开系统参数的设定对话框，如下图所示。

系统参数设定里面总共包含了[设备列表]、[HMI属性]、[一般属性]、[用户密码]、[字体]、[扩展存贮器] 和[打印服务器]总共七个部分。

下面我们将分别对这几个部分进行说明。

8.1设备列表[设备列表]用来设定与人机界面所连接的各项设备的属性，这些设备包括各式PLC，控制器、远程的人机界面和计算机。

当使用 EB8000新建一个MTP工程文件后，可以发现在“设备列表”中，存在一个预设装置：“本机触摸屏”，“本机触摸屏”被用来识别本机，也可称为本地人机界面，每一个MTP 文件至少需包含一个“本机触摸屏”设备。

当单击[设置…]按钮，可打开“本机触摸屏”的设定对话窗口，由图中可以发现“本机触摸屏”的属性为“HMI”，位置为“本机”。

下面说明新增一台设备的步骤：8.1.1控制一台本地PLC的参数设定所谓“本机PLC”是指直接连接到本地触摸屏的PLC，此时要控制本机PLC需先增加此种类型的设备。

在按下[新增…]按键后，只需在设定对话窗口中正确设定各项属性即可。

各项设定的说明如下：[名称]设备名称。

名称可以自定义，推荐使用比较容易识别和记住的名称。

一般系统默认为与所连接的PLC驱动名称一致。

[HMI]或[PLC]该两个选项表示，与本机触摸屏连接的设备属性，是人机界面（HMI）还是PLC。

此时选择“PLC”。

函数,参数及参数解构,返回值,作⽤域函数,参数及参数解构函数数学定义: y=f(x),y是x的函数,x是⾃变量.python函数: 完成⼀定的功能,由若⼲语句组成的语句块,函数名称,参数列表构成,它是组织代码的最⼩单位.函数的作⽤:结构化变成对代码的最基本的封装,⼀般按照功能组织⼀段代码.封装的⽬的为了复⽤,减少冗余代码.代码更加简洁美观,可读易懂.函数的分类:内建函数: 如max(),reversed()等.库函数: 如math.ceil()等.函数定义,调⽤def语句定义函数.语法:def 函数名(参数列表):函数体(代码块)[return 返回值]函数名就是标识符,命名要求⼀样.语句块必须缩进,约定4个空格.python的函数没有return语句,隐式会返回⼀个None值.定义中的参数列表成为形式参数,只是⼀种符号表达,简称形参.调⽤:函数定义,只是声明了⼀个函数,它不会被执⾏,需要调⽤.调⽤的⽅式,就是函数名加上⼩括号,括号内写上参数.调⽤时写的参数是实际参数,是实实在在传⼊的值,简称实参.函数举例:1 2 3 4 5def add(x, y): result = x + y return result out = add(4, 5) print(out) # 9上⾯只是⼀个函数的定义,有⼀个函数add,接收2个参数.计算的结果,通过返回值返回.调⽤通过函数名add加2个参数,返回值可使⽤变量接收.定义需要在调⽤前,也就是说调⽤时,已经被定义过了,否则抛异常NameError.函数是可调⽤的对象,callable().函数参数参数调⽤时传⼊的参数要和定义的个数相匹配(可变参数例外).位置参数:def f(x,y,z) 调⽤使⽤f(1,3,5).按照参数定义顺序传⼊实参.关键字参数:def f(x,y,z)调⽤使⽤f(x=1,y=3,z=5).使⽤形参的名字来出⼊实参的⽅式,如果使⽤了形参名字,那么传参顺序就可以和定义顺序不同.传参:f(z=None,y=10,x=[1])f((1,),z=6,y=4.1)f(y=5,z=6,2)要求位置参数必须在关键字参数之前传⼊,位置参数是按位置对应的.参数规则: 参数列表参数⼀般顺序是,普通参数,缺省参数,可变位置参数,keyword-only参数(可带缺省值),可变关键字参数.1 2 3 4 5 6 7In [44]: def fn(x,y,z=3,*arg,m=4,n,**kwargs): ...: print(x,y,z,m,n)...: print(args)...: print(kwargs)...:In [45]:注:代码应该易读易懂,⽽不是为难别⼈.按照书写习惯定义函数参数.函数参数默认值参数默认值:定义时,在形参后跟上⼀个值.1 2 3 4 5 6 7 8 9 10 11def add(x=4,y=5): result = x + yprint(result)add(6,10)add(6,y=7)add(x=5)add()add(y=7)# add(x=5,6) # error. # add(y=8,4) # error.12 13add(x=5,y=6) add(y=5,x=6)注: def add(x=4, y)是错误的.作⽤:参数的默认值可以在未传⼊⾜够的实参的时候,对没有给定的参数赋值为默认值.参数⾮常多时,并不需要⽤户每次都输⼊所有的参数,简化函数调⽤.举例:定义⼀个函数login,参数名称为host,port,username,password.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15def login(host='127.0.0.1', port='8080', username='ames', password='ames'): print('{}:{}@{}/{}'.format(host, port, username, password))login()login('127.0.0.1', 80, 'tom', 'tom')login('127.0.0.1', username='root')login('localhost', port=80, password=1234)login(port=80,password='python', host='www')# 运⾏结果:127.0.0.1:8080@ames/ames127.0.0.1:80@tom/tom127.0.0.1:8080@root/ameslocalhost:80@ames/1234www:80@ames/python可变参数⼀个形参可以匹配任意个参数.1 2 3 4 5 6 7 8 9 10 11 12 13In [1]: def add(nums): ...: sum = 0...: for x in nums: ...: sum += x ...: return sum...:In [2]: add([1, 3, 5]) Out[2]: 9In [3]: add([2, 4, 6]) Out[3]: 1214In [4]:位置参数的可变参数: 有多个数,需要累加求和.1 2 3 4 5 6 7 8 9 10 11 12 13In [4]: def add(*nums): ...: sum = 0...: print(type(nums)) ...: for x in nums:...: sum += x...: print(sum)...:In [5]: add(3, 6, 9)<class 'tuple'>18In [6]:在形参前使⽤*表⽰该形参是可变参数,可以接收多个实参.收集多个实参为⼀个tuple.关键字参数的可变参数:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18In [6]: def showconfig(**kwargs):...: for k,v in kwargs.items():...: print('{} = {}'.format(k,v))...:In [7]: showconfig(host='127.0.0.1', port=8080, username='ames', password=123456) username = ameshost = 127.0.0.1port = 8080password = 123456In [8]:# 运⾏结果:password = 123456port = 8080username = ameshost = 127.0.0.1形参前使⽤**符号,表⽰可以接收多个关键字参数.收集的实参名称和值组成⼀个字典.可变参数混合使⽤:def showconfig(username,password,**kwargs)def showconfig(username,*args,**kwargs)def showconfig(username,password,**kwargs,*args)总结:可变参数分为位置可变参数和关键字可变参数.位置可变参数在形参前使⽤⼀个星号*.关键字可变参数在形参前使⽤两个星号**.位置可变参数和关键字可变参数都可以收集若⼲个实参,位置可变参数收集形成⼀个tuple,关键字可变参数收集形成⼀个dict.混合使⽤参数时,可变参数要放在参数列表的最后,普通参数需要放到参数列表前⾯,位置可变参数需要放在关键字可变参数之前.可变参数举例:举例1:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24In [8]: def fn(x,y,*args,**kwargs): ...: print(x)...: print(y)...: print(args)...: print(kwargs)...:In [9]: fn(3,5,7,9,10,a=1,b='ames') 35(7, 9, 10){'a': 1, 'b': 'ames'}In [10]: fn(13,15)1315(){}In [11]: fn(23,25,27)2325(27,){}2526 27 28 29 30 31 32 33 34 35 36 37 38 39 40In [12]: fn(33,35,a=1,b='ames')3335(){'a': 1, 'b': 'ames'}In [13]: fn(7,9,y=5,x=3,a=1,b='ames')---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-13-a0c84e79923c> in <module>()----> 1 fn(7,9,y=5,x=3,a=1,b='ames')TypeError: fn() got multiple values for argument 'y' # 错误,7和9分别赋给了x,y,⼜y=5 x=3,x和y的值重复. In [14]:举例2:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24In [14]: def fn(*args, x, y, **kwargs):...: print(x)...: print(y)...: print(args)...: print(kwargs)...:In [15]: fn(3, 5)---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-15-4ac8ce4a4cba> in <module>()----> 1 fn(3, 5)TypeError: fn() missing 2 required keyword-only arguments: 'x' and 'y'In [16]: fn(13, 15, 17)---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-16-75940373c950> in <module>()----> 1 fn(13, 15, 17)TypeError: fn() missing 2 required keyword-only arguments: 'x' and 'y' In [17]: fn(23, 25, a=1, b='ames')25 26 27 28 29 30 31 32 33 34 35 36 37 38---------------------------------------------------------------------------TypeError Traceback (most recent call last)<ipython-input-17-709612ad798f> in <module>()----> 1 fn(23, 25, a=1, b='ames')TypeError: fn() missing 2 required keyword-only arguments: 'x' and 'y'In [18]: fn(37, 39, y=35, x=33, a=1, b='ames')3335(37, 39){'a': 1, 'b': 'ames'}In [19]:keyword-only参数keyword-only参数 (python3加⼊).如果在⼀个星号参数后,或者⼀个位置可变参数后,出现的普通参数,实际上已经不是普通的参数,⽽是keyword-only参数.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23In [19]: def fn(*args, x):...: print(x)...: print(args)...:In [20]: fn(3, 5)---------------------------------------------------------------------------TypeError Traceback (most recent call last) <ipython-input-20-4ac8ce4a4cba> in <module>()----> 1 fn(3, 5)TypeError: fn() missing 1 required keyword-only argument: 'x'In [21]: fn(13, 15, 17)---------------------------------------------------------------------------TypeError Traceback (most recent call last) <ipython-input-21-57115e70fa2e> in <module>()----> 1 fn(13, 15, 17)TypeError: fn() missing 1 required keyword-only argument: 'x'In [22]: fn(23, 25, x = 27)2724 25 26(23, 25) In [23]:注: 如上错误,args可看做已经截获了所有位置参数,x不使⽤关键字参数就不可能拿到实参.以上函数如果换成def fn(**kwargs,x),会直接报语法错误,可以理解为kwargs会截获所有的关键字,就算写了x=5,x也永远得不到这个值,所以语法错误. keyword-only参数的另⼀种形式:1 2 3 4 5 6 7 8In [23]: def fn(*,x,y): ...: print(x,y) ...:In [24]: fn(x=5,y=6) 5 6In [25]:*号之后,普通形参都变成了必须给出的keyword-only参数.可变参数和参数默认值1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22In [25]: def fn(*args,x=5): ...: print(x)...: print(args)...:In [26]: fn() # 等价于fn(x=5) 5()In [27]: fn(5)5(5,)In [28]: fn(x=6)6()In [29]: fn(1,2,3,x=10)10(1, 2, 3)In [30]:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42In [30]: def fn(y,*args,x=5):...: print('x={},y={}'.format(x,y))...: print(args)...:In [31]: fn()---------------------------------------------------------------------------TypeError Traceback (most recent call last) <ipython-input-31-fd7064640434> in <module>()----> 1 fn()TypeError: fn() missing 1 required positional argument: 'y'In [32]: fn(5)x=5,y=5()In [33]: fn(x=6)---------------------------------------------------------------------------TypeError Traceback (most recent call last) <ipython-input-33-704ccb59ea7c> in <module>()----> 1 fn(x=6)TypeError: fn() missing 1 required positional argument: 'y'In [34]: fn(1,2,3,x=10)x=10,y=1(2, 3)In [35]: fn(y=17,2,3,x=10)File "<ipython-input-35-717813843388>", line 1fn(y=17,2,3,x=10)^SyntaxError: positional argument follows keyword argumentIn [37]: fn(17,2,3,x=10)x=10,y=17(2, 3)In [36]: fn(1,2,y=3,x=10)---------------------------------------------------------------------------43 44 45 46 47 48 49TypeError Traceback (most recent call last) <ipython-input-36-c795acbab6ef> in <module>()----> 1 fn(1,2,y=3,x=10)TypeError: fn() got multiple values for argument 'y'In [38]:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26In [38]: def fn(x=5, **kwargs): ...: print('x={}'.format(x)) ...: print(kwargs)...:In [39]: fn()x=5{}In [40]: fn(5)x=5{}In [41]: fn(x=6)x=6{}In [42]: fn(y=3,x=10)x=10{'y': 3}In [43]: fn(3,y=10)x=3{'y': 10}In [44]:参数解构参数解构:给函数提供实参时,可在集群类型前使⽤*或**,把集群类型的解构解开,提取出所有元素作为函数的实参.⾮字典类型使⽤*解构成位置参数.字典类型使⽤**解构成关键字参数.提取出来的元素数⽬要和参数的要求匹配,也要和参数的类型匹配.1In [45]: def add(x,y):1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22In [45]: def add(x,y):...: return x+y...:In [46]: add(*(4,5))Out[46]: 9In [47]: add(*[4,5])Out[47]: 9In [48]: add(*{4,6})Out[48]: 10In [49]: d = {'x':5, 'y':6}In [50]: add(**d)Out[50]: 11In [51]: add(**{'x':5, 'y':6}) Out[51]: 11In [52]:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15In [54]: def add(*iterable): ...: result = 0...: for x in iterable: ...: result += x...: return result...:In [55]: add(1,2,3)Out[55]: 6In [56]: add(*[1,2,3])Out[56]: 6In [57]: add(*range(10)) Out[57]: 45练习:1.编写⼀个函数,能够接受⾄少2个参数,返回最⼩值和最⼤值.1 2 3 4 5 6 7 8 9import randomdef double_values(*nums):print(nums)return max(nums), min(nums)print(*double_values(*[random.randint(10, 20) for _ in range(10)])) # 两次解构# 运⾏结果:(18, 16, 16, 12, 13, 13, 14, 20, 18, 16)20 121. 编写⼀个函数,接受⼀个参数n,n为正整数,左右两种打印⽅式.要求数字必须对齐.1 2 3 4 5 6 7def show(n):tail = ' '.join([str(i) for i in range(n, 0, -1)])width = len(tail)for i in range(1, n):print("{:>{}}".format(" ".join([str(j) for j in range(i, 0, -1)]),width)) print(tail)show(12)1 2 3 4 5 6 7def showtail(n):tail = ' '.join([str(i) for i in range(n, 0, -1)]) print(tail)for i in range(len(tail)):if tail[i] == ' ':print(' '*i, tail[i+1:])showtail(12)插⼊排序函数返回值,作⽤域函数的返回值举例:1 2 3 4 5 6def showplus(x):print(x)return x+1print(x+1) # 该⾏不会执⾏. print(showplus(5))7 8 9# 运⾏结果: 56多条return语句:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16def guess(x):if x > 3:return '>3'else:return '<=3'print(guess(10))-------------------------------------------def showplus(x):print(x)return x+1return x+2 # 该⾏不会执⾏. print(showplus(5))# 运⾏结果:561 2 3 4 5 6 7 8 9 10 11 12def fn(x):for i in range(x):if i > 3:return ielse:print('{} is not greater than 3'.format(x))print(fn(5)) # 运⾏结果: 4print(fn(3))# 运⾏结果:3 is not greater than 3None # 所有函数都有函数值,如果没有return语句,隐式调⽤return None.总结:python函数使⽤return语句返回'返回值'.所有函数都有函数值,如果没有return语句,隐式调⽤return None.return语句并不⼀定是函数的语句块的最后⼀条语句.⼀个函数可以存在多个return语句,但是只有⼀条可以被执⾏.如果没有⼀条return语句被执⾏到,隐式调⽤return None.如果有必要,可以显⽰调⽤return None,可以简写为return.如果函数执⾏了return语句,函数就会返回,当前被执⾏的return语句之后的其他语句就不会被执⾏.作⽤: 结束函数调⽤和返回值.返回多个值:1 2 3 4 5 6 7def showlist():return [1, 3, 5]print(showlist()) # 运⾏结果: [1, 3, 5]def showlist():return 1, 3, 5print(showlist()) # 运⾏结果: (1, 3, 5)注:函数不能同时返回多个值.return [1,3,5] 即指明返回⼀个列表,是⼀个list对象.return 1,3,5 看似返回多个值,隐式的被python封装成了⼀个元组.1 2 3 4def showlist():return 1,3,5x, y, z = showlist()print(x, y, z) # 运⾏结果: 1 3 5函数嵌套函数嵌套:在⼀个函数中定义了另⼀个函数.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16In [4]: def outer():...: def inner():...: print('inner')...: print('outer')...: inner()...:In [5]: outer()outerinnerIn [6]: inner()---------------------------------------------------------------------------NameError Traceback (most recent call last) <ipython-input-6-159a447ee30d> in <module>()----> 1 inner()1718 19 20NameError: name 'inner' is not defined In [7]:注:函数有可见范围,这就是作⽤域的概念.内部函数不能被外部直接使⽤,会抛异常NameError,如上代码.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15def outer():def inner():print('inner')return 'xx' # return Noneprint('outer')inner()return inner(),'p'print(outer())# 执⾏结果outerinnerinner('xx', 'p') # 两次return的结果组成了⼀个元组.作⽤域作⽤域: ⼀个标识符的可见范围即标识符的作⽤域.⼀般常说的是变量的作⽤域.1 2 3 4 5 6 7 8 9 10 11 12 13In [9]: x = 5...: def foo():...: print(x)...:In [10]: foo()5In [11]:In [13]: x = 5...: def foo():...: x += 1 # x = x + 1...: print(x)...:In [14]: foo()# 运⾏报错:UnboundLocalError: local variable 'x' referenced before assignmentIn [15]:全局作⽤域:在整个程序运⾏环境中都可见.局部作⽤域:在函数,类等内部可见.局部变量使⽤范围不能超过其所在的局部作⽤域.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15In [31]: def fn1():...: x = 1 # 局部作⽤域,在fn1内....: def fn2():...: print(x)...:In [32]: print(x)---------------------------------------------------------------------------NameError Traceback (most recent call last) <ipython-input-32-57a99df8cebf> in <module>()----> 1 print(x)NameError: name 'x' is not definedIn [33]:嵌套结构:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16def outer1():o = 65def inner():print('inner {}'.format(o))print(chr(o))print('outer {}'.format(o))inner()outer1()# 运⾏结果:outer 65inner 65Adef outer2():o = 65def inner():o = 97print('inner {}'.format(o))print(chr(o))print('outer {}'.format(o))inner()outer2()# 运⾏结果:outer 65inner 97a从嵌套结构例⼦看出:外层变量作⽤域在内层作⽤域可见.内层作⽤域inner中,如果定义了o=97,相当于当前作⽤域中重新定义了⼀个新的变量o,但是这个o并没有覆盖外层作⽤域outer中的o.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35In [1]: x = 5In [2]: def foo():...: y = x + 1...: x += 1...: print(x)...:In [3]: foo()---------------------------------------------------------------------------UnboundLocalError Traceback (most recent call last) <ipython-input-3-624891b0d01a> in <module>()----> 1 foo()<ipython-input-2-4a190c7f9e12> in foo()1 def foo():---> 2 y = x + 13 x += 14 print(x)5UnboundLocalError: local variable 'x' referenced before assignmentIn [4]: def foo():...: y = x + 1...: # x += 1...: print(x)...:In [5]:In [5]: foo()5In [6]:1 2 3In [14]: x = 5In [15]: def foo():4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ...: x += 1...: return x...:In [16]: foo()---------------------------------------------------------------------------UnboundLocalError Traceback (most recent call last)<ipython-input-16-624891b0d01a> in <module>()----> 1 foo()<ipython-input-15-36b35103f745> in foo()1 def foo():----> 2 x += 13 return xUnboundLocalError: local variable 'x' referenced before assignmentIn [17]:注意:x += 1 其实是 x = x + 1相当于在foo内部定义⼀个局部变量x,那么foo内部所有x都是这个局部变量x了.但是这个x还没完成复制,就被右边拿来做加1操作了,故报错.全局变量: global1 2 3 4 5 6 7 8 9 10 11 12 13In [20]: x = 5In [21]: def foo(): ...: global x ...: x += 1 ...: return x ...:In [22]: foo() Out[22]: 6In [23]:使⽤global关键字的变量,将foo内的x声明为使⽤外部的全局作⽤域中定义的x.全局作⽤域中必须有x的定义.如果全局作⽤域中没有x定义:1 2 3 4 5 6 7 8 9 10 11 12 13 14In [1]: def foo(): ...: global x ...: x = 10 ...: x += 1 ...: print(x) ...:In [2]: foo()11In [3]: print(x) 11In [4]:使⽤global关键字的变量,将foo内的x声明为使⽤外部的全局作⽤域中定义的x.但是,x = 10赋值即定义,x在内部作⽤域为⼀个外部作⽤域的变量赋值,所以x += 1不会报错.注意这⾥的x的作⽤域还是全局的.global总结:x+=1这种是特殊形式产⽣的错误的原因,先引⽤后赋值,⽽python动态语⾔是赋值才算定义,才能被引⽤.解决办法是在这条语句前增加x=0之类的赋值语句,或者使⽤global告诉内部作⽤域,去全局作⽤域查找变量定义.内部作⽤域使⽤x=5之类的赋值语句会重新定义局部作⽤域使⽤的变量x,但是⼀旦这个作⽤域中使⽤的global声明为全局的,那么x=5相当于在为全局作⽤域的变量x赋值.global使⽤原则:外部作⽤域变量在内部作⽤域可见,但也不要在这个内部的局部作⽤域中直接使⽤,因为函数的⽬的就是为了封装,尽量与外界隔离.如果函数需要使⽤外部全局变量,使⽤函数的形参传参解决.闭包⾃由变量: 未在本地作⽤域中定义的变量.例如定义在内存函数外的外层函数的作⽤域中的变量.闭包: 就是⼀个概念,出现在嵌套函数中,指内层函数引⽤到外层函数的⾃由变量,就形成了闭包,JavaScript就是如此.1 2 3 4 5 6 7 8 9In [8]: def counter(): ...: c = [0]...: def inc():...: c[0] += 1 ...: return c[0] ...: return inc...:In [9]: foo = counter()1011 12 13 14 15 16 17 18 19In [10]: print(foo(), foo()) 1 2In [11]: c = 100In [12]: print(foo())3In [13]:代码解析:第四⾏没有报错,因为c已经在counter函数中定义过了,⽽且inc中的使⽤⽅式是为c的元素修改值,⽽不是重新定义变量.第⼗四⾏定义的c和counter中的c不⼀样,⽽inc引⽤的是⾃由变量⽽不是counter的变量c.这是python2中实现闭包的⽅式,python3还可以使⽤nonlocal关键字.如下代码:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24In [15]: def counter():...: count = 0...: def inc():...: count += 1...: return count...: return inc...:In [16]: foo = counter()In [17]: foo()---------------------------------------------------------------------------UnboundLocalError Traceback (most recent call last)<ipython-input-17-624891b0d01a> in <module>()----> 1 foo()<ipython-input-15-b7d707b2e550> in inc()2 count = 03 def inc():----> 4 count += 15 return count6 return incUnboundLocalError: local variable 'count' referenced before assignment26In [18]: foo()以上报错,使⽤global可以解决,但是这样使⽤的是全局变量,⽽不是闭包.如果要使⽤普通变量的闭包,python3可以使⽤nonlocal.nonlocal关键字使⽤了nonlocal关键字,将变量标记为在上级的局部作⽤域中定义,但不能是全局作⽤域中定义.1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18In [20]: def counter():...: count = 0...: def inc():...: nonlocal count...: count += 1...: return count...: return inc...:In [21]: foo = counter()In [22]: foo()Out[22]: 1In [23]: foo()Out[23]: 2In [24]:In [26]: a = 50...: def counter():...: nonlocal a...: a += 1...: print(a)...: count = 0...: def inc():...: nonlocal count...: count += 1...: return count...: return incFile "<ipython-input-26-a29a1eb62faa>", line 3nonlocal a^SyntaxError: no binding for nonlocal 'a' found# nonlocal 要绑定⼀个局部变量.In [27]:count是外层函数的局部变量,被内层函数引⽤.内部函数使⽤nonlocal关键字声明count变量在上⼀级作⽤域中.上⾯左边代码可以正常使⽤,且形成闭包;右边代码不能正常运⾏,变量a不能在全局作⽤域中.默认值的作⽤域默认值举例:1 2 3 4 5 6 7 8 9In [27]: def foo(xyz=1): ...: print(xyz)...:In [28]: foo()1In [29]: foo()111 12 13 14 15 16 17 18In [30]: print(xyz)------------------------------------------------------------NameError Traceback (most recent call last)<ipython-input-30-a2bcd278357a> in <module> ()----> 1 print(xyz)NameError: name 'xyz' is not definedIn [31]:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19In [32]: def foo(xyz=[]):...: xyz.append(1)...: print(xyz)...:In [33]: foo()[1]In [34]: foo()[1, 1]In [35]: print(xyz)------------------------------------------------------------NameError Traceback (most recent call last)<ipython-input-35-2cf093bba2e6> in <module>() ----> 1 print(xyz)NameError: name 'xyz' is not definedIn [36]:以上⽰例第⼆次调⽤foo函数打印[1, 1],是因为函数也是对象,python把函数的默认值放在了属性中,这个属性就伴随着这个函数对象的整个⽣命周期.查看属性: foo.__defaults__如下例⼦:1 2 3 4 5 6 7 8In [39]: def foo(xyz=[], u='abc', z=123): ...: xyz.append(1)...: return xyz...:In [40]: foo(), id(foo)Out[40]: ([1], 2239176151928)9 10 11 12 13 14 15 16 17 18In [41]: foo.__defaults__Out[41]: ([1], 'abc', 123)In [42]: foo(), id(foo)Out[42]: ([1, 1], 2239176151928)In [43]: foo.__defaults__Out[43]: ([1, 1], 'abc', 123)In [44]:函数地址并没有变,就是说函数这个对象的地址没有变,调⽤它,它的属性__defaults__中使⽤元组保存所有默认值. xyz默认值是引⽤类型,引⽤类型的元素变动,并不是元组的变化.⾮引⽤类型例⼦:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16In [48]: def foo(w,u='abc',z=123): ...: u='xyz'...: z=789...: print(w,u,z)...:In [49]: print(foo.__defaults__) ('abc', 123)In [50]: foo('ames')ames xyz 789In [51]: print(foo.__defaults__) ('abc', 123)In [52]:属性__defaults__中使⽤元组保存所有默认值,它不会因为在函数体内使⽤了它⽽发⽣改变.可变类型默认值,如果使⽤默认值,就可能修改这个默认值.有时候这个特性是好的,有时候这种特性是不好的,有副作⽤.如下例⼦做到了按需改变:1 2 3 4In [1]: def foo(xyz=[], u='abc', z=123):...: xyz = xyz[:] # 影⼦拷贝....: xyz.append(1)...: print(xyz)In [10]: def foo(xyz=None, u='abc', z=123):...: if xyz is None:...: xyz = []...: xyz.append(1)5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 ...:In [2]: foo()[1]In [3]: print(foo.__defaults__)([], 'abc', 123)In [4]: foo()[1]In [5]: print(foo.__defaults__)([], 'abc', 123)In [6]: foo([10])[10, 1]In [7]: print(foo.__defaults__)([], 'abc', 123)In [8]: foo([10,5])[10, 5, 1]In [9]: print(foo.__defaults__)([], 'abc', 123)In [10]:# 注:1)函数体内,不改变默认值.2)xyz都是传⼊参数或者默认参数的副本,如果想修改原参数,则⽆能为⼒....: print(xyz)...:In [11]: foo()[1]In [12]: foo.__defaults__Out[12]: (None, 'abc', 123)In [13]: foo()[1]In [14]: foo.__defaults__Out[14]: (None, 'abc', 123)In [15]: foo([10])[10, 1]In [16]: foo.__defaults__Out[16]: (None, 'abc', 123)In [17]: foo([10,5])[10, 5, 1]In [18]: foo.__defaults__Out[18]: (None, 'abc', 123)In [19]:# 注:使⽤不可变类型默认值:如果使⽤缺省值None就创建⼀个列表.如果传⼊⼀个列表,就修改这个列表.第⼀种⽅法:使⽤影⼦拷贝创建⼀个新的对象,永远不能改变传⼊的参数.第⼆种⽅法:通过值的判断就可以灵活的选择创建或修改传⼊对象.这种⽅式灵活,应⽤⼴泛.很多函数的定义,都可以看到使⽤None这个不可变的值作为默认参数,可以说这是⼀种惯⽤法.变量名解析原则LEGBLocal,本地作⽤域,局部作⽤域的local命名空间.函数调⽤时创建,调⽤结束消亡.Enclosing, python2.2时引⼊了嵌套函数,实现了闭包,这个就是嵌套函数的外部函数的命名空间.Global,全局作⽤域,即⼀个模块的命名空间.模块被import时创建,解释器退出时消亡.Build-in, 内置模块的命名空间,⽣命周期从python解释器启动时创建到解释器退出时消亡.例如print(open),print和open都是内置的变量.所以⼀个名词的查找顺序就是LEGB.函数的销毁全局函数:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29In [1]: def foo(xyz=[], u='abc', z=123):...: xyz.append(1)...: return xyz...:In [2]: foo(), id(foo), foo.__defaults__Out[2]: ([1], 1585221689688, ([1], 'abc', 123))In [4]: def foo(jdk=[], h='abc', p=123):...: jdk.append(1)...: return jdk...:In [5]: print(foo(), id(foo), foo.__defaults__)[1] 1585222352680 ([1], 'abc', 123)In [6]: del fooIn [7]: print(foo(), id(foo), foo.__defaults__)------------------------------------------------------------NameError Traceback (most recent call last)<ipython-input-7-7e639523779a> in <module>()----> 1 print(foo(), id(foo), foo.__defaults__) NameError: name 'foo' is not definedIn [8]:全局函数销毁:重新定义同名函数. del语句删除函数对象.程序结束时.局部函数:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29In [2]: def foo(xyz=[], u='abc', z=123):...: xyz.append(1)...: def inner(a=10):...: pass...: print(inner)...: def inner(a=100):...: print(xyz)...: print(inner)...: return inner...:In [3]: bar = foo()<function foo.<locals>.inner at 0x000001F99DA99A60><function foo.<locals>.inner at 0x000001F99DA99AE8>In [4]: print(id(foo), id(bar), foo.__defaults__, bar.__defaults__) 2171610546656 2171603622632 ([1], 'abc', 123) (100,)In [5]: del barIn [6]: print(id(foo), id(bar), foo.__defaults__, bar.__defaults__) ---------------------------------------------------------------------------NameError Traceback (most recent call last) <ipython-input-6-cbce72c73fb2> in <module>()----> 1 print(id(foo), id(bar), foo.__defaults__, bar.__defaults__)NameError: name 'bar' is not definedIn [7]:局部函数销毁:重新在上级作⽤域定义同名函数. del语句删除函数对象.上级作⽤域销毁时.。

Python中的函数及函数参数的使⽤函数：⼀个⼯具，随调随⽤ 降级代码冗余 增加代码的复⽤性，提⾼开发效率，为了不成为cv战⼠ 提⾼程序扩展性函数有两个阶段：定义阶段，调⽤阶段。

定义时：只检查函数体内代码语法，不执⾏函数体内代码。

函数参数： 参数分形参、实参 形参：函数定义时括号内的参数 实参：函数调⽤时括号内的参数 形参相当于变量，实参相当于变量的值。

定义时: def func(a, b, c): pass a, b, c为形参 调⽤时： func(1, 2, 3) 1, 2, 3 为实参形参： 只在被调⽤时，才分配内存单元。

调⽤结束，⽴刻释放所分配的内存。

形参只在函数内部有效。

实参： 可以是：常量、变量、表达式、函数。

进⾏函数调⽤时，实参必须是确定的值。

位置参数： 位置形参：函数定义时，从左往右写的参数，⽐如上⾯的 a, b , c 位置实参：函数调⽤时，从左往右写的参数, ⽐如上⾯的 1，2，3 位置形参定义多少个，调⽤时位置实参必须写上多少个，多⼀个少⼀个都不⾏。

关键参数： 正常情况下，给函数传参数，要按顺序。

如果不想按顺序，就⽤关键参数。

指定参数名的参数，就叫做关键参数。

函数调⽤时：func(a=1, b=2), 这种指定了参数名的参数，就是关键参数。

调⽤函数时，关键参数可以和位置参数⼀起⽤，但是关键参数必须在位置参数的后⾯。

不然会报错。

默认参数： 函数定义时，默认参数必须在位置形参的后⾯。

函数调⽤时，指定参数名的参数，叫关键参数。

⽽在函数定义时，给参数名指定值的时候，这个参数叫做默认参数。

关键参数，和默认参数两个参数写法⼀样，区别在于： 关键参数是在函数调⽤时，指定实参的参数名，也可以说指定值的参数名。

默认参数是在函数定义时，指定参数名的值。

写法： def (a, b=100): pass 定义时，有默认参数的话，调⽤时，这个实参可以不写。

如果实参不写的话，这个形参的参数值是他的默认值。