精华内容
下载资源
问答
  • int max(int a, int b) ...此处的a,b就是形式参数,形参的作用域只函数max内有效,max外不识别,函数运行的时候并不给形式参数分配内存; 当我们其他函数中(如main函数)调用max函数,如 result

    转载出处:https://zhidao.baidu.com/question/550654557.html

    int max(int a, int b)
    {
     函数体...;
     a...;
     b...;
    }
    此处的a,b就是形式参数,形参的作用域只在函数max内有效,max外不识别,在函数运行的时候并不给形式参数分配内存;
    当我们在其他函数中(如main函数)调用max函数时,如 result = max(x, y);
    此处的x,y就是实际参数,运行的时候将x的值传递给a,y的值传递给b,系统需要给x,y分配内存地址,其作用域范围为调用函数中。




    注:也就是说:形式参数就是 方法中的抽象的 公用的参数,实际参数就是具体赋值的参数



    延伸:形式参数:
     *         基本类型:形式参数的改变不影响实际参数
     *         引用类型:形式参数的改变直接影响实际参数
     *
     * 注意:
     *         String作为参数传递,效果和基本类型作为参数传递是一样的。



    eg:package cn.itcast_08;

    /*
     * 面试题:
     * 1:String,StringBuffer,StringBuilder的区别?
     * A:String是内容不可变的,而StringBuffer,StringBuilder都是内容可变的。
     * B:StringBuffer是同步的,数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高
     *
     * 2:StringBuffer和数组的区别?
     * 二者都可以看出是一个容器,装其他的数据。
     * 但是呢,StringBuffer的数据最终是一个字符串数据。
     * 而数组可以放置多种数据,但必须是同一种数据类型的。
     *
     * 3:形式参数问题
     * String作为参数传递
     * StringBuffer作为参数传递
     *
     * 形式参数:
     *         基本类型:形式参数的改变不影响实际参数
     *         引用类型:形式参数的改变直接影响实际参数
     *
     * 注意:
     *         String作为参数传递,效果和基本类型作为参数传递是一样的。
     */
    public class StringBufferDemo {
        public static void main(String[] args) {
            String s1 = "hello";
            String s2 = "world";
            System.out.println(s1 + "---" + s2);// hello---world
            change(s1, s2);
            System.out.println(s1 + "---" + s2);// hello---world

            StringBuffer sb1 = new StringBuffer("hello");
            StringBuffer sb2 = new StringBuffer("world");
            System.out.println(sb1 + "---" + sb2);// hello---world
            change(sb1, sb2);
            System.out.println(sb1 + "---" + sb2);// hello---worldworld

        }

        public static void change(StringBuffer sb1, StringBuffer sb2) {
            sb1 = sb2;
            sb2.append(sb1);
        }

        public static void change(String s1, String s2) {
            s1 = s2;
            s2 = s1 + s2;
        }
    }






    展开全文
  •  无参数的宏定义的一般形式为  # define 标识符 字符序列 其中# define之后的标识符称为宏定义名(简称宏名),要求宏名与字符序列之间用空格符分隔。这种宏定义要求编译预处理程序将源程序中随后所有的定名的出现...
    宏定义有无参数宏定义带参数宏定义两种。
       无参数的宏定义的一般形式为
                # define 标识符 字符序列

    其中# define之后的标识符称为宏定义名(简称宏名),要求宏名与字符序列之间用空格符分隔。这种宏定义要求编译预处理程序将源程序中随后所有的定名的出现(注释与字符串常量中的除外)均用字符序列替换之。前面经常使用的定义符号常量是宏定义的最简单应用。如有:
                # define TRUE 1
                # define FALSE 0
    则在定义它们的源程序文件中,凡定义之后出现的单词TRUE将用1替代之;出现单词FALSE将用0替代之。
           在宏定义的#之前可以有若干个空格、制表符,但不允许有其它字符。宏定义在源程序中单独另起一行,换行符是宏定义的结束标志。如果一个宏定义太长,一行不 够时,可采用续行的方法。续行是在键人回车符之前先键入符号"/"。注意回车要紧接在符号"/"之后,中间不能插入其它符号。
          宏定义的有效范围称为宏定义名的辖域,辖域从宏定义的定义结束处开始到其所在的源程序文件末尾。宏定义名的辖域不受分程序结构的影响。可以用预处理命令#undef终止宏定义名的辖域。
      在新的宏定义中,可以使用前面已定义的宏名。例如,
                 # define R 2.5
                 # define PI 3.1415926
                 # define Circle 2*PI*R
                 # define Area PI* R * R
    程序中的Circle被展开为2*3.1415926* 2.5, Area被展开为3.1415926*2.5*2.5。
         如有必要,宏名可被重复定义。被重复定义后,宏名原先的意义被新意义所代替。

         通常,无参数的宏定义多用于定义常量。程序中统一用宏名表示常量值,便于程序前后统一,不易出错,也便于修改,能提高程序的可读性和可移植性。特别是给数组元素个数一个宏定义,并用宏名定义数组元素个数能部分弥补数组元素个数固定的不足。
          注意:预处理程序在处理宏定义时,只作字符序列的替换工作,不作任何语法的检查。如果宏定义不当,错误要到预处理之后的编译阶段才能发现。宏定义以换行结束,不需要分号等符号作分隔符。如有以下定定义:
       # define PI 3.1415926;
    原希望用PI求圆的周长的语句
       c=2*PI*r;
    经宏展开后,变成
       c=2*3.1415926*r;
    这就不能达到希望的要求。
       带参数宏定义进一步扩充了无参数宏定义的能力,在字符序列替换同时还能进行参数替换。带参数定定义的一般形式为
       # define 标识符(参数表)字符序列
    其中参数表中的参数之间用逗号分隔,字符序列中应包含参数表中的参数。
    在定义带参数的宏时,宏名标识符与左圆括号之间不允许有空白符,应紧接在一起,否则变成了无参数的宏定义。如有宏定义:
       # define MAX(A,B) ((A) > (B)?(A):(B))

    则代码 y= MAX( p+q, u+v)将被替换成 y=((p+q) >(u+v)?(p+q):(u+v)。
               程序中的宏调用是这样被替换展开的,分别用宏调用中的实在参数字符序列(如p+q和u+V) 替换宏定义字符序列中对应所有出现的形式参数(如用p+q替代所有形式参数A,用u+V替代所有形式参数B),而宏定义字符序列中的不是形式参数的其它字 符则保留。这样形成的字符序列,即为宏调用的展开替换结果。宏调用提供的实在参数个数必须与宏定义中的形式参数个数相同。
           注意:宏调用与函数调用的区别。函数调用在程序运行时实行,而宏展开是在编译的预处理阶段进行;函数调用占用程序运行时间,宏调用只占编译时间;函数调用 对实参有类型要求,而宏调用实在参数与宏定义形式参数之间没有类型的概念,只有字符序列的对应关系。函数调用可返回一个值,宏调用获得希望的C代码。另 外,函数调用时,实参表达式分别独立求值在前,执行函数体在后。宏调用是实在参数字符序列替换形式参数。替换后,实在参数字符序列就与相邻的字符自然连 接,实在参数的独立性就不一定依旧存在。如下面的宏定义:
       # define SQR(x) x*x
    希望实现表达式的平方计算。对于宏调用
       P=SQR(y)
    能得到希望的宏展开p= y*y。但对于宏调用q=SQR(u+v)得到的宏展开是q=u+V*u+V。显然,后者的展开结果不是程序设计者所希望的。为能保持实在参数替换后的独立性,应在宏定义中给形式参数加上括号。进一步,为了保证宏调用的独立性,作为算式的宏定义也应加括
    号。如 SQR宏定义改写成:
       # define SQR((x)*(x))
    才是正确的宏定义。

          对于简短的表达式计算函数,或为了提高程序的执行效率、避免函数调用时的分配存储单元、保留现场、参数值传递、释放存储单元等工作。可将函数定义改写成宏定义。所以合理使用宏定义,可以使程序更简洁。


    使用一些宏跟踪调试

    A N S I标准说明了五个预定义的宏名。它们是:

    _ L I N E _ (两个下划线),对应%d

    _ F I L E _    对应%s

    _ D A T E _   对应%s

    _ T I M E _   对应%s

    _ S T D C _

    如果编译不是标准的,则可能仅支持以上宏名中的几个,或根本不支持。记住编译程序

    也许还提供其它预定义的宏名。

    _ L I N E _及_ F I L E _宏指令在有关# l i n e的部分中已讨论,这里讨论其余的宏名。

    _ D AT E _宏指令含有形式为月/日/年的串,表示源文件被翻译到代码时的日期。

    源代码翻译到目标代码的时间作为串包含在_ T I M E _中。串形式为时:分:秒。

    如果实现是标准的,则宏_ S T D C _含有十进制常量1。如果它含有任何其它数,则实现是

    非标准的。

    可以定义宏,例如:

    当定义了_DEBUG,输出数据信息和所在文件所在行

    #ifdef _DEBUG

    #define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%s”,date,_LINE_,_FILE_)

    #else

          #define DEBUGMSG(msg,date)

    #endif

    20,宏定义防止使用是错误

    用小括号包含。

    例如:#define ADD(a,b) (a+b)

    用do{}while(0)语句包含多语句防止错误

    例如:#difne DO(a,b) a+b;/

                       a++;

    应用时:if(….)

              DO(a,b); //产生错误

            else

            

    解决方法: #difne DO(a,b) do{a+b;/

                       a++;}while(0)


    宏中"#"和"##"的用法 
    一、一般用法 
    我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起(这里说的是在预处理是对源文件的操作)
    用法: 
    #include<cstdio> 
    #include<climits> 
    using namespace std;

    #define STR(s)     #s 
    #define CONS(a,b) int(a##e##b)

    int main() 

    printf(STR(vck));           // 输出字符串"vck" 
    printf("%d/n", CONS(2,3)); // 2e3 输出:2000 
    return 0; 
    }

    二、当宏参数是另一个宏的时候 
    需要注意的是凡宏定义里有用''#''或''##''的地方宏参数是不会再展开.

    1, 非''#''和''##''的情况 
    #define TOW      (2) 
    #define MUL(a,b) (a*b)

    printf("%d*%d=%d/n", TOW, TOW, MUL(TOW,TOW)); 
    这行的宏会被展开为: 
    printf("%d*%d=%d/n", (2), (2), ((2)*(2))); 
    MUL里的参数TOW会被展开为(2).

    2, 当有''#''或''##''的时候 
    #define A          (2) 
    #define STR(s)     #s 
    #define CONS(a,b) int(a##e##b)

    printf("int max: %s/n", STR(INT_MAX));    // INT_MAX #include<climits> 
    这行会被展开为: 
    printf("int max: %s/n", "INT_MAX");

    printf("%s/n", CONS(A, A));               // compile error 
    这一行则是: 
    printf("%s/n", int(AeA));

    INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏. 
    加这层宏的用意是把所有宏的参数在中间层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数.

    #define A           (2) 
    #define _STR(s)     #s 
    #define STR(s)      _STR(s)          // 转换宏 
    #define _CONS(a,b) int(a##e##b) 
    #define CONS(a,b)   _CONS(a,b)       // 转换宏

    printf("int max: %s/n", STR(INT_MAX));          // INT_MAX,int型的最大值,为一个变量 #include<climits> 
    输出为: int max: 0x7fffffff 
    STR(INT_MAX) --> _STR(0x7fffffff) 然后再转换成字符串;

    printf("%d/n", CONS(A, A)); 
    输出为:200 
    CONS(A, A) --> _CONS((2), (2)) --> int((2)e(2))

    三、''#''和''##''的一些应用特例 
    1、合并匿名变量名 
    #define ___ANONYMOUS1(type, var, line) type var##line 
    #define __ANONYMOUS0(type, line) ___ANONYMOUS1(type, _anonymous, line) 
    #define ANONYMOUS(type) __ANONYMOUS0(type, __LINE__) 
    例:ANONYMOUS(static int); 即: static int _anonymous70; 70表示该行行号; 
    第一层:ANONYMOUS(static int); --> __ANONYMOUS0(static int, __LINE__); 
    第二层:                        --> ___ANONYMOUS1(static int, _anonymous, 70); 
    第三层:                        --> static int _anonymous70; 
    即每次只能解开当前层的宏,所以__LINE__在第二层才能被解开;

    2、填充结构 
    #define FILL(a)   {a, #a}

    enum IDD{OPEN, CLOSE}; 
    typedef struct MSG{ 
    IDD id; 
    const char * msg; 
    }MSG;

    MSG _msg[] = {FILL(OPEN), FILL(CLOSE)}; 
    相当于: 
    MSG _msg[] = {{OPEN, "OPEN"}, 
    {CLOSE, "CLOSE"}};

    3、记录文件名 
    #define _GET_FILE_NAME(f)   #f 
    #define GET_FILE_NAME(f)    _GET_FILE_NAME(f) 
    static char FILE_NAME[] = GET_FILE_NAME(__FILE__);

    4、得到一个数值类型所对应的字符串缓冲大小 
    #define _TYPE_BUF_SIZE(type) sizeof #type 
    #define TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type) 
    char buf[TYPE_BUF_SIZE(INT_MAX)]; 
    --> char buf[_TYPE_BUF_SIZE(0x7fffffff)]; 
    --> char buf[sizeof "0x7fffffff"]; 
    这里相当于: 

    char buf[11]

    本文转载自http://hi.baidu.com/ufo008ahw/blog/item/5e943d4f5f49513caec3abd1.html)

    展开全文
  • #定义函数参数就是函数体接收外部传值的一种媒介,其实就一个变量名#1、无参函数:# 函数定义阶段括号内没有参数,称为无参函数# 注意:定义时无参,意味着调用也无需传入参数# 应用:#如果函数体代码逻辑不...

    #定义函数时的参数就是函数体接收外部传值的一种媒介,其实就一个变量名

    #1、无参函数:
    # 在函数定义阶段括号内没有参数,称为无参函数
    # 注意:定义时无参,意味着调用时也无需传入参数
    # 应用:
    #如果函数体代码逻辑不需要依赖外部传入的值,必须定义无参函数

    def func():
    print('hello world')
    func()


    #2、有参函数
    # 在函数定义阶段括号内有参数,称为有参函数
    # 注意:定义时有参,意味着调用时也必须传入参数
    # 应用:
    #如果函数体代码逻辑需要依赖外部传入的值,必须定义成有参函数
    # def sum2(x,y):
    # # x=10
    # # y=20
    # res=x+y
    # print(res)
    #
    # sum2(10,20)
    # sum2(30,40)

    def check_user():
    while True:
    uname=input('username>>:').strip()
    if uname.isalpha():
    return uname
    # break
    else:
    print('用户名必须由字母组成傻叉')

    def check_pwd():
    while True:
    pwd1=input('密码>>: ').strip()
    pwd2=input('重复输入密码>>: ').strip()
    if pwd1 == pwd2:
    return pwd1
    else:
    print('两次输入的密码不一致,眼瞎吗')

    def db_hanle(uname,pwd1):
    with open('db.txt','at',encoding='utf-8') as f:
    f.write('%s:%s\n' %(uname,pwd1))
    f.flush()

    def register():
    # 检测用户名是否合法
    x=check_user() #x='EGON'
    # 检测密码是否合法
    y=check_pwd() #y='123'

    # 写入数据文件
    # db_hanle(合法的用户名,合法的密码)
    db_hanle(x,y)


    # register()



    #3、空函数

    # def func():
    # pass


    def check_user():
    pass

    def check_pwd():
    pass

    def write_db(x,y):
    pass

    def register():
    #1 输入用户名,并进行合法性校验
    #2 输入密码,并进行合法性校验
    #3 将合法的用户名、密码写入文件
    x=check_user()
    y=check_pwd()
    write_db(x,y)

    转载于:https://www.cnblogs.com/Roc-Atlantis/p/9140537.html

    展开全文
  • C语言当中的实际参数及形式参数

    千次阅读 2019-04-02 14:23:10
    接下来,我们再定义一个函数,使其可以交换两个整形变量的内容. #include <stdio.h> #include <stdlib.h> void swap(int x, int y){ int tmp; tmp = x; x = y; y = tmp; } int main(){ int num1 = 10...

    首先我们来定义一个函数,使其可以交换两个整形变量的内容.

    #include <stdio.h>
    #include <stdlib.h>
    void Swap(int x, int y){
    	int tmp;
    	tmp = x;
    	x = y;
    	y = tmp;
    }
    int main(){
    	int num1 = 10;
    	int num2 = 20;
    	Swap(num1,num2);
    	printf("num1 = %d,num2 = %d\n",num1,num2);
    }
    

    程序运行结果如下
    在这里插入图片描述
    我们不是定义了一个函数,要将num1与num2的值进行交换吗?为什么num1与num2的值没有发生变化呢?这就涉及到了C语言中函数的参数问题.
    函数的参数
    实际参数(实参):实参是真实传给函数的参数,实参可以是常量,变量,表达式,函数等.但无论实参是那种类型的量,在进行函数调用时,他们都必须要有确定的值,以便于将这些值传送给形参.
    形式参数
    形式参数是指函数名后括号中的变量,因为形式参数只有在函数被调用的过程中才实例化(也就是分配内存单元),所以叫形式参数.形式参数当函数调用完成之后就自动销毁了.因此形式函数只有在函数中有效.
    在面的Swap函数中的参数x,y都是形式参数,在main函数中传给Swap的num1,num2是实际参数.
    我们可以来看一下上述Swap(a,b)的等价代码

    int x = a;
    int y = b;
    int tmp = x;
    x = y;
    y = tmp;
    

    我们可以理解为函数的形参是实参的一份拷贝.
    代码修改如下

    #include <stdio.h>
    #include <stdlib.h>
    void Swap(int* x,int* y){
    	int tmp = *x;
    	*x = *y;
    	*y = tmp;
    }
    int main(){
    	int num1 = 10;
    	int num2 = 20;
    	Swap(&num1,&num2);
    	printf("num1 = %d,num2 = %d",num1,num2);
    	system("pause");
    	return 0;
    }
    

    传值调用:
    函数的形参与实参分别占有不同内存块,对形参的修改不会影响实参.传址调用:
    传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式.这种传参方式可以让函数和函数外边的变量建立起真正的联系,也就是函数内部可以直接操作函数外部的变量.

    展开全文
  • 什么是形式参数?什么是实际参数

    万次阅读 多人点赞 2017-04-01 11:00:43
    1 形式参数:就是在定义函数或过程的时候命名的参数。通俗讲就是一个记号。2 实际参数:就是执行,调用函数或过程时,传递给函数或过程的参数。通俗讲就是实际值。3 参数嘛,就是一个可变量,它随着使用者的...
  • 函数定义以及参数

    万次阅读 2018-01-02 20:33:15
    可以通过函数名程序的不同地方多次执行。(函数调用) 函数分为预定义函数和自定义函数。 预定义函数可以直接使用。 自定义函数需要,是用户自己编写。 2.为什么要使用函数? (1)降低编程的难度。 ...
  • Python函数定义参数

    千次阅读 2017-11-01 23:24:26
    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段,能提高应用的模块性,和代码的重复利用率。...任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。 函数内容以冒号起
  • 形式参数和实际参数的区别

    千次阅读 2017-10-18 19:53:51
    形参:全称为“形式参数”是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数传递的参数。 实参:可以是常量、变量、表达式、函数等, 无论实参是何种类型的量,进行函数调用,它们都必须具有...
  • 当你写的函数方法,要被其他人调用, 你想让他知道传入参数的数据类型, 可以这样定义 def demo(name: str, age: int): print(name, type(name)) print(age, type(age)) demo(1, 2) # 这里的参数1会显示黄色, 但是...
  • 函数的定义一般形式

    千次阅读 2019-07-23 13:46:02
    函数定义的一般形式 ...很多情况下都不要求无参函数有返回值,此时函数类型说明符可以写为void函数名是由用户定义的标识符,函数名后面有一个空括号,其中无参数,但括号不可少。{}中的内容称为函数体。定义一...
  • python中,函数的参数除了最基本的必选参数,默认参数外,主要包含以下几种特殊的参数类型:可变参数,关键字参数,...函数定义时,他们定义的顺序为:必选参数、默认参数、可变参数、命名关键字参数和关键字参数
  • C_带参数的宏定义

    万次阅读 多人点赞 2018-05-24 11:13:35
    定义中的参数称为形式参数宏调用中的参数称为实际参数。 对带参数的宏,调用中,不仅要宏展开,而且要用实参去代换形参。 带参宏定义的一般形式为#define 宏名(形参表) 字符串 带参宏调用的一般形式为...
  • Oracle存储过程之带有返回参数

    万次阅读 2015-12-24 17:15:11
    1、基本语法 创建存储过程,需要有CREATEPROCEDURE或CREATE ANY PROCEDURE的系统权限。该权限可由系统管理员授予。创建一个存储过程的基本语句如下: ...[说明部分:参数定义、变量定义、游标定义] BEGIN  可
  • 函数的参数定义函数的时候,我们把参数的名字和位置确定下来,函数的接口定义就完成了。对于函数的调用者来说,只需要知道如何传递正确的参数,以及函数将返回什么样的值就够了,函数内部的复杂逻辑被封装起来,调用...
  • 各种python 函数参数定义和解析

    万次阅读 2014-04-18 17:25:22
    函数参数在调用过程中是如何解析的。首先说一下在python 中的函数调用过程是分四种方式的,这里且先说五种,第五种已经在以前的文章中说过了。 1.参数枚举的函数定义: >>> def Fun(a,b,c): return (a,b,c) >>> ...
  • 函数中的形式参数和实际参数

    千次阅读 多人点赞 2014-03-20 10:58:30
    c语言中实际参数和形式参数之间采用值传递的方式来传递数据。被调函数中,使用的是实际参数的一个拷贝数据。我们swap函数中交换了a和b,那只是主函数x,y数据的一个辈分,不能对main函数中的x,y产生影响,就像...
  • SQLserver创建参数化存储过程

    千次阅读 2019-01-16 21:54:49
    ql数据库的存储过程是一种你关闭数据库,储存你代码的一种方法,并且能实现以简短的指令来修改你的数据。, 那么就让我们看看这简短明了的参数化存储过程。 一.打开SQL数据库,找到你的数据库。 找到可编程性这...
  • 第5.2节 Python中带星号的函数参数实现参数收集

    千次阅读 多人点赞 2019-05-29 12:05:14
    Python的函数支持可变不定数量的参数模式,这种将不定数量实参调用传递给函数,函数将其识别并保存到指定形参的过程称为参数收集: 1、带一个星号的参数收集模式 这种模式是函数定义时在某个形参前面加一...
  • 参数的宏定义

    千次阅读 2014-11-16 09:41:18
    参数的宏定义的一般形式如下:  #define ()  其中, 是一个标识符,中的参数可以是一个,也可以是多个,视具体情况而定,当有多个参数的时候,每个参数之间用逗号分隔。是被替换用的字符串,宏体中的字符串...
  • 定义中的参数称为形式参数宏调用中的参数称为实际 参数。 对带参数的宏,调用中,不仅要宏展开,而且要用实参去代换形参。 带参宏定义的一般形式为: #define 宏名(形参列表) 字符串 字符串中含有各个...
  • 网络分析仪中的S参数定义及表达

    万次阅读 多人点赞 2019-08-16 10:33:22
    我们知道,高频电路中不能用一个确定的数值来代表这个元器件的特性,因为随着频率的变化其特性也发生变化。也不能让系统只工作一个频率上面,此时直流电路中的欧姆定律概念已经失效,现在需要引入网络的概念...
  • Python函数定义-位置参数-返回值

    千次阅读 2019-05-04 20:37:38
    1 函数介绍 函数编程语言中就是完成特定功能的一个词句组(代码块),这组语句可以作为一个单位使用,并且给它取...数学中的定义,这里就不介绍了。因为没卵用。哈哈 1.1 为什么要使用函数 编程中使用函数主...
  • def isValid(s: 'str') -&...这里的参数:‘注解内容’ 和 箭头‘注解内容’的用法是为标注了参数和返回值的类型,使代码更具有阅读性 和 def isValid(s):  return s 效果上其实没有区别...
  • 存储过程参数的三种模式

    千次阅读 2017-10-12 09:27:07
    (1)in:用于接受调用程序的值。(默认的参数模式) (2)out:用于向调用程序返回值。 (3)in out:用于接受调用程序的值,并向调用程序返回更新的值。
  • 1.python中的位置传递:先用形式参数定义,然后调用对应位置使用实参(具体的数值)调用 def sum(a, b):  return a + b sum(5, 6)
  • Python中必选参数、默认参数、可变参数、命名关键字参数、关键字参数的区别:
  • 定义一个存储过程,以员工编号为参数,返回该员工的工作年限。
  • Python 函数定义以及参数传递

    万次阅读 2017-02-22 16:19:37
    doSomething以关键字def 开头,后面是函数名和参数下面是函数处理过程。 举例:def add( a, b ): return a+b参数可以设定默认值,如:def add( a, b=10 ): return a+b2.参数传递def func(a, b): pr

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,251,061
精华内容 500,424
关键字:

参数在过程定义时是形式参数