函数 订阅
函数(function)的定义通常分为传统定义和近代定义,函数的两个定义本质是相同的,只是叙述概念的出发点不同,传统定义是从运动变化的观点出发,而近代定义是从集合、映射的观点出发。函数的近代定义是给定一个数集A,假设其中的元素为x,对A中的元素x施加对应法则f,记作f(x),得到另一数集B,假设B中的元素为y,则y与x之间的等量关系可以用y=f(x)表示,函数概念含有三个要素:定义域A、值域B和对应法则f。其中核心是对应法则f,它是函数关系的本质特征。 [1]  函数,最早由中国清朝数学家李善兰翻译,出于其著作《代数学》。之所以这么翻译,他给出的原因是“凡此变数中函彼变数者,则此为彼之函数”,也即函数指一个量随着另一个量的变化而变化,或者说一个量中包含另一个量。 展开全文
函数(function)的定义通常分为传统定义和近代定义,函数的两个定义本质是相同的,只是叙述概念的出发点不同,传统定义是从运动变化的观点出发,而近代定义是从集合、映射的观点出发。函数的近代定义是给定一个数集A,假设其中的元素为x,对A中的元素x施加对应法则f,记作f(x),得到另一数集B,假设B中的元素为y,则y与x之间的等量关系可以用y=f(x)表示,函数概念含有三个要素:定义域A、值域B和对应法则f。其中核心是对应法则f,它是函数关系的本质特征。 [1]  函数,最早由中国清朝数学家李善兰翻译,出于其著作《代数学》。之所以这么翻译,他给出的原因是“凡此变数中函彼变数者,则此为彼之函数”,也即函数指一个量随着另一个量的变化而变化,或者说一个量中包含另一个量。
信息
提出者
莱布尼茨(G.W.Leibniz)
表示法
列表法、图像法、解析法
三要素
自变量、因变量、对应法则
应用学科
数学、计算机科学等
中文名
函数
外文名
function
提出时间
17世纪
表达式
y=f(x)
函数详细介绍
首先要理解,函数是发生在集合之间的一种对应关系。然后,要理解发生在A、B之间的函数关系不止且不止一个。最后,要重点理解函数的三要素。函数的对应法则通常用解析式表示,但大量的函数关系是无法用解析式表示的,可以用图像、表格及其他形式表示 [2]  。在一个变化过程中,发生变化的量叫变量(数学中,常量为x,而y则随x值的变化而变化),有些数值是不随变量而改变的,我们称它们为常量。自变量(函数):一个与它量有关联的变量,这一量中的任何一值都能在它量中找到对应的固定值。因变量(函数):随着自变量的变化而变化,且自变量取唯一值时,因变量(函数)有且只有唯一值与其相对应。函数值:在y是x的函数中,x确定一个值,y就随之确定一个值,当x取a时,y就随之确定为b,b就叫做a的函数值 [2]  。设A和B是两个非空集合,如果按照某种对应关系 ,对于集合A中的任何一个元素a,在集合B中都存在唯一的一个元素b与之对应,那么,这样的对应(包括集合A,B,以及集合A到集合B的对应关系f)叫做集合A到集合B的映射(Mapping),记作 。其中,b称为a在映射f下的象,记作: ; a称为b关于映射f的原象。集合A中所有元素的象的集合记作f(A)。则有:定义在非空数集之间的映射称为函数。(函数的自变量是一种特殊的原象,因变量是特殊的象) [2]  函数与不等式和方程存在联系(初等函数)。令函数值等于零,从几何角度看,对应的自变量的值就是图像与X轴的交点的横坐标;从代数角度看,对应的自变量是方程的解。另外,把函数的表达式(无表达式的函数除外)中的“=”换成“<”或“>”,再把“Y”换成其它代数式,函数就变成了不等式,可以求自变量的范围 [2]  。如果X到Y的二元关系 ,对于每个 ,都有唯一的 ,使得 ,则称f为X到Y的函数,记做: 。当 时,称f为n元函数 [2]  。输入值的集合X被称为f的定义域;可能的输出值的集合Y被称为f的值域。函数的值域是指定义域中全部元素通过映射f得到的实际输出值的集合。注意,把对应域称作值域是不正确的,函数的值域是函数的对应域的子集。计算机科学中,参数和返回值的数据类型分别确定了子程序的定义域和对应域。因此定义域和对应域是函数一开始就确定的强制进行约束。另一方面,值域是和实际的实现有关 [2]  。 单射函数,将不同的变量映射到不同的值。即:对于所有 和 ,当 时有 。满射函数,其值域即为其对应域。即:对映射f的对应域中之任意y,都存在至少一个x满足 y=f(x)。双射函数,既是单射的又是满射的。也叫一一对应。双射函数经常被用于表明集合X和Y是等势的,即有一样的基数。如果在两个集合之间可以建立一个一一对应,则说这两个集合等势 [2]  。 元素在的象就是f(x),他们所取的值为0 [2]  。函数f的图象是平面上点对 的集合,其中x取定义域上所有成员的。函数图象可以帮助理解证明一些定理。如果X和Y都是连续的线,则函数的图象有很直观表示注意两个集合X和Y的二元关系有两个定义:一是三元组(X,Y,G),其中G是关系的图;二是索性以关系的图定义。用第二个定义则函数f等于其图象 [2]  。
收起全文
精华内容
参与话题
问答
  • C语言函数

    万次阅读 多人点赞 2019-08-03 19:54:19
    每个C程序都至少有一个函数,即主函数main(),如果程序的任务比较简单,全部的代码都写在main()函数中,但是,在实际开发中,程序的任务往往比较复杂,如果全部的代码都写在main()函数中,main()函数将非常庞大臃肿...

     

    函数的概念

           每个C程序都至少有一个函数,即主函数 main() ,如果程序的任务比较简单,全部的代码都写在main()函数中,但是,在实际开发中,程序的任务往往比较复杂,如果全部的代码都写在main()函数中,main()函数将非常庞大臃肿,结构复杂,代码重复。

           我们可以根据程序的逻辑和任务的分工把代码划分到不同的自定义函数中,main()更关心业务逻辑和处理流程,需要执行具体任务的时候,调用这些自定义的函数就可以了。

           为了方使理解,我们把函数分为两种:一种是库函数,一种是自定义函数。

           库函数是C语言提供的,或系统提供的,实现了某些基本的功能,例如scanf、printf,在程序中可以直接使用。

           自定义函数是程序员为了完成某项任务而编写的函数,目的是为了实现某项的功能或让主程序更简洁。程序员在使用自定义函数之前,必须先声明和定义。

    自定义函数的声明

           自定义函数声明就是告诉编译器函数名称及如何调用函数,包括函数返回值的数据类型、函数名称、参数列表。

           有些程序员也将函数声明说成是函数原型,只是用词不同,意思是一样的。

           C语言中的声明函数的语法如下:

           

           返回值的数据类型return_type:函数执行完任务后,可以返回一个值,return_type是函数返回的值的数据类型,可以是int、char、double或其它自定义的数据类型。有些函数只执行任务而不返回值,在这种情况下,return_type用是关键字 void表示。

           无返回值的函数的声明语法如下:

           

           函数名称function_name:函数名称是标识符,命名规则与变量名称的命名规则相同。

           函数的参数列表parameter list:当函数被调用时,调用者需要向函数的参数传递值。参数列表包括参数的类型、顺序。参数列表是可选的,也就是说,函数可以没有参数。

           无参数的函数的声明语法如下:

     

           

           函数声明示例:

     

           

           声明了一个函数,返回值是int类型,函数名是checksc,函数只有一个参数int height,注意,函数的声明语句最后的分号不能少。

           如果把自定义函数比喻成工具,函数的声明就是这个工具的设计图纸。

    自定义函数的定义

           自定义函数是工具,如果想让这个工具能被使用,光有设计图纸还不行,要把工具制造出来,函数的定义就是这个工具的实体,提供了函数的实际主体,为了实现函数的功能,程序员为需要函数编写代码。

           C语言中的函数定义的语法如下:

           

           函数定义的return_type、function_name和parameter list必须与函数声明一致。

           函数主体包含为了完成任务需要执行语句的集合,放在花括号内。

           示例:

           

           注意,不要在函数定义后面加分号,以下是错误的,初学者容易犯这种错误。

           

     

    自定义函数声明和定义的方式

          如果自定义函数只在调用者程序中使用,可以在调用者程序中声明和定义,声明一般为调用者程序的上部,定义一般在调用者程序的下部,这并不是C语言的规定,而是为了让程序更方便阅读,程序员约定的写法。

           自定义函数在调用者程序中声明和定义的示例(book45.c):

           

           在book45.c中,判断超女身材的函数checksc不是公共的功能,只是选秀程序使用,所以声明和定义在book45.c中。

           如果自定义函数是一个公共的功能模块,例如比较两个数的大小,就可以在其它的头文件中声明(如_public.h),调用者程序需要用#include预处理指令包含该函数声明的头文件。

           如果自定义函数是一个公共的功能模块,就可以在其它的程序文件中定义(如_public.c),编译的时候,要把调用者程序和自定义函数的程序文件一起编译。

          在以下的示例中,函数max在_public.h头文件中声明,在_public.c程序文件中定义,在book46.c程序中被调用。

           自定义函数的头文件(_public.h):

           

           自定义函数的程序文件(_public.c):

           

           调用者程序文件(book46.c)

           

           编译命令如下:

           

           注意:

           1)在book46.c的第6行 ,这里包含头文件是用双引号,不是尖括号<>。一般来说 #include <> 用于包含C语言提供的库函数的头文件,#include ""用于包含程序员自定义的头文件。

           2)编译调用者程序的时候,把调用者程序和自定函数的程序文件一起编译。否则编译的时候会出现以下错误。

     

           

          正确的编译指令应该是gcc -o book46 book46.c _public.c

           3)自定义函数的头文件_public.h和_public.c的命名没有规定,由程序员自己命名,就像变量的命名一样,为了增加程序的可读性,尽可能采用一些有意义的名称。

    库函数

           C语言提供了一些已声明和定义的函数,调用这些函数可以完成一些基本的功能,我们把这些函数称为C 标准函数(C standard library),简称库函数,例如printf、scanf、memset、strcpy等。CC语言的库函数有几百个,常用的不过十分之二三,不需要记住,在以后的章节中我将详细介绍一些常用库函数的使用,用多了就熟了。

           C语言标准库函数的声明的头文件存放在/usr/include目录中,如下:

           <asset.h>     <ctype.h>       <errno.h>     <float.h>    <limits.h>

           <locale.h>    <math.h>     <setjmp.h>   <signal.h>     <stdarg.h>

           <stddef.h>   <stdlib.h>   <stdio.h>      <string.h>      <time.h>

           C语言库函数的定义的文件是/usr/lib/gcc/x86_64-redhat-linux/4.4.4/libgcc.a(不同编译器的版本目录名有所不同),这是一个打包好的静态链接库文件,静态链接库的知识我们以后再介绍。

           我们在用gcc编译程序的时候并没有把libgcc.a包含进来,那是因为gcc编译器缺省会包含它,但是,程序员自定义函数的头文件和程序文件就没有这种待遇,需要手工的包含进来。

    需要包含哪些头文件

           我们在使用库函数的时候,如果不包含它的头文件,编译时会出现警告,如下:

           该包含哪些头文件呢?有两种方法,一是上百度上查资料,二是使用Linux系统提供的帮助,以strcpy函数为例,在命令行下输入man strcpy回车,如下:

           

           man显示了函数的声明的头文件(第5行),函数的参数、使用方法和返回值。

           注意了,如果程序中使用的没有包含它头文件的库函数,编译的时候不一定是警告,也可能是报错,函数无法识别等,这个要看编译器,不同C语言的编译器不一样。

    调用函数的方法

           库函数是系统声明和定义的,是现成的工具。自定义函数是程序员自己声明和定义的,是程序员补充的工具,不管是现成工具的还是补充的工具,都是工具,对使用者来说都一样,没有区别。

           在C语言中,函数的调用非常灵活,可以独占一行语句,也可以当成常量赋值给变量,也可以当成函数的参数。

           如果函数的返回值是void,表示该函数的的任务以完成某项功能为主,一般用单行书写,独占一条语句。

           如果函数的返回值不是void,如果单行书写,表示不关心它的返回值,也可以当成常量用于任何表达式中。

           例如:

           

    函数调用的过程

           当程序调用函数时,程序控制权会转移给被调用的函数。被调用的函数执行函数体的代码,当函数的返回语句被执行时,或到达函数的结束括号时,就把程序控制权交还给调用者程序。

           示例(book47.c)

           

           运行结果

           

     

    函数参数的传递

          关于函数的参数,在很多教程中有很多说法,如“形参”、“实参”、“值传递”、“地址传递”、“引用”等,这些说法把简单的概念复杂化了,大家不必理会。

          函数的参数可以理解为函数的局部变量,参数传递就是调用者程序把变量(或常量)的值复制一份给函数的参数,简单说来就是复制的过程。一旦完成数据的复制,调用者程序的变量和函数的参数就再也没有瓜葛了,所以,在函数调用的过程中,函数的参数的值发生改变并不会影响调用者程序的变量的值。

          我们在调用函数的时候,不关心函数参数的名称,函数参数的名称是函数自己的事情,只在函数内部使用,与调用者无关。

           示例(book48.c)

           

           运行结果

           

    const约束

           const 是 constant 的缩写,意思是“恒定不变的”!它是定义只读变量的关键字,或者说 const 是定义常变量的关键字。用 const 定义常变量的方法很简单,就在通常定义变量时前面加 const 即可,如:

           const  int  a = 10;

           那么用 const 修饰后和未修饰前有什么区别呢?它们不都等于 10 吗?

           用 const 定义的变量的值是不允许改变的,即不允许给它重新赋值,即使是赋相同的值也不可以。所以说它定义的是只读变量。这也就意味着必须在定义的时候就给它赋初值。

           在变量前加const约束,主要用于定义函数的参数,表示该参数在函数中是只读取,不允许改变,如果函数中试图改变它的值,编译的时候就会报错。

           例如:

           

           函数max在声明的时候,参数a和b都加了const约束,在函数中,a=10;和b=20;这两代码试图改变a和b的值。编译的时候如下:

     

           

          编译无法通过。

    应用经验

    1. 如果寻找函数

           在我的课程中,会介绍常用的库函数,但也有漏掉的。查资料是程序员的基本技能。

           例如要查找C语言复制字符串功能的函数,在百度上输入“C语言复制字符串”搜索就可以了,你想查什么就输入什么。

     

           

           然后,打开多几个网页看看,基本上就差不多了。

           注意一个问题,网上的内容太多太杂乱,重点关注百度百科的文章。

           1)测试函数的功能

           要使用函数,只需要关注它需要包含的头文件、函数名、返回值、参数的数据类型和参数的顺序,不必关心参数的名称。

           以strcpy函数为例,函数的声明如下。

           char *strcpy(char *dest, const char *src);

           函数名:strcpy

           返回值:返回dest,一般没用,不理它。

           第一个参数是目标字符串;第二个参数是源字符串,有const约束。

           写代码测试一下:

             char strname[50];

             strcpy(strname,"西施");

             printf("=%s=\n",strname);

           然后,看看输出的结果是不是“=西施=”,用=号夹住输出的内容是为了看清楚有没有其它的字符。

    版权声明

    C语言技术网原创文章,转载请说明文章的来源、作者和原文的链接。

    来源:C语言技术网(www.freecplus.net

    作者:码农有道

    如果这篇文章对您有帮助,请点赞支持,或在您的博客中转发我的文章,谢谢!!!

    如果文章有错别字,或者内容有误,或其他的建议或意见,请您留言指正,非常感谢!!!

    展开全文
  • 函数

    千次阅读 2020-05-12 02:48:02
    函数的定义 功能:包裹一部分代码,实现某一个功能,达成某一个功能. 特点;可以反复调用 基本格式: 定义一个函数 def 函数名(): code1 code2 调用函数 函数名() 函数名参考变量的命名. 鸵峰命名法: 1:大驼峰命名法:每个...

    函数 : 功能(包裹一部分代码,实现某一个功能,达成某一个目的)

    “”"
    特点:可以反复调用,提高代码的复用性,提升开发效率,便于后期维护
    “”"

    函数的基本格式

    #定义一个函数
    def 函数名():
    code1
    code2
    #调用函数
    函数名()

    函数的定义处

    def func():
    print(“我是一个函数”)

    函数的调用处

    func()

    函数的名字

    “”"
    函数的命名
    字母数字下划线,首字符不能为数字
    严格区分大小写,且不能使用关键字
    函数命名有意义,且不能使用中文哦

    驼峰命名法:
    (1) 大驼峰命名法: 每个单词的首字符都大写 mycar => MyCar (面向对象当中,定义类class)
    (2) 小驼峰命名法: 除了第一个单词小写之外,剩下每个单词首字符大写 mycar => myCar (函数,变量)
    命名一个函数 通常用_拼接的形式,组装不同的单词
    mycar => my_car
    symmetric_difference
    “”"

    函数的定义处(99乘法表)

    def cfb_99():
    for i in range(1,10):
    	for j in range(1,i+1):
    		print("%d*%d=%2d " % (i,j,i*j) , end="")
    	print()
    

    函数的调用

    cfb_99()

    打印10遍
    for i in range(10):
    cfb_99()

    ### 函数的参数 : (参数是配合函数运行时,需要用到的值)

    “”"
    参数的种类:
    (1) 形参: 形式上的参数 , 在函数的定义处
    (2) 实参: 实际上的参数 , 在函数的调用处

    形参的种类:
    普通(位置)形参,默认形参,普通收集参数,命名关键字参数,关键字收集参数
    实参的种类:
    普通实参,关键字实参

    遵循的原则:
    调用参数的时,形参和实参必须一一对应,否则报错
    “”"

    (1) 普通形参

    函数的定义处(hang , lie 是普通形参(位置形参))

       	def star(hang,lie):
       	i = 0
         while i<hang:
          	j = 0
    	     while j<lie:
    	      	print("*",end="")
    		j+=1
    	print()
    	i+=1
    

    函数的调用处

    “”“4,9 是实参,是普通实参”""
    star(4,9)

    (2)默认形参(hang和lie身上带有默认值)

     def star(hang=10,lie=10):
    i = 0
     while i<hang:
    	   j = 0
    	    while j<lie:
    			print("*",end="")
    	          	j+=1
            	print()
    	i+=1
    

    “”"
    调用时,如果不给实际参数,默认使用自带的值进行调用
    调用时,如果给实际参数,那么使用实参来进行调用
    “”"
    star()

    print("<====>")

    (3)普通形参 + 默认形参(默认形参必须放到普通形参之后)

    def star(hang,lie=10):
    i = 0
    while i<hang:
    	j = 0
    	while j<lie:
    		print("*",end="")
    		j+=1
    	print()
    	i+=1
    

    star(20)

    (4) 关键字实参

    def star(hang,lie=10):
    i = 0
    while i<hang:
    	j = 0
    	while j<lie:
    		print("*",end="")
    		j+=1
    	print()
    	i+=1
    

    关键字实参

    “”“调用函数时,关键字实参顺序可以任意调整的”""
    star(hang=3,lie=8)
    star(lie=8,hang=3)

    (5) 普通实参

    def star(hang,a,b,c,lie=10):
     i = 0
    while i<hang:
    j = 0
    while j<lie:
    print("*",end="")		j+=1
    	print()
    	i+=1
    

    调用处

    star(3,3,4,5,lie=4) + 关键字实参
    “”“关键字实参必须跟在普通实参的身后”""

    ### 区分 默认形参 和 关键字实参

    函数的定义处 (默认形参在函数的定义处)

    def lol_gameteam(top="魏富强",middle="李天照",bottom="尉翼麟",jungle="黄俊",support="神秘男孩"):
    print("上单选手:{who}".format(who=top))
    print("中单选手:{who}".format(who=middle))
    print("下路选手:{who}".format(who=bottom))
    print("打野选手:{who}".format(who=jungle))
    print("辅助选手:{who}".format(who=support))
    

    函数的调用处 (关键字实参在函数的调用处)

    lol_gameteam()
    print("<=====>")
    lol_gameteam(top="陈宁波",middle="宋青林",bottom="刘思敏",jungle="王振")
    

    ### 收集参数

    收集参数:
    (1) 普通收集参数 :
    在参数的前面加上一个*,代表的是普通收集参数.
    作用:收集多余的没人要的普通实参,构成一个元组
    def func(*args):
    pass
    args => arguments(参数)

    计算任意个数的累加和

    def mysum(*args):
    total = 0
    for i in args:
    	total += i
    print(total)
    mysum(1,2,3,4,5,6,7,8,9,1111)
    
    
    
    (2) 关键字收集参数
    在参数的前面加上两个**,代表的是关键字收集参数
    作用:收集多余的没人要的关键字实参,构成一个字典
    
    def func(**kwargs):
    	pass
    	kwargs => keyword arguments
    

    任意字符串的拼接

    “”"

    班长:张恒

    班花:刘思敏

    吃瓜群众:黄俊,王振…

    “”"

    def func(**kwargs):
    strvar = ""
    strvar2 = ""
    dic = {"monitor":"班长","class_flower":"班花"}
    print(kwargs)
    for k,v in kwargs.items():
    	# print(k,v)
    	# 判断键在字典中,在进行获取
    	if k in dic:
    		strvar += dic[k] + ":" + v	+ "\n"		
    	# 如果不在,那就是吃瓜群众
    	else:
    		strvar2 += v + " , "
    print(strvar.strip())
    print("吃瓜群众:" + strvar2.strip(" , ") + "......")
    func(monitor="张恒",class_flower="刘思敏",hj="黄俊",wz="王振")
    

    ### 命名关键字参数

    “”"
    (1) 在*号后面定义的参数是命名关键字参数
    def func(参数1,参数2,星号,参数3)
    (2) 在普通收集 和关键字收集参数之间的,是命名关键字参数
    def func(*args,参数,**kwargs)

    如果是命名关键字参数,必须使用关键字实参的形式调用;

    “”"

    (1) 定义方式一

    def func(a,b,*,c):
    		print(a,b)
    		print( c )
    func(1,2,c=3)
    

    (2) 定义方式二

    def func(*args,dd,**kwargs):
    		print(args)
    		print(kwargs)
    		print(dd)
    func(1,2,3,4,4,5,6,a=1,b=2,c=3,dd="abc")
    

    关于 * 和 ** 的使用方法

    “”"
    在函数的定义处, * 和 ** 用来接收数据,*打包成一个元组,**打包成个字典
    在函数的调用处, * 和 ** 用来解包数据,*一般应用在列表或元组,**一般用在字典
    “”"

    * 一个星调用处的语法

    def func(a,b,*,c,d):
    	print(a,b)
    	print(c,d)
    

    函数的调用处

    func(1,2,c=3,d=4)
    或
    lst = [1,2]
    func(*lst,c=3,d=4)
    解释*lst <=> 把列表里面的每一个元素都单独拿出来,
    当成参数赋值给func进行调用
    

    ** 二个星调用处的语法

    func(1,2,c=3,d=4)
    或
    dic = {"c":3,"d":4}
    func(1,2,**dic)
    **dic <=> 把字典里面的键值对拿出来,
    转化成关键字实参的形式,当成参数赋值给func进行调用;
    

    综合

    “”"
    定义处的星号用法 和 调用处的*号用法 是一对相反操作
    一个是用来打包,一个是用来解包
    优点:控制了参数的个数.
    “”"

    ### 参数的顺序

    形参顺序
    普通形参 -> 默认形参 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数

    收集所有实参

    def func(*args,**kwargs):
    	pass
    

    参数练习

    def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    
    def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
    以上两个函数 打印结果
    (一)
    f1(1, 2) # a =1 b=2 c=0 args=() kw={}
    f1(1, 2, c=3) # a=1 b=2 c=3 args=() kw={}
    f1(1, 2, 3, 'a', 'b') # a=1 b=2 c=3 args=(a,b) kw={}
    f1(1, 2, 3, 'a', 'b', x=99) # a=1 b=2,c=3 args=(a,b) kw={x:99}
     f2(1, 2, d=99, ext=None) # a=1,b=2,c=0 ,d=99,{ext:None}
    (二)
    args = (1, 2, 3, 4)
    kw = {'d': 99, 'x': '#'}
    f1(*args, **kw) # a=1,b=2,c=3,args=(4,) kw={d:99,x:#}
    (三)
    #myargs = (1, 2, 3)
    mykw = {'d': 88, 'x': '#'}
    f2(1,2,3,d=88,x=#)
    f2(*myargs, **mykw) # a = 1,b=2,c=3,d=88 kw={x:#}
    (四)
    def f1(a, b, c=0, *args,d,**kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    print(d)
    
    f1(1,2,3, 'a', 'b',d=67, x=99,y=77)
    #a =1,b=2,c=3 args=(a,b) kw={x:99,y:77} d=67
    

    ### return 自定义返回值

    “”"
    函数可以自定义返回值,通过return ,return会把这个值返回到函数的调用处
    (1) return + 返回值 后面出了可以接6大标准数据类型之外,还可以返回函数和类对象,
    如果没有定义任何返回值,默认返回的是None

    (2) 在函数中,如果执行了return , 意味着立刻终止函数,后面的代码通通不执行
    “”"

    (1) return + 可以返回的类型

    def func():
    # return 100
    # return 3.45
    # return "我爱你,亲爱的老婶"
    # return [1,2,3]
    # return {"a":1,"b":2}
    # 没有定义任何返回值,默认返回的None
    res = func() # res = 100
    print(res)
    

    (2) 遇到return 之后,意味着立刻终止函数,后面的代码不执行

    def func():
    	print("王振")
    	print("朱家熠")
    	return "尉翼麟"
    	print("黄俊")
    	print("陈宁波")
    res = func() # 尉翼麟
    print(res)
    

    注意点: 遇到return 立刻终止函数;

    def func():
    for i in range(1,10):
    	if i == 5:
    		return 15
    	print(i)
    res = func()
    print(res)
    

    (3) 模拟一个计算器 + - * /

    def calc(sign,num1,num2):
    	if sign == "+":
    		res = num1 + num2
    	elif sign == "-":
    		res = num1 - num2
    	elif sign == "*":
    		res = num1 * num2
    	elif sign == "/":
    		if num2 == 0 :
    			return "除数不能为0"
    			res = num1 / num2
    	else:
    		return "抱歉,这个值我不会算~"
    	
    	return res
    res = calc("+",10,11)
    res = calc("-",10,11)
    res = calc("*",2,3)	 res = calc("/",6,2)
    res = calc("/",6,0)
    res = calc("&",3,2)
    print(res)
    

    ### 全局变量 和 局部变量

    局部变量 : 在函数内部定义的变量就是局部变量 (局部命名空间)
    全局变量 : 在函数外面定义的变量 或者 在函数内部用global关键字定义是全局变量 (全局命名空间)

    作用域:作用的范围
    局部变量的作用的范围仅仅限定在函数的内部
    全局变量的作用的范围横跨整个文件

    生命周期:

    内置命名空间 > 全局命名空间 > 局部命名空间
    内置变量 > 全局变量 > 局部变量 
    

    (1) 局部变量

    def func():
    	# 定义一个局部变量
    	a = 1
    	# 获取局部变量
    	print(a)
    	# 修改局部变量
    	a = 20
    	print(a)
    func()
    print(a) error 无法获取局部变量的值
    

    (2) 全局变量

    #1.定义全局变量
    c = 100
    #2.获取全局变量
    print(c)
    #3.修改全局变量
    c = 200
    print(c)
    
    在函数内部定义全局变量 global
    def func():
    	# 标记d这个变量是一个全局变量 
    	global d
    	d = 400
    	print(d)
    func()
    print(d)
    

    (4) 在函数内部可以修改全局变量

    e = 500
    def func():
    	global e
    	e = 600
    	print(e)
    func()
    print(e)
    

    global 总结:
    如果函数外部有这个全局变量,在函数内部使用global关键字,可以修改全局变量
    如果函数外部没有这个全局变量,在函数内部使用global关键字,可以定义全局变量

    在函数内部可以直接获取全局变量
    但是无法直接修改全局变量,需要通过global

    ### 函数名的使用

    #python中的函数可以像变量一样,动态创建,销毁,当参数传递,作为返回值,叫做第一类对象,其他语言不能比拟功能有限

    1.函数名是个特殊的变量,可以当做变量赋值

    def func1():
    	print("我是func1")
    	return 111
    #res = func1()
    #print(res)
    

    动态创建函数

    print(func1)
    func = func1
    func()
    

    动态销毁函数

    del func
    func()
    

    2.函数名可以作为容器类型数据的元素

    def func2():
    	print("我是func2")
    def func3():
    	print("我是func3")
    def func4():
    	print("我是func4")	
    		return "func4"
    lst = [func2,func3,func4]
    	for i in lst:
    	i()
    

    3.函数名可以作为函数的参数

    def myfunc(f):
    	res = f()
    	print(res)
     f <=> func4  <==> res = func4() print(res)
    myfunc(func4)
    

    4.函数名可作为函数的返回值

    def myfunc2(f):
    	return f
    f2 = myfunc2(func4) # f2 = func4
    print(f2)
    f(2)
    

    —doc— 或者help查看文档

    模拟一个吃猪大肠的过程

    def eat_big_chang(something):
    '''
    功能:模拟一个吃猪大肠的过程
    参数:吃什么?
    返回值:吃没吃完?
    '''
    	print("step1=>先把{}洗一洗".format(something))
    	print("step2=>找肠子头放嘴里")
    	print("step3=>使劲嘬")
    	print("step4=>吃完了,满意的放下肠子")
    	return "真好吃~"res = eat_big_chang("大肠")
    res=eat_big_chang('大肠'')
    print(res)
    

    #函数.–doc– => 获取函数的帮助文档
    print(eat_big_chang.____-doc_____)

    ### locals 和 globals (了解)

    locals 获取当前作用域中的所有内容

    “”"
    locals 如果在函数外,调用locals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
    locals 如果在函数内,调用locals(),获取的是调用之前的所有变量,返回字典,局部空间作用域
    “”"

    例子1

    a = 1
    b = 2
    res = locals()
    c = 3
    print(res)
    d = 4
    

    例子2

    a = 1
    def func():
    	b = 2
    	res = locals()
    	c = 3
    	print(res)
    	d = 4
    func()
    

    globals 获取全局作用域的所有内容

    “”"
    globals 如果在函数外,调用globals(),获取的是打印之前的所有变量,返回字典,全局空间作用域
    globals 如果在函数内,调用globals(),获取的是调用之前的所有变量,返回字典,全局空间作用域
    “”"

    例子3

    a = 5
    b = 6
    res = globals()
    c = 7
    print(res)
    

    例子4

    a =10
    def func():
    	b = 11
    	c = 12
    	res = globals()
    	d= 13
    	print(res)
    ff = 30
    func()
    zz = 50
    

    ### globals 返回的是系统的字典

    1. 正常方式定义变量

    zhangsan = “112233”

    2. 通过系统的全局字典添加键值对,可以动态创建全局变量

    dic = globals()
    print(dic)

    传递字符串,创建一个变量

    k = “wangwen”
    dic[k] = “英俊潇洒的人”
    print(wangwen)

    3.批量创建全局变量,在函数中,通过字符串

    def func():
    	dic = globals()
    	for i in range(1,6):
    	dic["p%d" % (i)] = i
    
    func()
    print(p1)
    print(p2)
    print(p3)
    print(p4)
    print(p5)
    
    展开全文
  • 函数----自定义函数

    千次阅读 2019-05-21 07:38:45
    print(len(s)) # 用len()函数计算,len()函数属于内置函数。返回结果为:7 用for有限循环语句计算 i = 0 for k in s: # 用for有限循环语句计算 i += 1 print(i) # 返回结果为:7 函数的自定...
    1. 前言
      目前所学的方式去计算“s = ‘人生若只如初见’”的长度。
    1. 用len()函数计算
    s = '人生若只如初见'
    print(len(s))  # 用len()函数计算,len()函数属于内置函数。返回结果为:7
    
    1. 用for有限循环语句计算
    i = 0
    for k in s:  # 用for有限循环语句计算
        i += 1
    print(i)  # 返回结果为:7
    
    1. 函数的自定义:def
      内置函数:Python本身存在的,可直接使用的
      自定义函数:编程者自己为了方便调用信息,自己给代码定义的函数
      自定义函数格式:def + 一个空格 + 函数名(与变量名的规格一致) + 一对括号() + 冒号:
      如下定义一个计算字节长度的函数的定义格式,函数名即my_len
    s = '人生若只如初见'
    # 自定义/声明函数,该函数的名字就是my_len,该函数需要被调用时才使用
    
    
    def my_len():
        i = 0
        for k in s:  # for语句
            i += 1
        return i  # 返回一个值,此处必须需要有return,下面调用的函数length才能打印出结果
    
    
    length = my_len()  # 调用函数my_len()
    print(length)  # 返回结果为:7
    
    1. 函数的调用
      定义/声明好的函数可以在任何需要它的地方被多次调用;
      不能修改、只输出结果、函数的结果不能被用于赋值;
      函数的嵌套调用:函数与函数之前的代码是不会互相影响的。
    def func():
        return {'k':'v'}  # 一个返回值
        return 1  # 遇到return,结束语句
    
    
    print(func())  # 返回结果为:{'k': 'v'}(在此处调用了函数func())
    
    # 函数的嵌套调用:函数与函数之前的代码是不会互相影响的
    def f1(l):
        for i in l:
            print(l)
    def f2(l):
        for i in l:
            print(l)
    
    
    f1([1, 2, 3, 'rt5ry'])  # 调用函数f1
    f2(['A','B','C'])  # 调用函数f2,返回结果为:循环打印括号一名的内容
    

    在这里插入图片描述

    1. 函数的返回值
      return 是一个关键字,我们管写在return后面的值叫“返回值”;不写return的情况下,会默认返回一个None。
      返回值的三种情况:
    1. 没有返回值,
      a. 不写return;
      b. 只写return,后面不写其他内容(因为一旦遇到return,结束整个函数);
      c. return与return None的功能一致。
    2. 返回一个值,
      a. return后面写上要返回的内容即可;
      b. return和返回值之间要有空格,可以返回任意数据类型的值;
      c. 如果在一个程序中遇到了多个return,只执行第一个,后面的都不执行。
    3. 返回多个值
      a. 只写一个return;
      b. 有多少返回值则相应的用多少个变量接收;
      c. 返回多个值可以用一个变量接收,得到的是一个元组。
    # 函数无返回值的自定义函数
    s = '人生若只如初见'
    
    
    def my_len():
        i = 0
        for k in s:  # for语句计算
            i += 1
        print(i)  # 返回结果为:7
    
    #  一个返回值
    def func():
        return {'k':'v'}  # 一个返回值
        return 1  # 遇到return,结束语句
    
    
    print(func())  # # 返回结果为:{'k': 'v'}
    
    # 多个返回值
    def func():
        return 1,2  # 多个返回值
    r = func()
    
    
    print(r)  # 返回结果为:(1, 2)
    
    1. 函数的参数
    1. 参数的传递内容
      a. 没有参数:定义函数和调用函数时,函数的括号里面不写内容
      b. 一个参数:传什么内容就是什么
      c. 多个参数:参数可以传递多个,多个参数之间用逗号分割。
    # 函数的参数
    def my_len(s):  # 自定义函数只需要0个参数,接收参数;形式参数(形参)
        i = 0
        for k in s:
            i += 1
        return i
    
    
    ret = my_len(s)  # 传递参数(传参)
    ret = my_len('可以传递列表,元组,字符串等')  # 计算括号内容的长度,实际参数(实参)
    print(ret)  # 返回结果为:14
    
    1. 实参:按照位置传参数、按照关键字传参(不能给同一个变量传多个值)。3
    2. 形参:

    a. 位置参数:必须传,多传或少传都会报错。

    # 按照位置传参数
    def my_sum(a, b):  # 定义一个求和函数
        res = a+b  # res及result的简写
        return res
    
    
    s = my_sum(1, 2)  # 计算1+2的结果,# 调用函数my_sum
    print(s)  # 返回结果为3
    

    b. 默认参数:也叫关键字参数,可以不传,若不传参则使用默认参数;若使用传参则使用传参的参数。

    # 按照关键字传参(即默认参数传参)
    def classmate(name, sex='boy'):
        print('%s:%s'%(name, sex))
    
    
    classmate('Bob')  # 调用函数classmate
    classmate('Alice', 'girl')  # 等同于classmate(sex='girl', name='Alice')返回结果为:Alice:girl
    classmate('Alex')
    

    c. 可以无限多的接收参数,动态参数的值是可修改的;可以接收空的动态参数,不会报错。

    # 动态参数的种类:
        *args:接收的是按照位置传参的值,组织成一个元组;
               在参数前加*,约定俗成默认用*args。
        **kwargs:接收的是按照关键字传参的值,组织成一个字典;
                  在参数前加**,约定俗成默认用**kwargs。
    共同点:可以接收任意多个参数。
    
    def my_sum(*args):  # 定义一个动态参数,计算列表元素之和。
        n = 0
        for i in args:
            n += i
        return n
    
    
    print(my_sum(1, 2))  # 返回结果为:3
    print(my_sum(1, 2, 3))  # 返回结果为:6
    print(my_sum(1, 2, 3, 4))  # 返回结果为:10
    
    def func(*args, li=[]):  # 按照关键字传参,无法传任意多个动态参数
        print(args, li)
    
    
    func(1, 2, 3, 'str', ['list', 1, 2, 3, 4])
    func(1, 2, 3, 'str', li=['list', 1, 2, 3, 4])
    
    # 结合*args和**kwargs使用
    def func(*args, **kwargs):  # *args和**kwargs的位置不能互换
        print(args, kwargs)
    
    
    func(1, 2, 'str', name='Alex', job='teacher')  
    # 返回结果为:(1, 2, 3, 'str') {'name': 'Alex', 'job': 'teacher'}
    func(1, 2, 3, 'str', ['list', 1, 2, 3, 4])  
    # 返回结果为:(1, 2, 3, 'str', ['list', 1, 2, 3, 4]) {}
    
    1. 定义函数的时候:
      a. 位置参数:直接定义参数,如下例子定义classmate函数的位置参数name
      b. 默认参数:也可叫关键字参数,格式为参数名='默认的值
      c. 动态参数:可以接受任意多个参数
      (1)参数名之前加*,习惯参数名args,
      (2)参数名之前加**,习惯参数名kwargs,
      (3)args必须定义在**kwargs之前。
      d. 定义顺序:位置参数 -> 动态参数
      args -> 默认参数(关键字参数) -> 动态参数**kwargs,若顺序相反则会报错。
    2. 调用函数的时候:
      a. 按照位置传参:直接写参数的值,如下例子调用classmate函数的位置参数Alice等name值
      b. 按照关键字传:格式应为 关键字=值,如例子调用classmate函数的关键字参数girl等值
    def func(**kwargs):  # 按照关键字传参,无法传任意多个动态参数
        print(kwargs)
    # 动态参数,key的标准是数字不能开头,按照变量命名的标准
    
    
    func(name='Alex', height=175, weight=130)  # 返回结果为:{'name': 'Alex', 'height': 175, 'weight': 130}
    func(a=1, b=2)  # 返回结果为:{'a': 1, 'b': 2}
    func(a=1)  # 返回结果为:{'a': 1}
    
    1. 动态参数的另一种传参方式
    def func(*args):  # (2)站在形参的角度上,给变量添加一个*,就是组合所有在实参被打散后传来的值。
        print(args)
    
    
    func(1, 2, 3, 4, 5)  # 动态参数的前一种表现形式
    li = [1, 2, 3, 4, 5]  # 列表,返回值的结果
    func(li[0], li[1] ,li[2], li[3], li[4])
    func(*li)  # (1)站在实参的角度上,给一个序列上添加一个*,就是将此序列按照顺序打散,
    
    # 动态参数**kwargs
    def func(**kwargs):
        print(kwargs)
    
    
    func(a=1, b=2)  # 返回值的结果为:dic = {'a':1, 'b':2}
    dic = {'a':1, 'b':2}
    func(**dic)  # 返回值的结果为:dic = {'a':1, 'b':2}
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    7. 函数的注释
    def func():
    ‘’’
    先介绍这个函数实现的大概功能
    参数1:作用,若数据类型等(若没有参数可不写)
    参数2
    参数3
    ……
    :return:是字符串或者列表的长度等
    ‘’’
    pass

    1. 命名空间
    1. 全局命名空间----与我们写的代码,而非函数中的代码有关
      a. 是在程序中从上到下被执行的过程中依次加载进内存的,
      b. 放置了我们设置的所有变量名和函数名。
    2. 局部命名空间----与函数有关
      a. 就是函数内部定义的名字,
      b. 当调用函数的时候,才会产生这个名称空间,随着函数执行的结束,这个命名空间就又消失了。
    3. 内置命名空间----与Python解释器有关
      a. Python解释器(如Pycharm)本身所涵括的,可以直接使用的;如print(), input()等;
      b. 内置的名字在启动解释器的时候被加载到内存里的。

    在局部命名空间:可以使用全局、也可使用内置的命名空间
    在全局命名空间:可以使用内置命名空间,但不可使用局部命名空间
    在内置命名空间:不可使用全局或局部的命名空间

    # 在正常情况下会直接使用内置的名字;但当我们在全局定义了和内置名字空间中同名的名字时,会使用全部的名字。
    def max(l):
        print('in max func')  # 返回值为:in max func
    
    
    print(max([1, 2, 3]))  # 返回值为:None
    
    #使用全局命名
    def input():
        print('in input now')
    
    
    def func():
        input()
    
    
    func()
    # 返回值为:in input now
    
    # 使用局部命名
    def input():
        print('in input now')
    
    
    def func():
        input = 1  # 局部命名空间
        print(input)
    
    
    func()
    # 返回值为:1
    
    # 函数名() = 函数的内存地址()
    # 函数名 + 括号表示一个函数的执行;而单单函数名则指的是一个函数的内存地址。
    def func():
        print(input)
    
    
    print((func))  # 返回值为:函数体所在的内存地址<function input at 0x0000026E896DD268>
    
    # 两个独立的局部名字空间不可互相调用
    def func1():
        a = 1
    
    
    def func2():
        print(a)  # 返回值为:报错
    

    在这里插入图片描述

    1. 作用域
      全局作用域----作用在全局:内置和全局名字空间中的名字都属于全局作用域;
      局部作用域----作用在局部:函数(即局部名字空间中的名字属于局部作用域)。
    a = 1  # 属于全局作用域
    def func():
        print(a)
    
    
    func()
    # 返回值为:1
    
    '''
    

    对于不可变数据类型,在局部可查看全局作用域中的变量,但是不能直接修改;
    若想要修改,需要在程序一开始时添加global声明;
    如果在一个局部(函数)内声明了一个global变量,则此变量在局部的所有操作对全局有效。

    a = 1  # 属于全局作用域
    def func():
        global a
        a += 1
    
    
    func()
    print(a)
    # 返回值为:2 (若将上述的global a去掉,运行函数则会保存)
    
    # 使用locals查看局部作用域的变量
    a = 1
    b = 2
    
    
    def func():
        x = 'aaa'
        y = 'abc'
        print(locals())
    
    
    func()  # 返回值为:{'x': 'aaa', 'y': 'abc'}
    
    # 使用globals查看全局作用域的变量
    a = 1
    b = 2
    
    
    def func():
        x = 'aaa'
        y = 'abc'
        print(locals())
    
    
    func()  # 返回值为:{'x': 'aaa', 'y': 'abc'}
    print(globals())  # 可以查看全局命名空间以及内置命名空间的内容
    

    globals永远打印全局的名字(为了代码安全,尽量避免使用);
    locals输出的内容根据其所在的位置输出。

    a = 1
    b = 2
    print(locals())  # 可以查看全局命名空间以及内置命名空间的内容
    print(globals())  # 可以查看全局命名空间以及内置命名空间的内容
    
    1. 函数的嵌套和作用域链
      函数的嵌套定义
      在这里插入图片描述
      内部函数可以使用查看外部函数的变量
      内部函数不可以直接修改外部函数
    
    def max(a, b):
        return a if a > b else b
    '''
    函数的嵌套调用
    函数实现的功能:两个值比较大小并输出最大值
    :return:返回最大值
    '''
    
    
    def the_max(x, y, z):  # 函数的嵌套调用
        c = max(x, y)
        return max(c, z)
    
    
    print(the_max(5, 8, 6))  # 返回结果为:8
    
    # 函数的嵌套调用
    def outer():
        a = 1
        def inner():
            b = 2
            print(a)
            print('inner')
            def inner2():
                print(a, b)
                print('inner2')
            inner2()
        inner()
    outer()
    

    nonlocal:只能用于局部变量,对上层中离当前函数最近的一层的局部变量进行声明,对全局无效;
    声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量。

    a = 1
    def outer():
        a = 1
        def inner():
            b = 2
            print(a)
            print('inner')
            def inner2():
                nonlocal a # 声明一个离函数inner2最近一层的局部变量
                a += 1
                print('inner2')
            inner2()
        inner()
        print('局部:', a)
    outer()
    print('全局:', a)
    
    # 函数名的本质
    def func():
        print(123)
        
        
    func2 = func  # 函数名可以赋值
    func2()
    
    
    def func():
        print(123)
        
        
    func2 = func  # 函数名可以赋值
    func2()
    l = [func, func2]  # 函数名可以作为容器类型
    print(l)
    for i in l:  # 循环打印func和func2
        i()
    
    def func():
        print(123)
    
    
    def abc(l):
        l()
    
    
    abc(func)  # 函数名可以作为函数的参数
    
    def func():
        print(123)
    
    
    def abc(l):
        l()
        return l  # 函数名可以作为函数的返回值
    
    
    val = abc(func)
    val()
    
    1. 默认参数的陷阱
      如果默认参数的值是一个可变数据类型,那么每一次调用函数的时候,如果不传值就共用这个数据的资源。
    # 列表(可变数据类型)
    def func(li = []):
        li.append(1)  # append()追加
        print(li)
    
    
    func()  # 返回结果为:[1]
    func([])  # 返回结果为:[1]
    func()  # 返回结果为:[1, 1]
    func()  # 返回结果为:[1, 1, 1]
    
    # 字典(不可变数据类型)
    def func(li = {}):
        li['k'] = 'v'
        print(li)
    
    
    func()  # 返回结果为:{'k': 'v'} (此处的key必须为v的值)
    func()  # 返回结果为:{'k': 'v'}
    func()  # 返回结果为:{'k': 'v'}
    
    def func(k, li = {}):
        li[k] = 'v'
        print(li)
    
    
    func(1)  # 返回结果为:{1: 'v'}
    func(2)  # 返回结果为:{1: 'v', 2: 'v'}
    func(3)  # 返回结果为:{1: 'v', 2: 'v', 3: 'v'}
    
    展开全文
  • 函数(一)

    2020-06-10 08:45:02
    1 函数定义 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。 函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被...

    1 函数定义

    • 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
    • 函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
    • 定义一个函数
      你可以定义一个由自己想要功能的函数,以下是简单的规则:
      • 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
      • 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
      • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
      • 函数内容以冒号起始,并且缩进。
      • return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
    	1	def 函数名(形参1,形参2,...):
    	2		代码段		 
    
    	>>> def printer():
    	        print("Hello World")
     	  	    return 
    	   	printer()
    	>>> Hello World
    
    • 注意:
      • 函数名必须符合标识符的规范(可以包含字⺟、数字、下划线但是不能以数字开头)。
      • printer是函数对象, printer()是调⽤函数。

    2 函数的参数

    2.1 形参和实参

    • 形参(形式参数) 定义形参就相当于在函数内部声明了变量,但是并不是赋值。
    • 实参(实际参数)指定了形参,那么在调⽤函数时必须传递实参,实参将会赋值
      给对应的形参,简单来说有⼏个形参就要有⼏个实参。

    2.2 函数的传递方式

    • 以下是调用函数时可使用的正式参数类型:

      • 必备参数:必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

      • 关键字参数:关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。

      • 默认参数:调用函数时,默认参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,

      • 不定长参数:你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述2种参数不同,声明时不会命名。

      • 要注意定义可变参数和关键字参数的语法:

        • *args是可变参数,args接收的是一个tuple;

        • **kw是关键字参数,kw接收的是一个dict。

    2.3 必备参数

    调用printme()函数,你必须传入一个参数,不然会出现语法错误:

    #可写函数说明
    def printme( str ):
       "打印任何传入的字符串"
       print str
       return
     
    #调用printme函数
    printme()
    

    发生异常: TypeError
    printme() missing 1 required positional argument: ‘str’

    2.4关键字参数

    使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。

    以下实例在函数 printme() 调用时使用参数名:

    #可写函数说明
    def printme( str ):
       "打印任何传入的字符串"
       print str
       return
     
    #调用printme函数
    printme( str = "My string")
    

    My string

    #可写函数说明
    def printinfo( name, age ):
       "打印任何传入的字符串"
       print "Name: ", name
       print "Age ", age
       return
     
    #调用printinfo函数
    printinfo( age=50, name="miki" )
    

    Name: miki
    Age 50

    2.5默认参数

    下例会打印默认的age,如果age没有被传入:

    #可写函数说明
    def printinfo( name, age = 35 ):
       "打印任何传入的字符串"
       print "Name: ", name
       print "Age ", age
       return
     
    #调用printinfo函数
    printinfo( age=50, name="miki" )
    printinfo( name="miki" )
    

    Name: miki
    Age 50
    Name: miki
    Age 35

    2.6不定长参数

    基本语法如下:

    def functionname([formal_args,] *var_args_tuple ):
       "函数_文档字符串"
       function_suite
       return [expression]
    

    加了星号(*)的变量名会存放所有未命名的变量参数。不定长参数实例如下:

    # 可写函数说明
    def printinfo( arg1, *vartuple ):
       "打印任何传入的参数"
       print "输出: "
       print arg1
       for var in vartuple:
          print var
       return
    
    > #调用printinfo 函数 
    > printinfo( 10 ) 
    > printinfo( 70, 60, 50 )
    

    输出:
    10
    输出:
    70
    60
    50

    3 参数的解包

    • 传递实参时,也可以在序列类型的参数前添加星号,这样它会⾃动的将序列
      中元素依次作为参数传递
    • 要求序列中的元素的个数必须和形参的个数⼀致
    展开全文
  • 函数和方法的区别

    万次阅读 多人点赞 2017-12-31 23:08:45
    转载 节选 经常谈论起函数和方法,也常常搞不清楚它们之间的界限,...函数可以带有实际参数或者形式参数,用于指定这个函数执行计算要使用的一个或多个值,而且还可以返回值,以表示计算的结果。  方法(meth
  • 程序设计——函数

    2020-05-28 21:20:23
    数学函数 【题目描述】 打开文件MathFunc.cpp,完成其中的函数fun,根据以下公式计算数学表达式的值,并将结果作为函数值返回。在main()函数中输入x,调用函数fun(x),并输出fun(x)的值。 f(x)=3xsin⁡x+tgx1.5+∣x...
  • 为什么要自己定义函数? 因为随着程序规模的变大,都免不了会遇到下面这些问题: main 函数变得相当冗杂,程序可读性差 程序复杂度不断提高,编程变成了头脑风暴 代码前后关联度高,修改代码往往牵一发而动全身 ...
  • 07. 函数

    2020-11-21 14:58:08
    函数(Function) ★★★★★★★ 函数是指能够实现某种功能的一段代码 一、函数的定义语法 1. 返回值类型 int float double char 2. 函数名(形参类型 行参变量名1,形参类型 行参变量名2) 3. { 函数体...
  • Excel函数公式大全

    千次阅读 2019-05-15 00:40:02
    Excel函数公式大全 https://www.excelhanshu.com/
  • 函数指针和指针函数用法和区别

    万次阅读 多人点赞 2018-05-24 08:11:10
    函数指针和指针函数,在学习 C 语言的时候遇到这两个东西简直头疼,当然还有更头疼的,比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等,描述越长其定义就越复杂,当然理解起来就越难,...
  • 深度学习「一」

    2020-07-13 16:03:14
    这里的激活函数使用符号函数。 具体数学形式: ???? = ????1 ????1 + ????2 ????2 + ⋯+ ???????? ???????? + ???? 向量形式: ???? = ????????????+ ???? 添加线性函数: ???? = ????(????) = ??
  • Codeforces Round #655 (Div. 2) A. Omkar and Completion A题 time limit per test1 second memory limit per test256 megabytes inputstandard input outputstandard output You have been blessed as a child of ...
  • 第二门课:改善神经网络 第一周:深度学习的实践层面 1.1训练,验证和测试集 总结一下,在机器学习中,我们通常将样本分成训练集,验证集和测试集三部分,数据集规模相对较小,适用传统的划分比例,数据集规模较大的...
  • c语言中static关键字用法详解

    万次阅读 多人点赞 2018-04-05 18:18:14
    概述 static关键字在c语言中比较常用,使用恰当能够大大提高程序的模块化特性,有利于扩展和维护。 ...普通局部变量是再熟悉不过的变量了,在任何一个函数内部定义的变量(不加static修饰...
  • c语言函数参考手册

    2017-01-26 10:12:40
    C语言函数参考手册(C语言学习路线图)》是一本C语言函数查询参考手册,包含了C语言程序开发中应用的各种函数。全书共20章,按照C语言库函数头文件进行分章,每个头文件为一章,在每一个头文件中以字母的顺序对该...
  • C语言函数的基本知识

    万次阅读 多人点赞 2018-12-02 18:09:04
    接着上次的数组,这次我们来简单的讲讲C语言里面的函数函数和指针这两大块,在C语言中占据着重要的位置,是C语言中的主体和核心,所以它们的重要性也就不言而喻了。 那什么是函数呢? 1:函数C语言的模块,一...
  • C语言中的Sleep函数的解读

    万次阅读 多人点赞 2015-05-07 22:03:09
    Sleep函数: 功 能: 执行挂起一段时间 用 法: unsigned sleep(unsigned seconds); 注意: 在VC中使用带上头文件#include <windows.h>,在Linux下,gcc编译器中,使用的头文件因gcc版本的不同而不同#include...
  • 深入浅出剖析C语言函数指针与回调函数(一)

    万次阅读 多人点赞 2017-03-24 00:19:41
    关于静态库和动态库的使用和制作方法。...什么是回调函数?...如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。回调函数不是由该函数的实...
  • C语言函数返回值与参数传递 一:参数传递 C语言函数中必不可少的就是参数传递,可以采用传值和传指针两种方式。 1.传值的形式:只是将参数值的拷贝传给函数,并非参数本体如: int test(int x,int y) { x=2*y; ...
  • c语言常用函数

    2018-12-14 21:33:14
    C语言函数库2004年12月03日 20:57:00 vicant 阅读数:647 标签: c stream struct string file dos 更多 个人分类: C/C++ 分类函数,所在函数库为ctype.h int isalpha(int ch) 若ch是字母('A'-'Z','a'-'z')返回非0值...
  • 温故而知新:C语言中swap函数

    万次阅读 多人点赞 2014-10-17 13:46:13
    最近在学习数据结构和算法,发现使用到swap()函数,于是重新看了一下swap函数的各种实现,发现我对函数实参和形参理解不够透彻,现在分享我对swap的一些见解。 我们通常使用以下一段代码来实现整型变量的交换: ...
  • C语言函数指针与回调用函数

    万次阅读 2018-05-22 01:48:23
    1. 函数指针 指针是c语言的精髓,同时也是c语言中比较深奥、比较难掌握的一个知识点。本质上,对于一个内存单元来说,单元的地址即为指针, 其中存放的数据才是该单元的内容。我们允许用一个变量来存放指针,这种...
  • C语言中有关外部函数调用的问题

    万次阅读 多人点赞 2016-06-16 21:44:57
    对于外部函数实体(处于调用函数所在源文件之外的其他源文件中的函数),是在链接过程中,才会被寻找和添加进程序,一旦没有找到函数实体,就会报错,无法成功链接。 而外部函数的声明(一般声明在头文件中)只是令...
  • C语言CPU——函数

    2018-10-08 23:31:29
    函数C语言的基本模块,通过对函数模块的调用实现特定的功能。 A>函数避免了过长的main函数 B>使代码更美观 C>是可读性更强! 博文内容 函数的理解 函数的定义——调颜料 函数的参数——元素 参数...
  • 构造函数c语言

    2014-03-25 21:42:46
    c语言的构造函数详细解析,是初学者的福音,是值得一看的
  • 欧拉函数 C语言实现 #include "iostream" #include "math.h" #define maxsize 100 using namespace std; typedef struct node { int num; int total; }struct_num; struct_num a[maxsize]; int is_prime(int n)
  • C语言

    万次阅读 多人点赞 2019-12-18 23:01:50
    C语言 42.C语言是一种计算机高级语言。...47.C语言允许有空函数 48.C程序书写格式,允许一行内可以写几个语句 49.C程序的语句无行号 50.C语言的每个语句的最后必须有一个分号 51.C语言本身没有输入...
  • 局部变量(内部变量):在定义它的函数内有效,但是函数返回后失效; 全局变量(外部变量):在所有源文件内均有效。在同源文件的函数中使用使用全局变量,需要将全局变量提前声明;同时在不包含全局变量定义的不...
  • 入口函数 void perm(int *list, int k, int m,int **outArray) 假设求m个数的全排列,则: 第一个参数存储了1-m这m个数 第二个参数为0 第三个参数为m-1 第四个参数开辟了一个m!行、m列的内存区域,用于保存...
  • C语言函数嵌套示例

    2012-04-24 14:49:33
    完美展示函数嵌套的实例。turbo c跟vc++测试通过。

空空如也

1 2 3 4 5 ... 20
收藏数 8,145,538
精华内容 3,258,215
关键字:

函数