精华内容
下载资源
问答
  • 最近在整理python的一些易混淆的基础知识,今天就想着记录一下关于函数参数的一些特点和区别。因此又跑去看了一下廖雪峰的教程,强化一下基础。1.默认参数当想调用一个带默认参数的函数的时候,其实就是为了降低调用...

    最近在整理python的一些易混淆的基础知识,今天就想着记录一下关于函数参数的一些特点和区别。因此又跑去看了一下廖雪峰的教程,强化一下基础。

    1.默认参数

    当想调用一个带默认参数的函数的时候,其实就是为了降低调用难度,而如果还想需要更复杂的调用时,又可以传递更多的参数来实现时,函数只需要定义一个,不管简单复杂与否。

    举个栗子:

    def person(name, gender, age=21, city='ShenZhen'):

    print('name:', name)

    print('gender:', gender)

    print('age:', age)

    print('city:', city)

    当你想调用person时

    >>>person('Sombody',male)

    name:Somebody

    gender:male

    age:21

    city:ShenZhen

    当然你不想用age=21和city='ShenZhen'做默认参数你也可以这样:

    >>>person('Sombody',male,30)

    name:Somebody

    gender:male

    age:30

    city:ShenZhen

    >>>person('Sombody',male,city='BeiJing')

    name:Somebody

    gender:male

    age:21

    city:BeiJing

    既可以按照默认顺序,也可以不按照顺序。

    大坑:

    >>>def extendList(val, list=[]):

    ··· list.append(val)

    ··· return list

    结果为:

    >>>list1 = extendList(10)

    >>>print("list1 = %s" % list1)

    list1 = [10]

    >>>list3 = extendList('a')

    >>>print("list3 = %s" % list3)

    list3 = [10, 'a']

    很多人觉得list1 应该等于 [10] , list3 应该等于 ['a'],认为 list 的参数会在 extendList 每次被调用的时候会被设置成它的默认值 []。

    可事实是这样子:

    在extendList函数在初始化时,list被初始化一次,它的值为[ ],因为默认参数list也是一个变量,它指向[ ] 对象,如果在调用extendList时,没有被指定的列表参数调用,如list2 = extendList(123,[]),其实就是使用相同的[ ]列表。所以默认参数值改变时,不再是函数定义时的[ ]了。list2是操作它创建独立的列表(通过传递它自己的空列表作为list参数的值)。

    改进如下:

    >>>def extendList(val, list=None):

    ... if list is None:

    ... list = []

    ... list.append(val)

    ... return list

    结果为:

    list1 = [10]

    list2 = [123]

    list3 = ['a']

    因此要记住:定义默认参数时,默认参数必须指向不变对象!

    2.可变参数

    可变参数顾名思义就是调用函数时,传递参数的个数的可变的。

    举个栗子:

    >>>def calc(*numbers):

    ... sum = 0

    ... for n in numbers:

    ... sum = sum + n * n

    ... return sum

    参数前加个 *表示为可变参数,传的参数要么是list,要么是tuple,也可以是0个参数

    >>> calc()

    0

    >>>calc((1,2,3))

    14

    >>>calc(1,2,3)

    14

    这两种是等价的,参数传入的是list,可以把括号省略掉。

    >>>nums = [1,2,3]

    >>>calc(nums[0],nums[1],nums[2])

    14

    >>>calc(*nums)

    14

    这两种都是可行的,一般第二种比较常见。

    3.关键字参数

    关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict.

    >>>def person(name, age, **kw):

    ... print('name:', name, 'age:', age, 'other:', kw)

    调用的时候:

    >>> person('Michael', 30)

    name: Michael age: 30 other: {}

    >>> person('Adam', 45, gender='M', job='Engineer')

    name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

    >>> extra = {'city': 'Beijing', 'job': 'Engineer'}

    >>> person('Jack', 24, city=extra['city'], job=extra['job'])

    name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

    >>> person('Jack', 24, **extra)

    name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

    **extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数,kw将获得一个dict,注意kw获得的dict是extra的一份拷贝,对kw的改动不会影响到函数外的extra。

    4.命名关键字参数

    >>>def person(name, age, *, city, job):

    ... print(name, age, city, job)

    *右边为关键字参数,调用的时候必须要传入参数名,否则会报错。

    >>> person('Jack', 24, city='Beijing', job='Engineer')

    Jack 24 Beijing Engineer

    当然也可以有缺省值:

    >>>def person(name, age, *, city='Beijing', job):

    ... print(name, age, city, job)

    >>> person('Jack', 24, job='Engineer')

    Jack 24 Beijing Engineer

    5.参数组合

    >>>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 kw = {'ext': None}

    通过tuple和dict调用

    >>> args = (1, 2, 3, 4)

    >>> kw = {'d': 99, 'x': '#'}

    >>> f1(*args, **kw)

    a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}

    >>> args = (1, 2, 3)

    >>> kw = {'d': 88, 'x': '#'}

    >>> f2(*args, **kw)

    a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

    展开全文
  • 命名关键字参数

    2018-09-26 20:19:00
    # _*_ coding: utf-8 _*_# 补充day10 命名关键字参数# 命名关键字参数:在定义函数时,*与**之间参数称之为命名关键字参数# 特点:# 在调用函数时,命名关键字参数必须按照key:value形式传值# def function(x,*,y...
    # _*_ coding: utf-8 _*_
    # 补充day10 命名关键字参数
    # 命名关键字参数:在定义函数时,*与**之间参数称之为命名关键字参数
    # 特点:
    # 在调用函数时,命名关键字参数必须按照key:value的形式传值

    # def function(x,*,y=1,z):
    # print(x)
    # print(y)
    # print(z)
    #
    # function(1,z=2)
    # 1 x
    # 1 y
    # 2 z

    # def func(a,b=2,*args,c,**kwargs):#位置参数、默认参数、关键字参数
    # print(a)
    # print(b)
    # print(args)
    # print(c)
    # print(kwargs)
    #
    # func(1,10,3,2,1,c=2,d=2,z=1)
    # 1
    # 10
    # (3, 2, 1)
    # 2
    # {'d': 2, 'z': 1}

    转载于:https://www.cnblogs.com/OutOfControl/p/9709401.html

    展开全文
  • 一些函数,同时它们具有许多参数,而此刻你只想对其中一部分进行指定,那你可以对它们进行命名,从而给你想指定参数赋值,这就是关键字参数。 简单说就是: 使用命名(关键字)来指定函数中参数。 特点: ☞不...

    调用函数时可以使用的参数类型有以下五种:
    (1)必须参数。
    (2)关键字参数。
    (3)默认参数。
    (4)可变参数。
    (5)组合参数。
    一、必须参数
    即函数调用时必须要传的参数。
    特点:
    ☞ 以正确顺序传入函数。
    ☞ 调用时的数量必须与声明时的数量一致。
    例如:
    在这里插入图片描述
    在这里插入图片描述
    二、关键字参数
    一些函数,同时它们具有许多参数,而此刻你只想对其中一部分进行指定,那你可以对它们进行命名,从而给你想指定的参数赋值,这就是关键字参数。
    简单的说就是:
    使用命名(关键字)来指定函数中的参数。
    特点:
    ☞不需要考虑参数顺序,Python解释器能够用参数名匹配参数值。
    ☞我们可以只对那些我们希望赋予的参数赋值,只要其它的参数都具有默认参数值。
    例如:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 2、关键字参数在调用时(实参)中不必按照形参中顺序来,只要传递参数名=传递参数值即可。 3、在实参中可以用“参数名=参数值”调用位置参数,但必须遵守第一条。 def testTwo(x, y, z=1): p...

    关键字参数: 就是在形式参数中必须要提供”传递参数名=传递参数值”

    位置参数:  仅仅只有参数名

    特点:1、位置参数只能出现在关键字参数之前,不管是在行参还是实参中。 2、关键字参数在调用时(实参)中不必按照形参中的顺序来,只要传递参数名=传递参数值即可。

    3、在实参中可以用“参数名=参数值”调用位置参数,但必须遵守第一条。

    def testTwo(x, y, z=1):
        print(x, y, z)
    
    if __name__=='__main__':
        testTwo( 1,y=2,z=3)
        testTwo(z=3,y=2,x=1)

     上面打印结果:

    1 2 3
    1 2 3

    如果这样写就会出错:

    testTwo( z=3,1,2)
    testTwo( x=1,y=1,z=3)

    SyntaxError: non-keyword arg after keyword arg

    转载于:https://www.cnblogs.com/scofi/p/4920989.html

    展开全文
  • 特点:命名关键字参数必须按照key=value形式为其传值 示例1: def func(x, y, *, a, b): print(x, y, a, b) func(1, 2, b=4, a=3) 结果: 1 2 3 4 示例2: def func(x, y, *, a=111111, b): print(x, y, a, ...
  • 二、关键字参数 默认参数(默认形参):在定义函数阶段,就已经被赋值形参,称之为默认参数 特点:在定义阶段就已经被赋值,意味着在调用阶段可以不用为其赋值 关键字实参:在函数调用阶段,按照key=value...
  • final 1.final 类 表示该类不可继承, 2.final 方法 表示该方法不可... final用于基本类型和不可变类型,对象类型不可变只是引用没有意义 4.final 参数 表示在作用域里只能读取不能赋值该final变量 参数传递 ...
  •  特点:在调用函数时,命名关键字参数必须按照key=value形式传值  二、函数对象  函数是第一类对象:指是函数内存地址可以像一个变量值一样去使用  def foo(): #foo=函数内地址  ...
  • 在函数定义阶段括号内定义的参数,称之为形式参数,简称形参, 相当于变量名。 ''' def func(x,y): if x > y: print(x) print(y) '''实参 在函数调用阶段括号内传入的参数,称之为实际参数,简称实参, ...
  • 特点:在调用函数时,命名关键字参数必须按照key=value形式传值 函数对象 函数是第一类对象:指是函数内存地址可以像一个变量值一样去使用 1.变量值可以被引用 2.变量值可以当作参数传给另外一个函数 3...
  • In [3]:print(len(keyword.kwlist))关键字后面不需要使用括号l 函数封装了独立功能,可以直接调用函数名(参数)函数需要死记硬背l 方法和函数类似,同样是封装了独立功能l 方法需要通过对象来...
  • this关键字 this基本概念 这,这个, 表示本类对象引用,...私有关键字 , 一种访问权限修饰符,用来修饰类成员 他一般是封装中封装比较彻底方式语句。 起到封装效果 特点 被修饰成员只能在本类
  • 1、explicit作用 在C++中,explicit关键字用来修饰类的构造函数,... explicit 关键字作用于单个参数的构造函数。 在C++中,explicit关键字用来修饰类的构造函数,被修饰的构造函数的类,不能发生相应的隐式类型转...
  • Java关键字

    2017-10-06 10:45:53
    关键字 1:概述 被Java语言赋予特定含义单词,Java关键字是电脑语言里事先定义,有特别意义标识符,有时又叫保留字,还有特别意义变量。...1:关键字不能用作变量名、方法名、类名、包名和参数 2:got
  • static 关键字

    2021-01-30 10:50:40
    关键字static 关键字静态初始化块参数传值机制 static 关键字 在类中,用static声明成员变量为静态成员变量,也称为类变量。 类变量生命周期和类相同,在整个应用程序执行期间都有效。它有如下特点: 1. 为该类...
  • Java关键字、标识符

    2020-08-10 15:47:47
    Java的关键字对Java编译器有特殊意义,他们用来表示一种数据类型,或者表示程序结构等,关键字不能用作变量名、方法名、类名、包名和参数。 二、关键字定义和特点 定义:有特殊含义、被保留、不能随意...
  • 关键字解析

    2015-10-07 20:25:24
    定义:电脑语言里事先定义,有特别意义标识符,有时又叫保留字,还有特别意义变量特点:Java的关键字对Java编译器有特殊意义 他们用来表示一种数据类型,或者表示程序结构等 关键字不能用作变量名、...
  • 关键字可以指定采用数目可变的参数的方法参数(不指定参数的数目)。 可以发送参数声明中所指定类型的逗号分隔的参数列表或指定类型的参数数组。 可以不传递参数。 在方法声明中的 params 关键字之后不允许任何其他...
  • 1.重chong载:1>方法名必须一致2>方法参数类型不同和参数名没有关系2.面试题.方法的参数类型不同的几个特点1&...ref参数:用于传递参数的引用,而不是参数的值:使用ref参数引用传递,在参...
  • static关键字的作用

    2018-07-29 09:29:29
    内存分区 1)堆:由程序员手动分配和释放,完全不同于数据结构中的堆,分配方式类似链表,若程序员不释放,程序结束时由系统释放。 2)栈:由编译器自动分配和释放,存放...其中,BSS段的特点是在程序执行之前BSS...
  • java 重写和final关键字

    千次阅读 2018-03-04 22:51:32
    1、方法重写: 子类根据需求对从父类继承来的方法进行改写,是多态机制的前奏,重写方法必须和被重写的方法的方法名、参数列表、返回值相同。 重写方法不能使用比被重写的方法更为...2、final 关键字的特点: ...
  • 在父子类继承关系当中,创建子类对象,访问...概念:在继承关系当中,方法名称一样,参数列表也一样。 public class Demo01ExtendsMethod { public static void main(String[] args) { Zi zi = new Zi(); zi.m
  • 对于初次接触自动化测试时,对数据驱动和关键字驱动不甚理解,觉得有点故弄玄虚,不就是参数和函数嘛!其中也体现了测试所不同与开发一些特点(主要指系统测试),以及和对技术发展脉络展现。一、录制/回放...
  • params 关键字有以下几大特点:params关键字可以指定采用数目可变的参数的方法参数(不指定参数的数目)。 可以发送参数声明中所指定类型的逗号分隔的参数列表或指定类型的参数数组。可以不传递参数。 在方法...
  • 在创建对象时,为指定属性进行初始化赋值,也可以传入参数为指定属性进行赋值。 构造方法是一个用来初始化一个对象内部状态特殊方法 构造方法没有返回值类型 构造方法主要作用是完成对类对象初始化工作 ...
  • Java 关键字和标识符

    2016-05-29 10:03:00
    Java 关键字和标识符 一、 Java关键字 1. Java 关键字定义  Java的关键字对Java的编译器有特殊意义,它们用来表示一种数据...2. Java 关键字的特点  关键字中所有字母都为小写。 3. Java 关键字分类 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 931
精华内容 372
关键字:

关键字参数的特点