精华内容
下载资源
问答
  • 今天系统的讲解了定义函数传参数的问题,不管是传一个参数,还是多个参数,又或者部分参数要求参数名,部分参数不需要函数名。还讲了函数包装的用法,装饰器函数的定义。 一,多个参数,不知道有没有参数名 ...

    2018.03.12
    author: wills

    在python中,不管是传一个参数,还是多个参数,又或者部分参数要求参数名,部分参数不需要函数名,都有严格的语法要求。

    一,多个参数,不知道有没有参数名

    def say_hello(*args,**kwargs):

    
    def say_hello(*args,**kwargs):
        if 'name' in kwargs:
            print('你好,%s!' % kwargs['name'])
        elif 'age' in kwargs:
            age = kwargs['age']
            if age <= 15:
                print('你还小')
            else:
                print('你是大人了')
        else:
            print('你是谁')
        print(args)
        print(kwargs)

    关键字参数(**kwargs) :传进来—->一个字典—->根据参数名决定如何执行

    可变参数(*args):传进来的是一个元组tuple

    如果想直接传字典作为可变关键字参数,需要在字典前面加 ‘**’

        dict1 = {'name':'will','age':22}
        say_hello(**dict1)

    如果直接传元组,列表作为可变参数,需要在元组,列表前加 ‘*’

        tuple = (1,2,34,5)
        say_hello(*tuple)

    命名关键字参数

    ## 命名关键字参数 ,* 后面的参数,必须给参数名,前面的可给可不给
    def foo(a,e,d,*,name,age):
        print(a+e+d)
        print('%s' % name +':'+'%s' % age)
    
    foo(a=1,d=33,e=123,name='gppd',age=12)
    foo(2,2,3,name='will',age=85)

    高阶函数

    为了提高函数的通用性,又要符合函数高内聚的特性,我们可以把简单函数当做参数传入函数里,构成一个根据参数不同实现不同功能的高级函数,这就是高阶函数。见下例

    def cal(list,op):
        total = list[0]
        for x in range(1,len(list)):      
            total = op(total,list[x])
        return total 
    # 通过向函数中传入函数,可以写出更通用的代码
    # cal 函数中第二个参数是另一个函数,他代表了一个二元运算
    # 这样cal函数就不需要和某个特定二元运算耦合在一起
    # 所以cal函数变得通用性更强,可以由传入的第二个参数决定函数到底做什么
    # 高内聚,低耦合  high cohesion low coupling
    # 高内聚:函数做好一件事就好了
    def add(x,y):
        return x+y
    def mul(x,y):
        return x * y
    
    lis=[1,3,5]
    print(cal(lis,add))
    print(cal(lis,mul))

    很重要的函数方法decorator(),它的作用是装饰另一个函数使得另一个函数自身不变的情况下拥有更多的功能

    def record(fn):
        def wrapper(*args,**kwargs):
            print('准备执行%s函数 ' % fn.__name__)
            print(args)
            print(kwargs)
    
            # 此时正在执行被装饰的函数
            # 在这行代码的前后我们可以附加其他代码
            # 这些代码可以让我们在执行函数时做一些额外的工作
            val = fn(*args,**kwargs)
    
            print('执行%s函数之后。。。' % fn.__name__)
            print('return %d' %val)      
            return val
            # 返回被装饰函数的执行结果       
        return wrapper
    
    # 通过装饰器修饰f函数,让f函数在执行时可以做更多额外的操作
    @record
    def f(n):
        if n == 0 or n == 1:
            return 1
        return n * f(n-1)
    
    if __name__ == '__main__':
        print(f(5))
    

    命名关键字参数 ,* 后面的参数,必须给参数名,前面可给可不给

    def foo(a,e,d,*,name,age):
        print(a+e+d)
        print('%s' % name +':'+'%s' % age)
    
    foo(a=1,d=33,e=123,name='gppd',age=12)
    foo(2,2,3,name='will',age=85)
    
    def record(fn):
        def wrapper(*args,**kwargs):
            print('准备执行%s函数 ' % fn.__name__)
            print(args)
            print(kwargs)
    
            # 此时正在执行被装饰的函数
            # 在这行代码的前后我们可以附加其他代码
            # 这些代码可以让我们在执行函数时做一些额外的工作
            val = fn(*args,**kwargs)
    
            print('执行%s函数之后。。。' % fn.__name__)
            print('return %d' %val)      
            return val
            # 返回被装饰函数的执行结果
    
        return wrapper
    # 通过装饰器修饰f函数,让f函数在执行时可以做更多额外的操作
    @record
    def f(n):
        if n == 0 or n == 1:
            return 1
        return n * f(n-1)
    
    if __name__ == '__main__':
        print(f(5))
    

    下面就是递归求阶乘函数被装饰后运行过程,可以更清楚的看到被装饰函数f(n)每一步是怎么运行的

    准备执行f函数
    (5,)
    {}
    准备执行f函数
    (4,)
    {}
    准备执行f函数
    (3,)
    {}
    准备执行f函数
    (2,)
    {}
    准备执行f函数
    (1,)
    {}
    执行f函数之后。。。
    return 1
    执行f函数之后。。。
    return 2
    执行f函数之后。。。
    return 6
    执行f函数之后。。。
    return 24
    执行f函数之后。。。
    return 120
    120

    展开全文
  • 既然说道传值还是引用,就要说到c++了(据我所知python中没有这些概念)。假定题主和读者们对C++有所了解。首先复习一下实参和形参的概念,看foo函数,假设这是个c++函数,那么foo(a)调用过程中,a就是实参,b...

     

    a = [1,2,3]
    def foo(b):
        b.append(4)
    foo(a)
    print(a)  #  [1,2,3,4]
    
    def bar(c):
        c = [0,0,0]
    bar(a)
    print(a)  # [1,2,3,4]
    

    既然说道传值还是传引用,就要说到c++了(据我所知python中没有这些概念)。假定题主和读者们对C++有所了解。首先复习一下实参和形参的概念,看foo函数,假设这是个c++函数,那么foo(a)调用过程中,a就是实参,b就是形参,如果对这个概念模糊,好好看下c++primer中的关于函数参数传递那一部分的内容,此处不再赘述。再来看看传值和传引用:

    • 传值是要把实参的值copy一份给形参作为值的,然后形参在函数中的操作就和实参没有关系了,这显然不是python中的传参方式,看 foo 函数就好理解了,若传值,b会copy一份[1,2,3],执行完b.append(4),变为[1,2,3,4],但是b的改变不会影响a,而事实上 a也改变了。
    • 传引用是使用形参给实参取一个别名(alias),函数中对形参的操作实际上就是对实参的操作,来举个c++中传引用的例子:
    //命名空间和头文件此处省略了
    void test(vector<int>& vi)
    {
           vi = vector<int>{ 0,0,0 };
    }
    int main()
    {
           vector<int> v{ 1,1,1 };
           test(v); // 因为是传引用,执行结束后 v 变成了vector<int>{ 0,0,0 }
           return 0;
    }
    

    可以看到python也不是传引用,把 bar 函数与此处的 test 函数作对比就知道了, 注意执行bar(a)以后,a不是[0,0,0], a没有改变,所以有答案说对于可变对象是传引用的说法我认为是不对的。

    所以,既不是传值也不是传引用!要搞清楚python函数如何传参数这个问题,本质上要搞清楚的是python中的"name binding",我尽量用自己的话解释简洁一点,更多细节参看最后的链接。我把a, b, foo, bar 这些东西叫做name,而不是叫变量,因为如果使用一个未定义的东西xx,python会报 NameError: name 'xx' is not defined。python中name是没有类型的,而name所指向的对象是有类型的,比如name a 可以指向对象int数1,你也可以让它指向一个list对象。来看下面的代码:

    x = 1
    y = x
    print(y is x) #True 注意此处的is用来比较 y 与 x 所指向的对象是否为同一个,也就是id(x)与id(y)是不是一样的
    # id方法返回的是某对象的id号(一个int值),在其生命周期内保证唯一和不变, id(x)就是返回x所指向的对象的id
    y = 2
    print(y is x) # False
    x += 1 # 此时x的值为2,  x绑定到了对象 int2 上,同时id(x)也会发生改变 
    print(y is x) # True 

    x = 1表示的是给对象int 1绑定了(binging)一个名字(name)叫做x,可以用名字 x来引用int 1 这个对象了。而 y=x 表示的是,现在y 也是对象int 1 的一个名字了,也可以用名字 y来引用对象int 1 了。而y和x是同一个对象的name,所以y is x返回True。现在 y=2, y is x 就是False了,因为name x 和y 指向了不同的对象。 x+=1, 此时注意 id(x)会发生改变, 返回的id是对象int 2的id了。那么你再执行 y is x,就返回True, 因为它们都指向对象int 2。

     

     

     

     

    展开全文
  • python-函数-参数

    2018-04-03 11:29:19
     实参:实际参数,调用函数函数参数,可以是常量、变量、表达式、函数给形参  形参:形式参数,不占内存空间,形参变量只有在调用时才分配内存单元,目的是函数调用时接收实参 二者区别:  实参:是...

    函数就是为了把一堆语句组合到一起形成一个部件:

    1.最大的代码重用,最小的代码冗余
    2.流程的分解,函数讲的是流程,告诉你怎么去做事

    实参和形参

      实参:实际参数,调用函数时传给函数的参数,可以是常量、变量、表达式、函数,传给形参

      形参:形式参数,不占内存空间,形参变量只有在调用时才分配内存单元,目的是函数调用时接收实参

    二者区别:

      实参:是一个变量,占用内存空间,数据传送单向,实参传给形参,不能形参传给实参

      形参:虚拟的,不占用内存空间,形参变量只有被调用时才分配内存单元

    函数传递的参数说明

    python-函数-参数
    python-函数-参数
    python-函数-参数

    标红的部分尤其注意,否则就会有语法错误,另外还有一个就是如果给定了默认值的参数,一定要放在没有默认值的参数后面,放到前面同样会有语法错误,

    *星args返回的是元组tuple元祖 星星args返回的是字典

    python默认会从左到右匹配变量名,对于参数,划线是最好的学习方法
    country没有给就是默认的CN
    python-函数-参数
    ...

    def f(a,b,c)
    prin(a,b,c)
    f(1,2,3)
    输出:1 2 3
    ...

    关键字参数,基于位置的参数首先按照从左到右依次匹配,之后再进行基于关键字匹配,也就是如果使用了关键字传递参数,参数是通过变量名传递而不再是位置。
    ...

    f(1,b=3,c=2)
    1 3 2
    ...

    默认参数 就是调用函数时没有传就用默认的值,传了就用传的值

    ...
    def f(a,b=2,c=3):
    print(a,b,c)
    f(1)
    f(1,2)
    f(1,c=2,b=3)都可以
    ...

    关键字和默认参数混用案例挺简单,一看激动

    python-函数-参数

    任意参数有这两个例子就可以看懂,一个元组,一个字典

    python-函数-参数

    最后这个混合使用的也特别好,画好线一目了然

    python-函数-参数

    另外一个知识点就是解包函数,说的调用函数时传递的参数带有星号,予以为解包,解开元组,解开字典。

    相关连接

    转载于:https://blog.51cto.com/aklaus/2094146

    展开全文
  • python 多进程传参】pool.map() 函数传参数

    万次阅读 多人点赞 2019-09-02 15:16:37
    相信很多人都用过,pool.map()函数,这个函数,有两个参数可以,第一个参数传的是函数,第二个参数传的是数据列表。 那么怎么在第二个数据列表,多几个参数呢,方法是通过对有多个参数的方法进行封装,在进程中...

    无意中发现了一个巨牛的人工智能教程,忍不住分享一下给大家。教程不仅是零基础,通俗易懂,而且非常风趣幽默,像看小说一样!觉得太牛了,所以分享给大家。点这里可以跳转到教程。人工智能教程

    一、背景介绍

    相信很多人都用过,pool.map()函数,这个函数,有两个参数可以传,第一个参数传的是函数,第二个参数传的是数据列表。
    那么怎么在第二个数据列表,多传几个参数呢,方法是通过对有多个参数的方法进行封装,在进程中运行封装后的方法。
    类似如下调用job1()方法:

    # -*- coding:utf-8 -*-
    
    import time
    import multiprocessing
    
    
    def job(x ,y):
    	"""
    	:param x:
    	:param y:
    	:return:
    	"""
    	return x * y
    
    def job1(z):
    	"""
    	:param z:
    	:return:
    	"""
    	return job(z[0], z[1])
    
    
    if __name__ == "__main__":
    	time1=time.time()
    	pool = multiprocessing.Pool(2)
    	data_list=[(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10)]
    	res = pool.map(job1,data_list)
    	time2=time.time()
    	print(res)
    	pool.close()
    	pool.join()
    	print('总共耗时:' + str(time2 - time1) + 's')
    

    二、运行结果:

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    总共耗时:0.24999451637268066s
    
    Process finished with exit code 0
    
    展开全文
  • Python函数、模块

    2021-03-01 18:30:06
    Python函数、模块函数四种传参数的方法模块 函数 函数简介 定义函数使用def ,函数体写在缩进块中,函数的返回值用return语句返回,函数执行完毕也没有return语句时,自动return None 如果想定义一个什么事也不...
  • Python函数进阶

    2020-08-03 20:39:18
    1.怎么确定调用函数的时候参数传什么值 看这个参数函数中是怎么使用的 2.实参高阶函数的应用 除了写装饰器以外,一般不会自己去定义实参高阶函数,主要是使用系统已经定义好的实参高阶函数。 系统中常用的实参高...
  • 在不改变函数的结构的基础,我们给函数加新的功能,用是函数装饰器,如果要给函数传递参数,那么应该怎么做呢 @timerdef test2(name,age): time.sleep(3) print('name: %s age: %s' % (name, age)) test2('dongye'...
  • 1,函数 函数的命名: 纯小写 小驼峰命名法--------get_max_value ...pass:当我们还不知道函数的内容怎么实现的时候,可以先使用pass,不然会报错的 函数体:可以是前面学习的所有的知识,逻辑处理
  • 请问下面函数中char2unm是什么用法,map中调用此函数为什么没有传参数 ``` >>> from functools import reduce >>> def fn(x, y): ... return x * 10 + y ... >>> def char2num(s): ... return {'0': 0, '1':...
  • Python 参数化装饰器

    2019-04-18 12:51:12
    在解析源码中的装饰器时,Python 会把被装饰的函数作为第一个参数传给装饰器函数,那怎么让装饰器接受其他参数呢? 答案是建立一个装饰器工厂函数,返回一个装饰器,然后再把它应用到要装饰的函数上。 举例: # ...
  • Python中的自定义sum函数

    千次阅读 2017-06-10 19:46:10
    郑重声明,我写的是一个sum函数,虽然不知道python内置的是怎么实现的,在写之前,也从未看过源码 def sum(*args): return reduce(lambda x,y:x+y,args) 的是可变参数,当然要是其他的也好改 我自己感觉这...
  • python中map函数怎么用?使用方法举例说明 使用方法 map(function,iterable,…)函数,其中function传入的是一个函数名,可以是python的内置,也可以是自定义的。参数iterable的是一个可以迭代的对象,例如列表...
  • 但是当需要给这个回调函数传更多参数的时候,顿时不知怎么弄了。后来想到了python闭包的方式,果然可行。   不自定义参数函数是这样写的: import pyhook hm = pyHook.HookManager() hm.Ho...
  • 这个概念说实话以前听过,但没深究过,也没用到过…但是被人问到了,就查来记录...少传参数 更短 更简洁 说白了都是一个事情…… 那么先看一下,如果我们自己要实现这个功能,会怎么搞? 看下面这个例子 ''' 遇到问
  • 怎么确定调用函数的时候参数传什么值 def func2(x): print(x + 10) func2(1) func2(1.34) func2(True) def func3(x): print(x[1]) func3('abc') func3([10, 20, 30]) func3((1, 2, 3)) def func4(x: list): x...
  • 爬虫在使用中,难免会遇到需要将在start_request中的某个关键在,给parse,然后通过item存入数据库中,那么怎么才能呢? 如上图,在callback中,使用lambda函数 例子:callback=lambda response,port=1,port_2=2:...
  • python实战学习

    2021-06-04 15:19:36
    在阅读很多python项目时,我们常常会看到@staticmethod,@classmethod 和 @property,这究竟是怎么一回事呢,赶快来跟小编...即,将函数 B 作为参数传给 A() 函数 二。内置函数装饰器 2.1@staticmethod, 返回函数的静态
  • python_装饰器

    2020-12-25 20:40:38
    装饰器是python基础语法中比较晦涩难懂的地方,借此机会,谈谈自己对装饰器的理解。 文章目录一、什么是装饰器二、为什么要有装饰器三、怎么用装饰器四、语法糖 一、什么是装饰器 ...这里是为deco参数.
  • 因为经常会用到这种用法:一个参数传进来,然后给一个返回值出去,所以把这种函数变成一个lambda,其实有时候expression就是一个公式,把参数定义好,公式一算就返回出去了,所以用lambda这样一个函数来定义。...
  • 一个s参数进行判断,如果有空字符它会切掉前后的空字符,返回一个新的s,这个新的s还有的话会继续执行这种重复的操作,类似于递归(博主不怎么会递归),所以没有用循环也能做到循环的效果,看似是静态但因为递归...
  • 怎么连接主机----两种方法,一种是在实例化时传入ip地址连接主机(tn = telnetlib.Telnet(host_ip,port=23)),第二种是,先不传参数进行实例化再用open方法连接主机(我这里使用的方法) 怎么输入用户名密码----...
  • 特点:有默认参数self,self在调用的时候不用传参,系统自动将当前对象给self。 什么时候使用:如果实现函数的功能需要对象属性就使用对象方法(对象方法中的self可以用来提供需要所有的对象属性)。 2. 类...
  • c++中嵌入python入门3

    2011-10-16 22:53:13
    c++中嵌入python入门3 这次主要讲讲怎么python中的class嵌入到c++中去。顺便讲讲元组的操作和怎么编译python源...由于参数是通过元组进去的,所以我们不能老是通过Py_BuildValue这个函数来操作元组,那样太不方
  • 怎么连接主机----两种方法,一种是在实例化时传入ip地址连接主机(tn = telnetlib.Telnet(host_ip,port=23)),第二种是,先不传参数进行实例化再用open方法连接主机(我这里使用的方法) 怎么输入用户名密码----...
  • Python中的一切都是类,所有的变量都是一个对象的引用。引用的值是由函数确定的,因此无法改变。但是如果一个对象是可以被...所谓引用是有一个参数在内存有个地址,地址里面放了一堆东西,在调用函数时,把实际...
  • 特点: 自带参数self(如果使用对象去调用对象方法,对象方法中self不用传参,系统会自动将当前对象给self) self指向当前对象 怎么调用:对象.方法() 2)类方法 怎么定义:在定义函数前加 @classmethod
  • Python学习笔记(四)

    2018-07-03 23:41:00
    1.函数补充  1.全局变量与局部变量      如果要在函数里面修改全局变量的话,要用global声明,之后就可以修改了 ...当不确定后面几个参数时,可以使用*args来声明,多个参数会放在一个list里,可...
  • python3.8测试版出来了,我们来介绍一些变动,代码演示一下,当然底层相关的细节变动就不...这是一个很简单的函数,但是现在我的需求是让参数z只能以关键字参数的方式传递,该怎么做呢? 现在的话,我调用foo(1, 2...
  • 学习python的第十四天

    2020-08-08 15:11:29
    特点:自带参数self(如果使用对象去调用对象方法,对象方法中self不用传参,系统会自动将当前对象给self)self指定当前对象 怎么调用: 对象.方法() 2)类方法 怎么定义:在定义函数前加@classmethod 特点:自带...
  • python29 1.元类 2. 异常

    2019-05-24 18:55:00
    今日内容: 1.元类 2.异常 Python:一门动态语言 最大特点:运行期间动态生成类,修改对象属性 ... 例如,存储到列表中,或者作为参数传函数等等 对象是如何产生的? 通过实例化产生的 ...

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
关键字:

python函数怎么传参数

python 订阅