function(函数)中的动态参数

我们可向函数传递动态参数,*args,**kwargs,首先我们来看*args,示例如下:

    1.show(*args)

def show(*args):
    print(args,type(args))
    #以元组的形式向列表传递参数
  show(11,22,33,44,55,66)

首先我们定义了一个函数,函数show(*args)里面的*args可以接收动态参数,这里我们接收一个元组形式的参数,我们可以向show()里面传递很多参数,函数默认把这些参数作为一个元组进行接收。

    2.show(**args)

def show(**kwargs):
    print(kwargs,type(kwargs))
    #以字典的形式向函数传递参数
  show(k1=80,k2="alex")

由上面代码可以看出,**kwargs是以字典的形式接收参数的,我们知道,字典是由键-值对组成的,key-value,因而我们必须向里面传入键-值对的参数形式才能够接收,因此我们在里面传入了参数k1=80,k2="alex".这样生成了一个字典,从代码可以看出来。

    3.show(k,*args)

def show(k,*args):
    print(k,type(k))
    print(args,type(args))

  show([11,22],33,44,55,88)

运行结果如下:

[11, 22] <class ‘list‘>
  (33, 44, 55, 88) <class ‘tuple‘>

由上面代码可以看出,我们向函数定义了两个参数,一个是k,一个是*args,我们知道,形参k只能接收一个对象参数,*args可以接收多个参数并且放在一个元组中,下面我们向函数传递了多个参数,看是如何接收的。从运行结果(1)可以看出,形参k接收了参数[11,22];而后面输入的值传递给了*args,并在存放在一个列表中。

    4.show(*args,**kwargs)

只要函数有这两个参数那么,可以传递任何形式的实参进来,人当杀人,佛当杀佛,因为可以接收任意形式的参数,但是我们知道,字典必须是由键值对组成,传递的参数要满足key=value的格式,否则会报错。这点一定要记得,Python中默认给字典传递参数的方法就是键-值对。

  def show(*args,**kwargs):      print(args,type(args))      print(kwargs,type(kwargs))

  show(123,"alex",666,alex="sb",nanyang="degnzhou")  运行结果如下:

(123, ‘alex‘, 666) <class ‘tuple‘>
  {‘nanyang‘: ‘degnzhou‘, ‘alex‘: ‘sb‘} <class ‘dict‘>

我们可以看到,前面的元素被放到了一个元组tuple中,后面的元素被放到了一个字典dict中,但是我们一定要记得,*args,一定要在**kwargs前面,不然会报错,顺序一定是单个参数,动态元组,动态字典方式。

  下面我们来看一个实例:

def show(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))

  l = [11,22,33,44]
  d = {"n1":88,"alex":"sb"}
  #我们想把列表l传递给形参*args,把字典传递给形参**kwargs,看下面方式是否可以
  show(l,d)                  (1)

  #如果向实现上面功能,要进行表示,指定把哪个参数传递给形参*args,另一个参数传递给形参××kwargs
  show(*l,**d)                 (2)

上面代码中,我们在(1)处直接调用参数,但是得到的结果不是我们想要的,我们想要把参数以列表或者字典的形式传给对应的形参,那么必须标明是传递给哪个参数的,相当于默认参数一样。否则只会传递给第一个参数*args,把列表和字典都放在同一个元组中。上面代码的运行结果如下:

运行结果:

([11, 22, 33, 44], {‘alex‘: ‘sb‘, ‘n1‘: 88}) <class ‘tuple‘>
  {} <class ‘dict‘>
  (11, 22, 33, 44) <class ‘tuple‘>
  {‘alex‘: ‘sb‘, ‘n1‘: 88} <class ‘dict‘>

    5.字符串中参数的情况

    (1)字符串格式化,向字符串中传递列表参数

s1 = "{0} is {1}."
  result = s1.format("alex","sb")                (1)
  l = ["alex","sb"]                              (2)
  res = s1.format(*l)
  print(result)
  print(res)

上面,我们有两种向字符串传递参数的方法,方法(1)中我们直接按顺序传递参数给s1,在方法(2)中我们指定一个列表,但是使用*args的形式给字符串s1传递参数。列表是有序的。

    (2)向字符串中传递字典形式的参数

  s1 = "{name} is {acter}."  result = s1.format(name="alex",acter="sb")  d = {"name":"alex","acter":"sb"}  #向列表中传递字典形式的参数  res = s1.format(**d)  print(result)  print(res)  在上面代码中,我们向字符串中传递了一个字典形式的参数,我们知道字典的格式,在传递给字符串的时候要指定我们传递的参数是一个字典,因而要使用**d格式,告诉Python。    6.lambda表达式    lambda简单表达式就是函数的简单表示形式:    >>> func = lambda a:a+1  >>> ret = func(99)  >>> print(ret)  100    在上面形式中,func是定义一个函数,lambda表示的是我们定义了一个lambad表达式,其中a代表的形参,冒号(:)后面的a+1代表表达式,对函数进行什么样的处理,然后把结果返回给ret这个变量,调用它的变量。省略了return。    上面形式参数可以有多个,冒号前面是参数,可以多个;冒号后面是函数体。    lambda表达式创建了形参a;函数内容a+1,并把结果返回给调用函数的变量。
时间: 2025-01-05 13:40:10

function(函数)中的动态参数的相关文章

python函数中的动态参数

1.一级指针(*)动态参数一 在python中一个*表示将参数变成一个元组,可以接收多个参数 2.二级指针(**)动态参数二 在python中两个*表示将参数变成一个字典,在传值的时候必须是一对一对(键值对)的传,也可接收多个键值对 3.一级和二级混用时(万能参数) 在python中函数参数中包含一级和二级时,一级必须放到二级的前面 eg:f(p, *a, **b),不能写成f(p, **b, *a) 原文地址:https://www.cnblogs.com/oliverlucqut/p/887

【转】深入理解C++的动态绑定和静态绑定 &amp; 不要重定义虚函数中的默认参数

为了支持c++的多态性,才用了动态绑定和静态绑定.理解他们的区别有助于更好的理解多态性,以及在编程的过程中避免犯错误.需要理解四个名词:1.对象的静态类型:对象在声明时采用的类型.是在编译期确定的.2.对象的动态类型:目前所指对象的类型.是在运行期决定的.对象的动态类型可以更改,但是静态类型无法更改.关于对象的静态类型和动态类型,看一个示例: class B { } class C : public B { } class D : public B { } D* pD = new D();//p

如何在tsung中使用动态参数(一)

这两天给公司一个新项目做上线前的压力测试,这个项目主要的接口有两个,获取订单号(getOrderId)和确认订单(confirm),需要重点压测.开始,我们选择用python写测试例,python的好处是开发迅速,但是并发能力不够:我就想试试用tsung,tsung是用erlang写的,并发肯定没问题,但我以前只用来测试过静态网站,没有测试过动态API,查了查文档,发现tsung是支持用erlang脚本生成动态参数的,于是我决定用tsung. tsung的安装略过,看一下getorderId的配

C/C++函数中使用可变参数

先说明可变参数是什么,先回顾一下C++里面的函数重载,如果重复给出如下声明: 1 int func(); 2 int func(int); 3 int func(float); 4 int func(int, int); 5 ... 这样在调用相同的函数名 func 的时候,编译器会自动识别入参列表的格式,从而调用相对应的函数体. 但这样的方法毕竟有限,试想一下我们假如想定义一个函数,我们在调用之前(在运行期之前)根本不知道我到底要调用几个参数,并且不知道这些参数是个什么类型,例如我们想定义一个

python函数中的默认参数问题

Python 函数中,参数的传递本质上是一种赋值操作 def foo(arg): arg = 2 print(arg) a = 1 foo(a) # 输出:2 print(a) # 输出:1 def bar(args): args.append(1) b = [] print(b)# 输出:[] print(id(b)) # 输出:4324106952 bar(b) print(b) # 输出:[1] print(id(b)) # 输出:4324106952 def foo(x, a_list=

python函数中的关键字参数

关键字参数: 就是在形式参数中必须要提供”传递参数名=传递参数值” 位置参数:  仅仅只有参数名 特点:1.位置参数只能出现在关键字参数之前,不管是在行参还是实参中. 2.关键字参数在调用时(实参)中不必按照形参中的顺序来,只要传递参数名=传递参数值即可. 3.在实参中可以用“参数名=参数值”调用位置参数,但必须遵守第一条. def testTwo(x, y, z=1): print(x, y, z) if __name__=='__main__': testTwo( 1,y=2,z=3) te

关于在函数中返回动态的内存

1.有以下题目: 1 #include <iostream> 2 using namespace std; 3 4 void GetMemeory(char* p) 5 { 6 p=(char*)malloc(sizeof(char)*100); 7 } 8 9 int main() 10 { 11 char *str=NULL; 12 GetMemeory(str); 13 strcpy(str,"Thunder"); 14 strcat(str,"Downlo

微信小程序for循环中传递动态参数

for循环中的参数,没法传到对应的 js里,所以直接在 wxml页面上跳转 发送参数的 wxml页面 <view class="uploader" wx:for="{{bookList}}" wx:for-item = "item"> <navigator url="../catalog/catalog?id={{item.id}}&title={{item.title}}" open-type=&q

函数中的可变参数

可变指的是函数参数的个数可变,可以是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 但是调用的时候,需要先组装出一个