精华内容
下载资源
问答
  • python定义函数时默认参数注意事项

    千次阅读 2020-12-14 07:11:38
    如果在调用一个函数时,没有传递默认参数,则函数内的默认参数是对函数的默认参数属性__defaults__的引用,如def func(arg1=[]): arg1.append(2)调用func时如果没有传参,上面的arg1就是func.__defaults__[0]的引用没...

    如果在调用一个函数时,没有传递默认参数,则函数内的默认参数是对函数的默认参数属性__defaults__的引用,

    def func(arg1=[]): arg1.append(2)

    调用func时如果没有传参,上面的arg1就是func.__defaults__[0]的引用

    没传递默认参数,会发生以下情况

    由于func.__defaults__[0]是可变类型,导致每一次调用func,arg1都会对func.__defaults__[0]进行操作(func.__defaults__[0].append(2),

    这样在有些情况下会导致逻辑出错的,例如

    def func(arg1=[]): if(arg1==[]): print'arg1 is empty' arg1.append(1) else: print'arg1 is not empty'print arg1 func() # arg1 is empty

    func() #arg1 is not empty [1]

    第二次调用func的时候,并没有传递参数arg1,但是第一次调用时,函数内部已经修改了__defaults__

    这是为啥呢?为何第二次调用不重置arg1为[]?

    因为

    Python的默认参数只会在函数定义时被确定,而不是每次调用时重新确定,所以,一旦在函数中修改了默认参数,则再随后的调用中都会生效

    由于有这个特性,在定义函数时,如果默认参数使用可变的对象类型,如上例子,则很可能导致逻辑出错,

    所以,如不是特别需要,则不允许在函数内部对默认参数引用的func.__defaults__属性进行修改,如何能让一个对象不被修改?那就是在操作arg1前取消它对__defaults__的引用

    以上例子改动一下

    def func(arg1=[]): if(arg1==[]): print'arg1 is empty' arg1=[] arg1.append(1) else: print'arg1 is not empty'print arg1

    上例中,在用户没有传递默认参数arg1时,函数内部会给arg1变量重新赋值,让arg1去引用我们想用的对象[],这样arg1就不会修改func.__defaults__了

    如果是默认参数是有值的情况,可以这样操作

    def func(arg1=[1,2,3]): if(arg1==[1,2,3]): print'is [1,2,3]' arg1=[1,2,3] #重点是这里,取消arg1对__defaults__属性的引用,防止arg1修改__defaults__ arg1.append(1) else: print'not [1,2,3]'print arg1

    以上太啰嗦,下例模仿了python官方例子,使用不可变类型(例如None)作为默认参数,逻辑简洁,推荐使用

    def append_to(element, to=None): #默认参数to定义时为None,但函数逻辑中进行进一步重新赋值为想使用的默认值

    if to is None: to = [1,2,3] to.append(element) return to

    总结:

    防止默认参数修改函数的__defaults__,需要:

    1.定义默认参数时,最好使用不可变类型.

    2.如果默认参数一定要使用可变类型,那就在函数内部对默认参数重新赋值为可变类型的具体值.

    python定义函数时的参数&调用函数时的传参

    一.定义函数: 1.位置参数:直接定义参数 2.默认参数(或者关键字参数):参数名 = "默认值" 3.位置参数必须在默认参数之前 二.调用函数: 1.按位置传,直接写参数的值 2 ...

    python定义函数时的默认返回值

    python定义函数时,一般都会有指定返回值,如果没有显式指定返回值,那么python就会默认返回值为None, 即隐式返回语句: return None 执行如下代码 def now(): prin ...

    python中函数的默认参数陷阱问题

    其实也不能说是陷阱,只是一个不容易注意到的地方,尤其是有其他java/c++类编程语言经验的人员,这里涉及到python的一个特点,所以笔者说是陷阱只是一个噱头而已. def test(item, b ...

    python定义函数时,形参前加*和**的意义

    转发:https://blog.csdn.net/qq_34806812/article/details/82017839 1.加*表示接受一个tuple类型(元组),如: 2.加**表示接受一个di ...

    Python 中函数的 收集参数 机制

    定义函数的时候,在参数前加了一个 * 号,函数可以接收零个或多个值作为参数.返回结果是一个元组. 传递零个参数时函数并不报错,而是返回一个空元组.但以上这种方法也有局限性,它不能收集关键字参数. 对关 ...

    Python函数的默认参数的设计【原创】

    在Python教程里,针对默认参数,给了一个“重要警告”的例子: def f(a, L=[]): L.append(a) return L print(f(1)) print(f(2)) print( ...

    在python函数中默认参数的一些坑

    一.默认参数 python为了简化函数的调用,提供了默认参数机制: 这样在调用pow函数时,就可以省略最后一个参数不写: 在定义有默认参数的函数时,需要注意以下: 必选参数必须在前面,默认参数在后: ...

    对C++虚函数使用默认参数的注意事项

    本文为大便一箩筐的原创内容,转载请注明出处,谢谢:http://www.cnblogs.com/dbylk/ 备忘一个关于虚函数的小知识点 使用多态调用一个类型中定义的虚函数时,编译器会根据指针的当前 ...

    C++中函数的默认参数

    使用方法: (1)在函数声明或定义时,直接对参数赋值,该参数就是默认参数. (2)在函数调用时,省略部分或全部参数,这时就会使用默认参数进行代替. 注意事项: (1)一般在声明函数是设置默认参数. 如 ...

    随机推荐

    重写AgileEAS.NET SOA 中间件平台账号密码的加密算法

    一.平台简介 AgileEAS.NET SOA 中间件平台是一款基于基于敏捷并行开发思想和Microsoft .Net构件(组件)开发技术而构建的一个快速开发应用平台.用于帮助中小型软件企业建立一条适 ...

    用Access作为后台数据库支撑。

    /// /// 读取Excel文档 /// /// 文件名称&l ...

    使用C# WinForm制作 员工打卡项目 -- S2 2.3

    新建一个员工类,存储员工的信息 新建一个List<>集合,并在load事件中实例化三个员工对象 DataGridView绑定数据源,可以显示出数据 点击查询按钮,查询工号等同于输入的数的员 ...

    &lbrack;Unity3D&rsqb;开发视图中的标记 - Gizmos

    这个类用来做自己的组件很不错,比如下面这个图的路径点,他其实是个Empty Object,可以自己加脚本让他带上标记.官方解释还可以用来做帮助提示的-.- 大游戏场景的制作时候,你可以用这个在地图上写 ...

    c&num;&plus;ArcEngine中的IGroupLayer的用法

    转自羊子雄起原文c#+ArcEngine中的IGroupLayer的用法 在AE开发中,我们知道axMapControl.LayerCount能获取图层的数量,但是这种方法不能获取到图层组里面的图层, ...

    EDK II代码实例之Variable

    EFI_STATUS Status = EFI_SUCCESS; EFI_GUID OemOSTypeGuid = {0xd06a0bc7, 0x9feb, 0x4cbb, 0xbd, 0x78, 0 ...

    wpf 实现 css3 中 boxshadow inset 效果

    using System; using System.Linq; using System.Windows; using System.Windows.Controls; using System.W ...

    day10 参数args kwargs 作用域

    函数参数/作用域/args/kwargs 1.参数 1.1参数基本知识 任意个数 任意类型 func("1",True) 1.2位置传参(调用函数并传入参数) def func(a ...

    Django之模板1

    Django模板 一.变量(只需要记住两种特殊符号) {{ }} 和{% %} {{ }}表示变量,在模板渲染的时候替换成值,变量名由字母数字和下划线组成. {% %}表示逻辑相关的操作. 点(.)在 ...

    windows下搭建voip服务器

    软件: yate-6.0.0-1-setup.exe 服务端,里面也有个客户端 eyeBeam.exe 客户端 步骤: 失败....

    展开全文
  • Python定义函数实现累计求和操作

    千次阅读 2020-11-30 12:44:32
    一、使用三种方法实现0-n累加求和定义函数分别使用while循环、for循环、递归函数实现对0-n的累加求和1、使用while循环定义一个累加求和函数sum1(n),函数代码如下:2、使用 for循环定义一个累加求和函数sum2(n),函数...

    一、使用三种方法实现0-n累加求和

    定义函数分别使用while循环、for循环、递归函数实现对0-n的累加求和

    1、使用while循环

    定义一个累加求和函数sum1(n),函数代码如下:

    20200503163511.jpg

    2、使用 for循环

    定义一个累加求和函数sum2(n),函数代码如下:

    20200503163523.jpg

    3、使用递归函数

    定义一个累加求和函数sum3(n),函数代码如下:

    20200503163531.jpg

    二、使用了三种实现累加求和的方法,分别定义了三个函数。

    1、对0-100实现累加求和,令n=100,分别调用三个函数,

    代码如下:

    20200503163539.jpg

    2、 控制台的输出结果都为:5050

    20200503163547.jpg

    3、这里需要注意的是:

    1、在while循环中需要定义初始值和累加变量,防止出现死循环;

    2、for循环的作用就是循环遍历;

    3、递归函数一定要设置递归的出口,即当函数满足一个条件时,函数不再执行,目的防止出现死循环;设置当n=1时 ,我们让函数返回1,return后面的代码不在执行。使用return返回值,当我们调用函数的时候需要使用变量进行接收,才能在控制台有输出结果。

    补充知识:在python中,计算Sum = m + mm + mmm +mmmm+.....+mmmmm.....,输入两个数m,n。m的位数累加到n的值,列出算式并计算出结果:

    大家还是直接看代码吧!

    #为了打印出算式,并计算出结果,将m,mm这些放入到列表中

    #定义列表中的m初始值为0,用Ele来代表m,mm....

    Ele = 0

    #定义总和为0

    Sum = 0

    #定义一个空列表

    List = []

    #输入两个值

    n = int(input("input a digit:"))

    m = int(input("input a digit:"))

    #用循环的方式计算每个Ele(m,mm,mmm...)的值

    #同时计算出总和

    for i in range(n):

    Ele = Ele + m #前两行循环计算出每个Ele的值

    m = m * 10

    Sum = Sum + Ele #循环计算出总和

    Str = str(Ele) #将Ele转化为字符串型,方便将列表整个转化成一个长字符串也就是计算公式

    List.append(Str) #循环往列表添加一个Ele在列表的最后位置

    List.append("+") #循环往列表添加一个"+"在列表的最后位置,完成上面循环之后,列表中就出现了["m","+","mm","+","mmm","+"。....,"+"]

    List.pop() #去掉列表中的最后一个加号,算式的最后面是没有加号的

    print("".join(List) + "=",end="") #列表通过("".join)函数转化为字符串并去掉中间的逗号变成m+mm+mmm+...mmm....,再拼接上“=”号,设置打印不换行

    print(Sum) #将计算结果拼接在公式的末尾,一个算式完美的出现了

    以上这篇Python定义函数实现累计求和操作就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持云海天教程。

    展开全文
  • Python定义函数的三种形式

    千次阅读 2020-09-15 20:55:14
    定义函数时参数是函数体接收外部传值的一种媒介,其实就是一个变量名 在函数阶段括号内没有参数,称为无参函数。需要注意的是:定义时无参,意味着调用时也无需传入参数。 如果函数体代码逻辑不需要依赖外部传入的值...

    一、无参函数

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

    在函数阶段括号内没有参数,称为无参函数。需要注意的是:定义时无参,意味着调用时也无需传入参数。

    如果函数体代码逻辑不需要依赖外部传入的值,必须得定义成无参函数。

    def func():
        print('hello nick')
        
    func()  # hello nick
    
    

    二、有参函数

    在函数定义阶段括号内有参数,称为有参函数。需要注意的是:定义时有参,意味着调用时也必须传入参数。

    如果函数体代码逻辑需要依赖外部传入的值,必须得定义成有参函数。

    '''
    遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939
    寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
    '''
    def sum_self(x, y):
        """求和"""
        res = x+y
        print(res)
    
    sum_self(1,2)  # 3
    
    

    三、空函数

    当你只知道你需要实现某个功能,但不知道该如何用代码实现时,你可以暂时写个空函数,然后先实现其他的功能。

    def func():
        pass
    

    结尾给大家推荐一个非常好的学习教程,希望对你学习Python有帮助!

    Python基础入门教程推荐:更多Python视频教程-关注B站:Python学习者
    https://www.bilibili.com/video/BV1LL4y1h7ny?share_source=copy_web

    【Python教程】全网最容易听懂的1000集python系统学习教程(答疑在最后四期,满满干货)

    Python爬虫案例教程推荐:更多Python视频教程-关注B站:Python学习者
    https://www.bilibili.com/video/BV1QZ4y1N7YA?share_source=copy_web

    2021年Python最新最全100个爬虫完整案例教程,数据分析,数据可视化,记得收藏哦

    展开全文
  • Python定义函数(待整理)

    千次阅读 2019-04-01 12:08:04
    定义函数: 格式:在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。 调用函数 数据类型检查 数据类型...

    定义函数:

    格式:在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。

    调用函数

     

    数据类型检查

    数据类型检查可以用内置函数isinstance()

     

    def my_abs(x):
        if not isinstance(x, (int, float)):
            raise TypeError('bad operand type')
        if x >= 0:
            return x
        else:
            return -x

     

    返回多个值:返回值是一个tuple,但是,在语法上,返回一个tuple可以省略括号

    import math
    
    def move(x, y, step, angle=0):
        nx = x + step * math.cos(angle)
        ny = y - step * math.sin(angle)
        return nx, ny
    >>> x, y = move(100, 100, 60, math.pi / 6)
    >>> print(x, y)
    151.96152422706632 70.0

     

    但其实这只是一种假象,Python函数返回的仍然是单一值:

     

     


     

    >>> r = move(100, 100, 60, math.pi / 6)
    >>> print(r)
    (151.96152422706632, 70.0)

    位置参数、默认参数必选参数在前,默认参数在后 

     

    默认参数必须指向不变对象!

     

     

    可变参数

    def calc(*numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum
    

    定义可变参数和定义一个list或tuple参数相比,仅仅在参数前面加了一个*号。在函数内部,参数numbers接收到的是一个tuple,因此,函数代码完全不变。但是,调用该函数时,可以传入任意个参数,包括0个参数:

    >>> calc(1, 2)
    5
    >>> calc()
    0

    Python允许你在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去:

    >>> nums = [1, 2, 3]
    >>> calc(*nums)
    14
    

    *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用,而且很常见。

     

    关键字参数

    def person(name, age, **kw):
        print('name:', name, 'age:', age, 'other:', kw)
    >>> extra = {'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

     

     

     

     

    命名关键字参数

    对于关键字参数,函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些,就需要在函数内部通过kw检查。

    仍以person()函数为例,我们希望检查是否有cityjob参数:

    def person(name, age, **kw):
        if 'city' in kw:
            # 有city参数
            pass
        if 'job' in kw:
            # 有job参数
            pass
        print('name:', name, 'age:', age, 'other:', kw)

     

     

    函数的参数

    阅读: 604997


    定义函数的时候,我们把参数的名字和位置确定下来,函数的接口定义就完成了。对于函数的调用者来说,只需要知道如何传递正确的参数,以及函数将返回什么样的值就够了,函数内部的复杂逻辑被封装起来,调用者无需了解。

    Python的函数定义非常简单,但灵活度却非常大。除了正常定义的必选参数外,还可以使用默认参数、可变参数和关键字参数,使得函数定义出来的接口,不但能处理复杂的参数,还可以简化调用者的代码。

    位置参数

    我们先写一个计算x2的函数:

    def power(x):
        return x * x
    

    对于power(x)函数,参数x就是一个位置参数。

    当我们调用power函数时,必须传入有且仅有的一个参数x

    >>> power(5)
    25
    >>> power(15)
    225
    

    现在,如果我们要计算x3怎么办?可以再定义一个power3函数,但是如果要计算x4、x5……怎么办?我们不可能定义无限多个函数。

    你也许想到了,可以把power(x)修改为power(x, n),用来计算xn,说干就干:

    def power(x, n):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s
    

    对于这个修改后的power(x, n)函数,可以计算任意n次方:

    >>> power(5, 2)
    25
    >>> power(5, 3)
    125
    

    修改后的power(x, n)函数有两个参数:xn,这两个参数都是位置参数,调用函数时,传入的两个值按照位置顺序依次赋给参数xn

    默认参数

    新的power(x, n)函数定义没有问题,但是,旧的调用代码失败了,原因是我们增加了一个参数,导致旧的代码因为缺少一个参数而无法正常调用:

    >>> power(5)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: power() missing 1 required positional argument: 'n'
    

    Python的错误信息很明确:调用函数power()缺少了一个位置参数n

    这个时候,默认参数就排上用场了。由于我们经常计算x2,所以,完全可以把第二个参数n的默认值设定为2:

    def power(x, n=2):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s
    

    这样,当我们调用power(5)时,相当于调用power(5, 2)

    >>> power(5)
    25
    >>> power(5, 2)
    25
    

    而对于n > 2的其他情况,就必须明确地传入n,比如power(5, 3)

    从上面的例子可以看出,默认参数可以简化函数的调用。设置默认参数时,有几点要注意:

    一是必选参数在前,默认参数在后,否则Python的解释器会报错(思考一下为什么默认参数不能放在必选参数前面);

    二是如何设置默认参数。

    当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。

    使用默认参数有什么好处?最大的好处是能降低调用函数的难度。

    举个例子,我们写个一年级小学生注册的函数,需要传入namegender两个参数:

    def enroll(name, gender):
        print('name:', name)
        print('gender:', gender)
    

    这样,调用enroll()函数只需要传入两个参数:

    >>> enroll('Sarah', 'F')
    name: Sarah
    gender: F
    

    如果要继续传入年龄、城市等信息怎么办?这样会使得调用函数的复杂度大大增加。

    我们可以把年龄和城市设为默认参数:

    def enroll(name, gender, age=6, city='Beijing'):
        print('name:', name)
        print('gender:', gender)
        print('age:', age)
        print('city:', city)
    

    这样,大多数学生注册时不需要提供年龄和城市,只提供必须的两个参数:

    >>> enroll('Sarah', 'F')
    name: Sarah
    gender: F
    age: 6
    city: Beijing
    

    只有与默认参数不符的学生才需要提供额外的信息:

    enroll('Bob', 'M', 7)
    enroll('Adam', 'M', city='Tianjin')
    

    可见,默认参数降低了函数调用的难度,而一旦需要更复杂的调用时,又可以传递更多的参数来实现。无论是简单调用还是复杂调用,函数只需要定义一个。

    有多个默认参数时,调用的时候,既可以按顺序提供默认参数,比如调用enroll('Bob', 'M', 7),意思是,除了namegender这两个参数外,最后1个参数应用在参数age上,city参数由于没有提供,仍然使用默认值。

    也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时,需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin'),意思是,city参数用传进去的值,其他默认参数继续使用默认值。

    默认参数很有用,但使用不当,也会掉坑里。默认参数有个最大的坑,演示如下:

    先定义一个函数,传入一个list,添加一个END再返回:

    def add_end(L=[]):
        L.append('END')
        return L
    

    当你正常调用时,结果似乎不错:

    >>> add_end([1, 2, 3])
    [1, 2, 3, 'END']
    >>> add_end(['x', 'y', 'z'])
    ['x', 'y', 'z', 'END']
    

    当你使用默认参数调用时,一开始结果也是对的:

    >>> add_end()
    ['END']
    

    但是,再次调用add_end()时,结果就不对了:

    >>> add_end()
    ['END', 'END']
    >>> add_end()
    ['END', 'END', 'END']
    

    很多初学者很疑惑,默认参数是[],但是函数似乎每次都“记住了”上次添加了'END'后的list。

    原因解释如下:

    Python函数在定义的时候,默认参数L的值就被计算出来了,即[],因为默认参数L也是一个变量,它指向对象[],每次调用该函数,如果改变了L的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时的[]了。

     定义默认参数要牢记一点:默认参数必须指向不变对象!

    要修改上面的例子,我们可以用None这个不变对象来实现:

    def add_end(L=None):
        if L is None:
            L = []
        L.append('END')
        return L
    

    现在,无论调用多少次,都不会有问题:

    >>> add_end()
    ['END']
    >>> add_end()
    ['END']
    

    为什么要设计strNone这样的不变对象呢?因为不变对象一旦创建,对象内部的数据就不能修改,这样就减少了由于修改数据导致的错误。此外,由于对象不变,多任务环境下同时读取对象不需要加锁,同时读一点问题都没有。我们在编写程序时,如果可以设计一个不变对象,那就尽量设计成不变对象。

    可变参数

    在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个。

    我们以数学题为例子,给定一组数字a,b,c……,请计算a2 + b2 + c2 + ……。

    要定义出这个函数,我们必须确定输入的参数。由于参数个数不确定,我们首先想到可以把a,b,c……作为一个list或tuple传进来,这样,函数可以定义如下:

    def calc(numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum
    

    但是调用的时候,需要先组装出一个list或tuple:

    >>> calc([1, 2, 3])
    14
    >>> calc((1, 3, 5, 7))
    84
    

    如果利用可变参数,调用函数的方式可以简化成这样:

    >>> calc(1, 2, 3)
    14
    >>> calc(1, 3, 5, 7)
    84
    

    所以,我们把函数的参数改为可变参数:

    def calc(*numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum
    

    定义可变参数和定义一个list或tuple参数相比,仅仅在参数前面加了一个*号。在函数内部,参数numbers接收到的是一个tuple,因此,函数代码完全不变。但是,调用该函数时,可以传入任意个参数,包括0个参数:

    >>> calc(1, 2)
    5
    >>> calc()
    0
    

    如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做:

    >>> nums = [1, 2, 3]
    >>> calc(nums[0], nums[1], nums[2])
    14
    

    这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个*号,把list或tuple的元素变成可变参数传进去:

    >>> nums = [1, 2, 3]
    >>> calc(*nums)
    14
    

    *nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用,而且很常见。

    关键字参数

    可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。请看示例:

    def person(name, age, **kw):
        print('name:', name, 'age:', age, 'other:', kw)
    

    函数person除了必选参数nameage外,还接受关键字参数kw。在调用该函数时,可以只传入必选参数:

    >>> person('Michael', 30)
    name: Michael age: 30 other: {}
    

    也可以传入任意个数的关键字参数:

    >>> person('Bob', 35, city='Beijing')
    name: Bob age: 35 other: {'city': 'Beijing'}
    >>> person('Adam', 45, gender='M', job='Engineer')
    name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
    

    关键字参数有什么用?它可以扩展函数的功能。比如,在person函数里,我们保证能接收到nameage这两个参数,但是,如果调用者愿意提供更多的参数,我们也能收到。试想你正在做一个用户注册的功能,除了用户名和年龄是必填项外,其他都是可选项,利用关键字参数来定义这个函数就能满足注册的需求。

    和可变参数类似,也可以先组装出一个dict,然后,把该dict转换为关键字参数传进去:

    >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
    >>> person('Jack', 24, city=extra['city'], job=extra['job'])
    name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
    

    当然,上面复杂的调用可以用简化的写法:

    >>> extra = {'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

    命名关键字参数

    对于关键字参数,函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些,就需要在函数内部通过kw检查。

    仍以person()函数为例,我们希望检查是否有cityjob参数:

    def person(name, age, **kw):
        if 'city' in kw:
            # 有city参数
            pass
        if 'job' in kw:
            # 有job参数
            pass
        print('name:', name, 'age:', age, 'other:', kw)
    

    但是调用者仍可以传入不受限制的关键字参数:

    >>> person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)
    

    如果要限制关键字参数的名字,就可以用命名关键字参数,例如,只接收cityjob作为关键字参数。这种方式定义的函数如下:

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

    和关键字参数**kw不同,命名关键字参数需要一个特殊分隔符**后面的参数被视为命名关键字参数。

    调用方式如下:

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

    如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*了:

    def person(name, age, *args, city, job):
        print(name, age, args, city, job)
    

    命名关键字参数必须传入参数名,这和位置参数不同。如果没有传入参数名,调用将报错:

     

    展开全文
  • python定义函数时,指定要传入参数的数据类型 原创小小臭臭g 最后发布于2019-02-13 18:14:49 阅读数 9537 收藏 展开 当你写的函数方法,要被其他人调用时, 你想让他知道传入参数的数据类型, 可以这样定义 def demo...
  • python定义函数时有多个return语句

    千次阅读 2021-08-30 09:43:38
    python用 def 语句创建函数时,return 语句把结果返回到调用的地方,并且退出函数。return 语句在同一函数中可以出现多次,但只要有一个得到执行,就会直接结束函数的执行。 那么当程序运行到第一个return语句的...
  • python 定义函数范例,n的阶乘。

    千次阅读 2020-04-13 19:29:09
    定义n的阶乘函数: 代码如下: def fact(n): s=1 for i in range(1,n+1): s*=i return
  •  if isPrime1(j):#使用isPrime1() isPrime2 isPrime3() isPrime4()函数功能相同效率不同,可以引入time判断使用的时间  #涉及简单计时 http://www.cnblogs.com/didiaoxiaoguai/p/6684094.html    strPrime = ...
  • Python定义函数实现累计求和

    万次阅读 多人点赞 2020-01-31 21:06:02
    Python实现0-n累加求和一、使用三种方法实现0-n累加求和1、使用while循环2、使用 for循环3、使用递归函数二、使用了三种实现累加求和的方法,分别定义了三个函数...定义函数分别使用while循环、for循环、递归函数实...
  • 闰年:所谓闰年即能被4整除,但不能被100整除的年份,或者能被400整除的年份。 def Year(): year = input('请输入一个年份:') year = int(year) # 将年份转换成转换为整数,如果转换一个不符合格式的字符串将会...
  • 1,加*表示接受一个tuple(元组),如: def f(*args): for arg in args: # 取出tuple中的每个元素,然后打印 print(arg) f(1,2,3,4) 1 2 3 ... 2,加**表示接受一个dict(字典),如: ...{'a':...
  • python定义函数求解一元二次方程

    千次阅读 2018-01-17 17:23:10
    #求一元二次方程的根 import math while True: a=int(input('请输入a:')) b=int(input('请输入b:')) c=int(input('请输入c:')) if (a!=0 and b**2-4*a*c>0): def quadratic(a,b,c): ...
  • 1,加*表示接受一个tuple类型(元组),如: def f(*args): for arg in args: # 取出tuple中的每个元素,然后打印 print(arg) f(1,2,3,4) ...2,加**表示接受一个dict类型(字典),如: ...f(a=1, b=2...
  • Python函数中定义函数

    千次阅读 2018-12-07 16:33:38
    函数内部定义函数要在函数内部调用 def paint(): print(&amp;amp;amp;quot;paint&amp;amp;amp;quot;) def paintA(): print(&amp;amp;amp;quot;paintA&amp;amp;amp;quot;) paintA() paint() ...
  • java开发者在定义类中的方法时...补充知识:Python的列表等变量的声明必须要在函数定义函数调用之前 源代码 —–这个代码作用是调用Linux应用终端操作来实现计算,并把计算结果取出来,组成相似矩阵,有五组值也就是
  • python定义函数时,self怎么理解:

    千次阅读 2020-12-06 13:53:21
    定义方法的时候有一个self参数,在所有的方法声明中都要用到这个参数,这个参数代表实例对象本身,当你用实例调用方法的时候,由解释器自动的把实例对象本身悄悄的传递给方法,不需要你自己传递self进来,例如有一...
  • python如何定义函数

    千次阅读 2020-12-21 00:24:36
    Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回。下面自定义一个求绝对值的my_abs函数为例:defmy_abs(x):ifx>...
  • python定义函数的关键字是什么

    千次阅读 2020-12-03 13:00:19
    函数代码块以def关键字开头,后接函数标识符名称和圆括号(),任何传入参数和自变量...你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数定义一个函数可以定义...
  • python 如何定义函数——基础详细

    千次阅读 2020-11-05 12:15:19
    定义函数 定义函数的格式如下 (1)无参数、无返回值 def 函数名(): 代码 (2)无参数、有返回值 def 函数名(): 语句 return 需要返回的数值 注意: 一个函数到底有没有返回值,就看有没有return,因为只有...
  • python中如何定义函数返回值

    千次阅读 2021-01-14 10:09:46
    详细内容返回值简介:简单介绍print和...函数需要先定义后调用,函数体中return语句的结果就是返回值。如果一个函数没有reutrn语句,其实它有一个隐含的return语句,返回值是None,类型也是'NoneType'。return语句的...
  • 先求出两个正整数的质数乘积(单独一个函数)。参考输出,例:40返回值是{"2":3,"5":1}意思是2的3次方*5,就是合并,并且保留指数最大的就行。def gcd(a, b): # 求最大公约数x = a % bwhile (x != 0):a, b = ...
  • 本篇目录:一、 函数的介绍二、 函数的定义三、 定义函数的三种类型四、 函数调用的阶段五、 Return返回值==========================================================================一、 函数的介绍1....
  • Python自定义函数基础概念

    千次阅读 2021-01-14 12:21:04
    一、函数定义语法:def 函数名(形参列表):语句块二、函数定义规则1. 函数的名字就是语句块的名称2. 函数名的命名规则与变量名相同(函数名必须是标识符)3. 函数名是一个变量(不要轻易对其赋值)4. 函数有自己的名字空间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 659,053
精华内容 263,621
关键字:

python定义函数

python 订阅
友情链接: 1坦克大战.rar