形参 订阅
自定义函数中的“形参”全称为"形式参数" 由于它不是实际存在变量,所以又称虚拟变量。实参和形参可以重名。 展开全文
自定义函数中的“形参”全称为"形式参数" 由于它不是实际存在变量,所以又称虚拟变量。实参和形参可以重名。
信息
特    点
实参和形参可以重名
实质 
不是实际存在变量
中文名
形式参数
又    称
虚拟变量
形式参数简介
是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数.在VB中,出现在Sub过程和Function过程的形参表中的变量名、数组名,称为形式参数,过程被调用之前,并为其分配内存,其作用是说明自变量的类型和形态以及在过程中所“扮演”的角色。形参即函数的自变量,其初值来源于函数的调用。只有在程序执行过程中调用了函数,形参才有可能得到具体的值,并参与运算求得函数值。可见形参表相当于变量说明,但应特别注意:此处只能使用类型标识符,而不能直接使用类型。在调用函数时,实参将赋值给形参。因而,必须注意实参的个数,类型应与形参一一对应,并且必须要有确定的值。
收起全文
精华内容
下载资源
问答
  • 形参当然了就是形式参数,而实参是我们需要给这个函数传入的变量,在我们给实参传入变量之后,调用函数,实参则自动会把数值或则变量赋予形参,从而通过函数得出我们想要的结果。既然形参是由实参赋值传递,所以说...
  • C语言中实参和形参之间的数据传递是单向的“值传递”,单向传递,只能由实参传给形参,反之不行 输出格式并没有选择%p而是选择了%d,因为十进制的数看起来更直观 1 值传递 如果只是传递值的话: #include //值...
  • 本文以实例阐述了C++中形参与实参的区别,有助于读者加深对于C++形参与实参的认识。 形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量也不...
  • 形参可以设置参数默认值,设置遵循从右至左原则 例如:fun(x=0,y=1),fun(x,y=1),但不可以是fun(x=1,y) 形参设置可以为数字字符串变量、元组和字典等任意类型数据,元组形参是在变量名前加*,字典形参是在变量名前加...
  • 函数的参数分为形参和实参两种。在本小节中,进一步介绍形参、实参的特点和两者的关系。形参出现在函数定义中,在整个函数体内都可以使用,离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量也...
  • 今天小编就为大家分享一篇关于C++中map和vector作形参时如何给定默认参数?,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 个人认为,提供params关键字以实现方法形参个数可变是C#语法的一大优点。在方法形参列表中,数组类型的参数前加params关键字,通常可以在调用方法时代码更加精练
  • 但是如果在形参中加入地址符时候就会改变实参的值,为什么? 请看下面的例子: 复制代码 代码如下: <?php //编写一个函数swap(),测试该函数的实参值无改变 function swap($a,$b) { echo “进入swqp()函数前 \n”;...
  • 主要介绍了C++常量详解二(常量形参,常量返回值,常量成员函数),需要的朋友可以参考下
  • 发现对C语言函数形参进行说明的文章点击率远高于其它文章,看来大家对C语言的热情可不是一般,难怪谭浩强教授那本C语言的书发行量能过千万册,显然是有坚实的群众基础。既然大家都偏好C语言的相关知识,今天我们来...
  • 下面小编就为大家带来一篇c++指针使用形参改变实参的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 下面小编就为大家带来一篇老生常谈C++中实参形参的传递问题。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 下面小编就为大家带来一篇详谈C++引用&和指针在作为形参时的区别。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了在python中list作函数形参,防止被实参修改的实现方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 形参

    2019-04-28 22:26:00
    '''形参种类:1)位置形参 -- 普通位置形参 -- 默认值形参 -- 可变长位置形参2)关键字形参 -- 有默认值关键字形参 -- 无默认值关键字形参 -- 可变长关键字形参'''def fn1(a, b, *, x, y): pass# fn1()# 位置形参与...
    '''
    形参种类:
    1)位置形参
    -- 普通位置形参
    -- 默认值形参
    -- 可变长位置形参

    2)关键字形参
    -- 有默认值关键字形参
    -- 无默认值关键字形参
    -- 可变长关键字形参
    '''


    def fn1(a, b, *, x, y):
    pass


    # fn1()
    # 位置形参与关键字形参的分水岭 *

    # 重点:
    # 位置实参只能给位置形参进行传值
    # fn1(10, 20, 30, 40) # 只有两个位置,给了四个位置
    # 关键字实参可以给位置形参与关键字形参进行传值
    # fn1(x=30, y=40, a=10, b=20)



    # part2
    # 两个带默认值的形参
    def fn2(a=10, *, x=20):
    print(a, x)
    fn2(100, x=200)
    # 总结:
    # 1.有默认值的参数可以不用传值
    # 2.*前有默认值的叫默认值参数,属于位置形参,可以被位置及关键字实参进行传值
    # 3.*后有默认值的叫有默认值的关键字形参,属于关键字形参,只能被关键字实参进行传值

    # def get_p(name, sex='男'):
    # pass
    # get_p('Bob', '女')


    # part3
    def fn3(a, b=10, *, x, y=20, z):
    print(a, b, x, y, z)
    fn3(100, x=200, z=300)
    # 总结:
    # 1.没有默认值的必须传参,有默认值的可以传也可以不传
    # 2.位置有值的必须出现在无值之后,关键字顺序不做要求

    # part4
    def fn4(a, b=10, *args, x, **kwargs):
    print(a, b, x)
    print(args)
    print(kwargs)
    fn4(10, 20, 30, x=100, y=200, z=300)
    # 总结:
    # 1.可变长是用来接收未接收完的值(接收0到n个):
    # -- *args用来接收所以没有接收完的位置(只能接收位置实参)
    # -- **kwargs用来接收所以没有接收完的关键字(只能接收关键字实参)
    # 2.*args必须出现在所以位置参数之后,**kwargs必须出现在所以参数之后

    # 假设第一个位置永远是参数name
    def func4(*args, **kwargs):
    name = args[0] # 将name抽出来

    def func44(name, *args, **kwargs):
    # name 可以直接接收,省了抽出来的过程
    pass



    # part5
    def fn5(*args, **kwargs):
    print(args, kwargs) # args=(10, 20) kwargs={'x': 100, 'y': 200}

    def fn55(*args, **kwargs):
    print(args, kwargs) # args=(10, 20) kwargs={'x': 100, 'y': 200}
    fn5(*args, **kwargs) # *args就会把元组打散传递,**kwargs就会把字典打散传递

    fn55(10, 20, x=100, y=200)

    # 容器类型可以打散传值
    def temp(*args, **kwargs):
    print(args, kwargs)
    ls = [1, 2, 3, 4, 5]
    dic = {'a': 1, 'b': 2}
    temp(*ls, **dic)

    转载于:https://www.cnblogs.com/qiangyuzhou/p/10787374.html

    展开全文
  • 函数形参是C++函数学习中一大重点,经常让初学者头疼,这里我们通过讲解两个实参值互换的例子讲解实参与形参间的关系,并比较普通变量、指针以及引用作形参时的区别,了解地址、名称以及值间的联系,体会指针、引用...
  • JNI形参中改写String

    2014-08-25 11:29:09
    这个是经过验证的, JAVA层传入String参数, 在JNI里进行修改, 作为输出参数.
  • 形参(parameter):在函数greet_user()的定义中,变量username是一个形参——函数完成其工作所需的一项信息。 实参(argument):在代码greet_user('jesse')中,值'jesse'是一个实参——调用函数时传递给函数的信息...
  • 数组元素不能作形参,那么结构体成员可以作形参使用么?看书的时候看到说数组元素只能做函数实参,不能做函数形参。我的理解是:intF(inta[10]),其实此处a是一个指针变量(也就是数组名,c把数组名作为指针变量),...

    数组元素不能作形参,那么结构体成员可以作形参使用么?

    看书的时候看到说数组元素只能做函数实参,不能做函数形参。我的理解是:

    int F(int a[10]),其实此处a是一个指针变量(也就是数组名,c把数组名作为指针变量),所以我们可以不限定里面的数组大小,int F(int a[ ]),所以数组元素作形参没意义。

    那么结构体成员呢? 可以作为形参么? 感觉自己写的时候,不好下手,不论是定义,还是初始化。所以想请教大神告诉。然后最好能写个小小的例子参考下。

    比如void days(int judge.year,int judge.month,int judge.day) 事先定义好judge为一个结构体。这样可以么? 能不能写个例子来看看具体怎么实现?

    结构体

    形参

    实参

    c语言

    函数

    分享到:

    ------解决方案--------------------

    不知 lz 为何会有此种需求,

    如果函数定义中需要使用某中聚集型数据类型中的多个元素,一般用此聚集型数据类型作形参(数组用指针,结构体可以用指针也可以用其本身)

    如果函数定义中只需要使用某中聚集型数据类型中的某一个元素,一般用此元素的数据类型作形参

    ------解决方案--------------------

    在参数里使用数组,实际上会退化成普通的指针。

    结构体的话不是这样用的,参数是有参数类型和类型名组成的。参数名只是个普通的名称,不能定义成XX.YY的形式。你想要传递结构体的成员,这是你调用时的事情,你调用的时候可以A(p.x,p.y),但不能实现指定好。或者你可以让完整的一个结构体类型做参数,也可以是这个结构体的指针或引用(C++)

    ------解决方案--------------------

    4L。。。 楼主很明显的说了结构体成员,还写了例子,不知所云

    5L说得对 楼主你听他的吧

    ------解决方案--------------------

    是的。数组和结构体积巨大,不合适在栈使用和传递。以引用的方式使用(也就是指针的方式)。

    typedef struct {

    char *ch;

    }st,*pst;

    void fun( pst s){

    s->ch = ( char*)malloc(1024*1024);

    }

    char* func(void){

    char *p = (char*)malloc(1024*1024);

    return p;

    }

    这个例子十分夸张,这里这是想说明为什么是引用而不是传值。

    void days(int judge.year,int judge.month,int judge.day)这个不需要这样做。

    void fun( pst s){

    s->成员名;这样你就可以访问结构的任意成员。

    }

    你想单独使用结构成员,区分一下指针和变量就可以了。

    函数声明 void days(int a,int b,int c)

    如果是结构指针,这样传递void days(judge->year, judge->month, judge->day)

    如果是结构变量,这样传递void days( judge.year, judge.month, judge.day)

    ------解决方案--------------------

    并不是说数组不能作形参, 只是说即使定义了数组作形参,也会自动退化成指针.

    ------解决方案--------------------

    引用:Quote: 引用:可以的!其实只是一个地址而已了!在参数的时候,数组和指针差不多!几乎一样的!

    结构体也比较简单了!只是一个地址进去就好!

    typedef struct Judge

    {

    int year;

    int month;

    int day;

    }Judge_s;

    void days(Judge_s *pJudge)

    {

    // TODO something;

    }我的意思是结构体成员,不是结构体,就是说结构体里面的每一个具体成员

    比如申明函数时void days(int judge.year,int judge.month,int judge.day)可以么?

    事先定义好judge含有year,month,day三个成员。

    可以的啊!如果只是需要某一个成员的话,那就把这个成员当成参数传进去就好了!

    一个结构体成员传参也是一样的!只有类型匹配就好!

    ------解决方案--------------------

    #include 

    using namespace std;

    struct Date

    {

    int year;

    int month;

    int day;

    };

    void ShowDate(Date &d)

    {

    cout<

    cout<

    <

    <

    }

    void ShowDate(Date *d)

    {

    cout<

    cout<year<

    <month<

    <day<

    }

    //个人觉得,形参就是体现实参的类型和个数而已。

    //如果要数组元素做形参,直接定义个和数组元素

    //同类型的形参不就行了吗?不是很明白这句话。

    void ShowDate(int year,int month,int day)

    {

    cout<

    cout<

    <

    <

    }

    int main()

    {

    Date date={2013,11,18};

    ShowDate(date);

    ShowDate(&date);

    ShowDate(date.year,date.month,date.day);

    return 1;

    }

    100942166.gif个人见解,不足之处还望见谅!楼主加油!共勉!

    ------解决方案--------------------

    100942167.jpg

    ------解决方案--------------------

    引用:Quote: 引用:在参数里使用数组,实际上会退化成普通的指针。

    结构体的话不是这样用的,参数是有参数类型和类型名组成的。参数名只是个普通的名称,不能定义成XX.YY的形式。你想要传递结构体的成员,这是你调用时的事情,你调用的时候可以A(p.x,p.y),但不能实现指定好。或者你可以让完整的一个结构体类型做参数,也可以是这个结构体的指针或引用(C++)感觉这时候x.x已经就是一个类似指定好数据类型的变量,把它看作整体,比如结构体x的成员int x  可以看作int x.x x.x当作整体。不就可以作为形参出现了么? 那么是编译器不通过这中格式? 可以不可以把x.x赋给一个类型相同的变量,就可以作为形参了?  这样不就意味着它实际是可以? 只是不支持x.x这种格式? 好吧,我都没办法用具体的函数实现,所以都是臆想的。。。

    理解有点不妥!函数传参的时候,只要类型和函数的原型匹配就好了!至于是结构体的成员,还是结构体中成员的成员都是没有关系的!因为编译器也不会知道!它只是检查传进来的参数和函数原型是否匹配就好!

    ------解决方案--------------------

    感觉int judge.year完全不合语法的东西能用吗?真心没看过...

    ------解决方案--------------------

    引用:

    展开全文
  • const形参和实参

    2021-05-22 01:39:30
    形参是const时,必须要注意关于顶层const的讨论。如前所述,顶层const的作用于对象本身:const int ci=42; //不能改变ci,const是顶层的int i=ci; //正确:当拷贝ci时,忽略了它的顶层constint *const p=&i; ...

    当形参是const时,必须要注意关于顶层const的讨论。如前所述,顶层const的作用于对象本身:

    const int ci=42;  //不能改变ci,const是顶层的

    int i=ci;   //正确:当拷贝ci时,忽略了它的顶层const

    int *const p=&i;  //const是顶层的,不能给p赋值

    *p=0;    //正确:通过p改变对象的内容是允许的,现在i变成了0

    和其他初始化过程一样,当用实参初始化形参时会忽略掉顶层const。换句话说,形参的顶层const被忽略掉了。当形参有顶层const时,传给它的常量对象或者非常量对象都是可以的:

    void fcn(const int i){  /*fcn能够读取i,但是不能向i写值*/}

    调用fcn函数时,既可以传入const int也可以传入int。忽略掉形参的顶层const可以产生意想不到的结果:

    void fcn(const int i) {/*fcn能够读取i,但是不能向i写值*/}

    void fcn(int i)  {/*....*/}//错误:重复定义了fdn(int)

    在C++语言中,允许我们定义若干具有相同名字的函数,不过前提是不同函数的形参列表应该有明显的区别。因为顶层const被忽略了,所以在上面的代码中传入两个fcn函数的参数可以完全一样。因此第二个fcn是错误的,尽管形式上由差异,但实际上它的形参和第一个fcn的形参没什么不同。

    指针或引用形参与const

    形参的初始化方式和变量的初始化方式是一样的,所以回顾通用的初始化规则有助于理解下面的知识。我们可以使用非常量初始化一个底层的const对象,但是反过来不行;同时一个普通的引用必须用同类型的对象初始化。

    int i=42;

    const int *cp=&i;  //正确:但是cp不能改变i

    const int &r=i;   //正确:但是r不能改变i

    const int &r2=42;   //正确

    int  *p=cp;    //错误:p的类型和cp的类型不匹配

    int &r3=r;    //错误:r3的类型和r的类型不匹配

    int  &r4=42;  //错误:不能用字面值初始化一个非常量引用

    将同样的初始化规则应用到参数传递上可得如下形式:

    int i=0;

    const int ci=i;

    string::size_type ctr=0;

    void reset(int &i);

    reset(&i);  //调用形参类型是int *的reset函数

    reset(&ci);  //错误:不能用指向const int对象的指针初始化int *

    reset(i);   //调用参数类型是int&的reset函数

    reset(ci);  //错误:不能把普通引用绑定到const对象ci上

    reset(42);  //错误:不能把普通引用绑定到字面值上

    reset(ctr); //错误:类型不匹配,ctr是无符号类型

    //find_char的第一个形参是对常量的引用

    find_char("hello world",'o',ctr);//可以绑定到字面值常量上

    要想调用引用版本的reset,只能使用int类型的对象,而不能使用字面值、求值结果为int的表达式、需要转换的对象或者const int类型的对象。类似的,要想调用指针版本的reset只能使用int*。

    另一方面,我们能传递一个字符串字面值作为find_char的第一个实参,这是因为改函数的引用形参是常量引用,而C++允许我们用字面值初始化常量引用。

    尽量使用常量引用

    把函数不会改变的形参定义成(普通的)引用是一种比较常见的错误,这么做带来给函数的调用者一种误导,即函数可以修改它的实参的值。此外,使用引用而非常量引用也会极大地限制函数所能接受的实参类型。就像刚刚看到的,我们不能把const对象、字面值或者需要类型转换的对象传递给普通的引用形参。

    关于函数传参的其他问题&lpar;const形参实参&sol;可变形参&rpar;

    const 形参和实参 当形参是 const 变量时,实参是 const 或者不是 const 变量都可以. 实参初始化形参时会忽略掉顶层 const: void gel(const int a){ ...

    C语言之形参和实参

    一 形参与实参 1).定义 形参:形式参数. 就是定义函数的时候,写在函数名小括号后面的参数叫形参 实参:实际参数. 就是调用函数的时候,调用函数时写在函数名小括号后面的参数就叫实参 2).注意项 a ...

    const形参与非const形参

    在程序设计中我们会经常调用函数,调用函数就会涉及参数的问题,那么在形参列表中const形参与非const形参对传递过来的实参有什么要求呢? 先来看一个简单的例子: #include 

    c&plus;&plus;形参改变实参(对指针的理解

    这几天搞逻辑比较晕,居然把指针的概念都混淆了. eg:int *p;//当然不对指针初始化在有些编译器是通不过编译的,比如VS(尤其是选中了SDL) 指针p是一个对象,定义开始没有分配了内存空间,只是 ...

    C&num;形参,实参,值传递参数,引用传递参数,输出参数,参数数组的学习

    1)形参 形参顾名思义就是形式上的参数,不是实际的参数,它代替实际传入方法的值.在方法体代码中代表了值本身参与运算.形参定义于参数中,它不同于方法体内局部变量,因为是一个变量,在它的作用域内不允许存在 ...

    c&plus;&plus;形参和实参同名时,如何单步执行观察形参的变化。

    c++形参和实参同名时,如何单步执行观察形参的变化? 方法:当程序运行到函数中时,添加变量观察即可.

    关于Java中形参与实参的理解

    今天阅读了一个写的非常棒的博文,通过此博文再次复习了Java中参数传递的知识(即值传递与引用传递的区别).参考网站http://www.cnblogs.com/binyue/p/3862276.htm ...

    JavaScript中函数的形参和实参的实现原理剖析

    我们都知道JS里面参数的传递是可以不一样的,比如我们有一个函数:

    &lbrack;C&plus;&plus;程序设计&rsqb;有关形参与实参&comma;及返回值说明

    有关形参与实参的说明:(1) 在定义函数时指定的形参,在未出现函数调用 时,它们并不占内存中的存储单元,因此称它们是 形式参数或虚拟参数,表示它们并不是实际存在的数据,只有在发生函数调用时,函数max ...

    随机推荐

    【Linux学习】Vi 操作命令集合

    Vi 操作命令集合 进入vi的命令 vi filename :打开或新建文件,并将光标置于第一行首 vi +n filename :打开文件,并将光标置于第n行首 vi + filename :打开文 ...

    sql server T-SQL 基础

    SQL语言按照用途可以分为如下3类: ①DDL(Data Definition Language)  数据定义语言: 定义修改和删除数据库.表.索引和视图等 ②DML(Data Manipulatio ...

    Deferred和Promise之间有什么区别呢?

    一个promise就是一个由异步函数返回的对象. deferred对象就是jQuery的回调函数解决方案. 总结 jQuery 的ajax 就是返回一个promise 对象,里面含有done(), f ...

    简洁之美 -约瑟夫环的python 解法

    问题描述: 约瑟夫环问题:已知n个人(以编号1,2,3...n分别表示)围坐在一张圆桌周围.从编号为k的人开始报数,数到k的那个人出列:他的下一个人又从1开始报数,数到k的那个人又出列:依此规律重复下 ...

    UGUI实现NGUI的UIEventListener功能

    在unity中处理UI事件时,习惯了使用NGUI的UIEventListener,虽然UGUI也有AddListener,但是一个组件只能对应一个函数,不能在一个函数中同时处理多个事件,显得有些麻烦 ...

    gitlab中批量删除本地以及远程tag的操作

    git 批量删除标签# 删除所有远程标签git show-ref --tag | awk '{print ":" $2}' | xargs git push origin # 删除 ...

    省钱版----查找 IoT 设备TTL线序&lowbar;&lowbar;未完待续

    作者:仙果 原文来自:省钱版—-查找 IoT 设备TTL线序 省钱版----查找 IoT 设备TTL线序__未完待续 缘由 在IoT固件调试分析的过程中,建议首先在IoT设备的板子上焊接调试线,这是能 ...

    前端Js框架 UI框架汇总 特性 适用范围 选择

    身为一个资深后端工程师,面对层出不穷的前端框架,总让人眼花缭乱,做一个综合解析贴,从全局着眼,让我们明白各种前端框架的应用范围,为如何选择前端框架,从不同的维度提供一些线索,做为一个长期优化贴,欢迎指 ...

    Java NIO Test Case

    package org.zwl.test.nio; import java.io.IOException; import java.net.InetSocketAddress; import java ...

    展开全文
  • 面向对象程序设计,即c++语言。类,函数的形参、返回值为不同情况时,复制构造函数的调用。内有详细的注释说明。
  • 位置形参 星号元祖形参 ,命名关键字形参和双星号字典形参可以混合使用 函数参数自左至右的顺序为: 位置形参 星号元祖形参 命名关键字形参 双星号字典形参 综合示例: # # 综合示例 def f1(a,b,*args,c,**kwargs): ...

    return语句

    语法:

    return [表达式]

    [ ]可以省略

    作用:

    用于函数中,结束当前函数的执行,返回到调用该函数的地方,同时返回一个对象的引用关系

    说明:

    1.return语句后跟的表达式可以省略,省略后相当于return None

    2.如果函数没有return语句,则函数执行完最后一条语句后返回None(相当于在最后加了一条return None语句)

    3.函数调用一定会返回一个对象引用

    def myfun(a,b):

    s=a+b#在函数内部定义的变量是局部变量

    print("和是:",s)

    return s#给调用者返回的值

    # 此示例示意return语句的用法和执行过程

    def myf1():

    print("assdg")

    print("vfsg")

    return 100 #return语句执行后,后面的语句便不再执行,以遇到return马上回到调用函数的地方

    print("wtehn")

    v=myf1()#一遇到函数名加括号立马执行函数内容

    print("我是返回值:",v)

    练习:

    写一个函数myMax,实现返回两个数的最大值:

    如:

    def myMax():

    ​ print(myMax(100,200)) #200

    ​ print(myMax(10,20)) #20

    ​ print(myMax(“abcd,”“abc”) #abcd

    def myMax(a,b):

    v=max(a,b)

    return v

    print(myMax(100,200))

    print(myMax(20,10))

    print(myMax("abcd","abc"))

    写一个函数input_number():

    ​ 。。。。。

    此函数用来获取用户循环输入的整数,当用户输入负数时,结束输入

    将用户输入的数以列表的形式返回,再用再建函数max,min,sum示出用户输入的最大值,最小值以及和

    def input_number():

    li=[]

    sum=0

    while 1:

    i=int(input("请输入整数:"))

    if i<0:

    break

    if i not in li:

    li.append(i)

    for x in li:

    sum+=i

    print("最大值",max(li),"最小值:",min(li),"和:",sum)

    return li

    print(input_number())

    Python函数的参数传递

    传递方式

    ​ 位置传参

    ​ 序列传参

    ​ 关键字传参

    ​ 字典关键字传参

    位置传参

    实际参数(实参)的对应关系与形式参数(形参)的对应关系是按位置来一次对应的

    示意:

    def myFun(a,b,c):

    pass

    myFun(1,2,3)

    说明:

    实际参数和形式参数通过位置进行传递和匹配

    实参个数必须与形参个数相同

    # 此示例示意位置传参

    def myFun(a,b,c):

    print("a绑定的是:",a)

    print("b绑定的是:",b)

    print("c绑定的是:",c)

    myFun(1,2,3)

    序列传参

    序列传参是指在函数调用过程中,用*将序列拆解后按位置传参的方式进行参数传递

    def myFun(a,b,c):

    print("a绑定的是:",a)

    print("b绑定的是:",b)

    print("c绑定的是:",c)

    s=[1,2,3]

    myFun(*s) #*表示把s拆开s[0,1,2]分别对应a,b,c

    s2="asd"

    myFun(*s2)

    关键字传参

    关键字传参是指传参时,按着形参的名称给形参赋值

    实参和形参按照名称进行匹配,实参和形参可以不按位置分配

    # 此示例示意关键字传参

    def myFun(a,b,c):

    print("a绑定的是:",a)

    print("b绑定的是:",b)

    print("c绑定的是:",c)

    myFun(b=22,c=23,a=12) #实参和形参可以不按位置分配

    字典关键字传参

    是指实参为字典,将字典用**拆解后进行关键字传参

    说明:

    ​ 字典的键名必须和形参名一致

    ​ 字典的键名必须是字符串

    ​ 字典的键名要在形参中存在

    # 此示例示意字典关键字传参

    def myFun(a,b,c):

    print("a绑定的是:",a)

    print("b绑定的是:",b)

    print("c绑定的是:",c)

    d={"c":12,"a":45,"b":23}

    myFun(**d)#拆解字典后再传参

    函数的综合传参

    ​ 函数传参方式,在能确定形参能唯一匹配到相应实参的情况下可以任意组合

    说明:

    传参时,先位置传参,后关键字传参

    # 此示例示意综合传参

    def myFun(a,b,c):

    print("a绑定的是:",a)

    print("b绑定的是:",b)

    print("c绑定的是:",c)

    myFun(100,*[200,400])

    myFun(*"as",200)

    myFun(1,**{"c":3,"b":5})

    myFun(100,b=200,c=10)

    myFun(**{"b":2,"c":2},a=1)

    myFun(b=2,c=1,a=5)

    练习

    1.写一个函数sum3(a,b,c)

    用于返回三个数的和

    2.写一个函数pow3(x),用于返回x的三次方

    用以上函数计算

    1),13+23+3**3

    2)计算1+2+3的和的立方

    def sum3(a,b,c):

    d=a+b+c

    return d

    def pow3(x):

    y=x**3

    return y

    print(sum(pow3(1),pow3(2),pow3(3)))

    print(pow3(sum3(1,2,3)))

    以下讲的是形参

    函数的缺省参数

    语法:

    ​ def 函数名(形参名1=默认实参,

    ​ 形参名2=默认实参2,

    ​ 形参名3=默认实参3.。。。)

    说明

    缺省参数必须自右至左依次存在,如果一个参数由缺省参数,则及右侧的所有参数必须有缺省参数

    缺省参数可以有0个1个或多个,甚至全部都有缺省参数

    如:

    def test(a,b=10,c):------------------>错误!

    # 以下示意缺省参数

    def info(name, age=1, address="未填写"):

    print(name,"今年", age,"岁", "家住:", address)

    info('csaf',25)

    info("暴风")

    info("梵蒂冈",21,"浙江杭州")

    练习

    写一个函数,mySum(),可以传入两个实参或三个实参,

    如果传入两个实参则返回两个实参的和

    如果传入三个实参,则返回前两个实参和对第三个实参求余的结果

    def mySum(a,b,c=None):

    if c is None:

    return a+b

    return (a+b)%c

    print(mySum(12,3))

    print(mySum(12,4,5))

    函数的形参定义方式

    位置形参

    星号元祖形参

    命名关键字形参

    双星号字典形参

    位置形参

    语法:

    def 函数名(形参1,形参2,。。):

    语句块

    星号元祖形参

    语法

    ​ def 函数名(*元祖形参名):

    ​ 语句

    作用:

    收集多余位置传参

    说明:

    元祖形参名通常用:“args”

    练习

    写一个函数,mySum,可以传入任意个实参的数字,返回所有实参的和

    def mySum(*args):

    return sum(args)

    print(mySum(1,2,3,4,5,6,7,8))

    命名关键字形参

    语法:

    def 函数名(*,命名关键字形参):

    语句

    def 函数名(*args,命名关键字形参):

    语句

    作用:

    ​ 所有的参数都必须用关键字传参或字典关键字

    def fn(*,d,e): # * 是语法表示符

    print("d=",d)

    print("e=",e)

    fn(d=200,e=300)# 所有传参必须是以关键字传参

    fn(100,200) #不合法!不能用位置传参

    fn(1,2,d=12,e=34) #不合法

    def fn(*args,d,e):

    print(args)

    print("d=",d)

    print("e=",e)

    fn(1,2,d=12,e=34) # 合法

    fn(*"as",**{"e":12,"d":4})

    双星号字典形参

    语法:

    ​ def 函数名(**字典形参名):

    ​ 语句

    作用:

    收集多余的关键字传参

    说明:

    通常字典形参名定为

    def func(**kwargs):

    print("关键字参数个数是:",len(kwargs))

    print("kwargs:",kwargs)

    print(func(name="das",age=12))

    函数的参数说明

    缺省参数 位置形参 星号元祖形参 ,命名关键字形参和双星号字典形参可以混合使用

    函数参数自左至右的顺序为:

    位置形参

    星号元祖形参

    命名关键字形参

    双星号字典形参

    综合示例:

    # # 综合示例

    def f1(a,b,*args,c,**kwargs):

    print("位置形参:",a,b)

    print("星号元祖形参:",args)

    print("关键字传参:",c)

    print("双星号字典传参:",kwargs)

    f1(12,34,*"gjfsdf",c=21,**{"name":"as","age":12})

    函数不定长参数:

    def fn(*args,**kwards):

    pass

    #可以接受任意的位置传参和关键字传参

    def fn(*args, **kwards):

    print(args)

    print(kwards)

    fn("as",12,2,23,34,45,**{"name":"dasf","afe":321})

    练习

    写一个myRange()函数,此函数返回一个符合rang规则的完整数列表

    如:

    L=myRange(3)

    print(L) [0,1,2]

    def myRange(start,stop=None,step=1):

    li=[]

    i=start

    if stop is None:

    stop=start

    start=0

    i=start

    while i

    li.append(i)

    i+=1

    if stop is not None:

    while i

    li.append(i)

    i+=1

    if step is not 1:

    while i

    li.append(i)

    i+=step

    return li

    练习

    ​ 1.素数prime函数练习

    ​ 1)写一个函数isprime(x)判断x是否是素数,如果是返回True ,否则返回False

    ​ 2)写一个函数prime_m2n(m,n)

    ​ 返回从m开始到n结束(不包含n)的范围内的素数列表

    ​ 3)写一个函数primes(n),返回指定范围内素数(不包含n)的全部素数的列表,并打印这些素

    ​ 数

    1)打印100以内的全部素数

    2)打印100以内的全部素数和

    def isPrimes(x):

    if x<=1:

    return False

    for i in range(2,x):

    if x%i!=0 or x==2:

    return True

    return False

    def prime_m2n(m,n):

    return [x for x in range(m,n) if isPrimes(x)]

    def primes(n):

    return prime_m2n(0,n)

    print(prime_m2n(0,100))

    print(sum(primes(100)))

    2.修改之前的学生信息管理程序

    ​ 编写两个函数用于封装

    ​ 录入学生的信息和打印学生信息的功能

    ​ 1)def input_student():

    ​ #此函数获取学生信息,并返回学生信息的列表

    ​ 2) def output_student(L):

    ​ #以表格形式再打印学生信息

    验证测试:

    L=input_student()

    output_student(L)

    print(“在添加几个学生的信息”)

    L+=input_student(L)

    print(“添加后的学生信息如下:”)

    l = []

    def input_student():

    while 1:

    name = input("请输入学生姓名:")

    if not name:

    break

    age = int(input("请输入学生年龄:"))

    score = int(input("请输入学生成绩:"))

    d = {} # 创建一个新的字典

    d["name"] = name # 值 对 键

    d["age"] = age

    d["score"] = score

    l.append(d)

    def output_student(l):

    print("+--------+-----+--------+")

    print("| name | age | score |")

    print("+--------+-----+--------+")

    for d in l:

    t = ((d["name"]).center(8),

    str(d["age"]).center(5),

    str(d["score"]).center(8))

    line = "|%s|%s|%s|" % t # t是元祖

    print(line)

    print("+--------+-----+--------+")

    input_student()

    output_student(l)

    展开全文
  • 形参实际意义

    2021-06-08 18:48:52
    //这是一个关于引用形参,const形参,指针形参的程序,用于理解不同形式的区别 using namespace std; //非引用形参:是“实参”的一个拷贝副本,修改“形参”不影响“实参” //const常量:值不可修改 //非引用非...
  • 10、形参和实参

    2021-03-18 15:47:35
    文章目录一、形参和实参介绍二、形参和实参的具体使用(定义阶段,调用阶段)2.1 位置参数2.2 关键字(实)参数2.3 默认(行)参数2.4 可变长度的参数(\*与\*\*)2.4.1 可变长度的位置参数2.4.2 可变长度的关键字...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 366,738
精华内容 146,695
关键字:

形参

友情链接: UcBrowseCtl.rar