Python函数的参数类型

Python函数的参数类型主要包括必选参数、可选参数、可变参数、位置参数和关键字参数，本文介绍一下他们的定义以及可变数据类型参数传递需要注意的地方。

成都创新互联网站建设公司是一家服务多年做网站建设策划设计制作的公司,为广大用户提供了成都网站制作、成都网站设计，成都网站设计，广告投放，成都做网站选成都创新互联，贴合企业需求，高性价比，满足客户不同层次的需求一站式服务欢迎致电。

必选参数（Required arguments）是必须输入的参数，比如下面的代码，必须输入2个参数，否则就会报错：

其实上面例子中的参数 num1和num2也属于关键字参数，比如可以通过如下方式调用：

执行结果：

可选参数（Optional arguments）可以不用传入函数，有一个默认值，如果没有传入会使用默认值，不会报错。

位置参数（positional arguments）根据其在函数定义中的位置调用，下面是pow()函数的帮助信息:

x，y，z三个参数的的顺序是固定的，并且不能使用关键字：

输出：

在上面的pow()函数帮助信息中可以看到位置参数后面加了一个反斜杠 / ，这是python内置函数的语法定义，Python开发人员不能在python3.8版本之前的代码中使用此语法。但python3.0到3.7版本可以使用如下方式定义位置参数：

星号前面的参数为位置参数或者关键字参数，星号后面是强制关键字参数，具体介绍见强制关键字参数。

python3.8版本引入了强制位置参数（Positional-Only Parameters），也就是我们可以使用反斜杠 / 语法来定义位置参数了，可以写成如下形式：

来看下面的例子：

python3.8运行：

不能使用关键字参数形式赋值了。

可变参数 (varargs argument) 就是传入的参数个数是可变的，可以是0-n个，使用星号（ * ）将输入参数自动组装为一个元组（tuple）：

执行结果：

关键字参数（keyword argument）允许将任意个含参数名的参数导入到python函数中，使用双星号（ ** ），在函数内部自动组装为一个字典。

执行结果：

上面介绍的参数可以混合使用：

结果：

注意：由于传入的参数个数不定，所以当与普通参数一同使用时，必须把带星号的参数放在最后。

强制关键字参数（Keyword-Only Arguments）是python3引入的特性，可参考：。 使用一个星号隔开：

在位置参数一节介绍过星号前面的参数可以是位置参数和关键字参数。星号后面的参数都是强制关键字参数，必须以指定参数名的方式传参，如果强制关键字参数没有设置默认参数，调用函数时必须传参。

执行结果：

也可以在可变参数后面命名关键字参数，这样就不需要星号分隔符了：

执行结果：

在Python对象及内存管理机制中介绍了python中的参数传递属于对象的 引用传递 （pass by object reference），在编写函数的时候需要特别注意。

先来看个例子：

执行结果：

l1 和 l2指向相同的地址，由于列表可变，l1改变时，l2也跟着变了。

接着看下面的例子：

结果：

l1没有变化！为什么不是[1, 2, 3, 4]呢？

l = l + [4]表示创建一个“末尾加入元素 4“的新列表，并让 l 指向这个新的对象，l1没有进行任何操作，因此 l1 的值不变。如果要改变l1的值，需要加一个返回值：

结果：

下面的代码执行结果又是什么呢？

执行结果：

和第一个例子一样，l1 和 l2指向相同的地址，所以会一起改变。这个问题怎么解决呢？

可以使用下面的方式：

也可以使用浅拷贝或者深度拷贝，具体使用方法可参考Python对象及内存管理机制。这个问题在Python编程时需要特别注意。

本文主要介绍了python函数的几种参数类型：必选参数、可选参数、可变参数、位置参数、强制位置参数、关键字参数、强制关键字参数，注意他们不是完全独立的，比如必选参数、可选参数也可以是关键字参数，位置参数可以是必选参数或者可选参数。

另外，python中的参数传递属于对象的 引用传递 ，在对可变数据类型进行参数传递时需要特别注意，如有必要，使用python的拷贝方法。

参考文档：

--THE END--

Python参数类型

上一期我们学习参数传递怎么传递，也了解了参数的几种类型。

首先，我们再来回顾一下，形参和实参:

形参是在定义函数时定义的，放在函数名后面的圆括号里,可为空

实参是调用函数时为形参传入具体的参数值

简单总结一下，谁调用函数，谁就负责传入参数。

好呐，本期我们来详细学习函数几种参数类型，大纲如下：

python函数的参数名是无意义的，Python允许在调用函数时通过通过名字来传入参数值。

位置参数：按照形参位置传入的参数

调用函数时，实参默认按位置顺序传递的。同时实参个数也要和形参匹配

举一个小栗子

如果实参的个数与形参不匹配时，调用函数运行就会报错

Python中，形参与调用函数紧密联系在一起的。

关键字参数：调用函数时，使形参名称来传递参数，形式为“形参名=实参”

关键字参数，又叫命名参数，传递时无需考虑参数位置和顺序

举一个小栗子

默认参数：定义函数时，我们可以为形参提前设置具体的值。

在定义函数时，默认参数要放到位置等其他参数后面

在调用函数时，默认参数是可选的。如果传入新值，则会覆盖默认值

举一个小栗子

注意，默认值不能位于位置参数前面，否则程序会报错误

不定长参数又名可变参数。

不定长参数指的是可变数量的参数，分两种情况：

如果不定长参数后面，可以新增参数吗？

我们通过例子来看,会发生什么？

运行上面的程序，Python解释器会报错

原因是，形参a已经是不定长参数，我们调用的test(2,3,4)传入的三个实参,系统自动把它们属于形参a的值，形参b 和形参c就等于没有值传入，这时候系统就认为，调用函数的对象，参数没有传够。

为了解决这一报错，python引入了 强制命名参数

规定，调用不定参数后面有跟位置参数的函数时，传入给位置参数时，必须要强制命名参进行传参。

逆向参数收集针对的对象传入函数的实参

调用函数时，如果实参是元组，列表或者字典，通过在实参前面加入星号，可以自动把元素进行隔开，然后再转入给函数进行处理

举一个小栗子

本期，我们详细学习了参数几种类型，为后面我们学习函数，打好基础。

实践是检验真理的过程，大家多动手练习练习，会有不一样的奇妙旅程~

好呐，以上是本期内容，欢迎大佬们评论区指正~

python中字典里的值不能作为实参

不要那个小数点，取字典中的键值只要中括号就可以。

字典是一种映射，这种数据结构通过名称来访问其各个值特点：1、字典是Python中唯一的内置映射类型。2、字典的值不按顺序排列。3、值存储在键下。

实参是指在调用函数时实际传入的具体数值。

python字典操作函数

字典是一种通过名字或者关键字引用的得数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射。字典类型是Python中唯一内建的映射类型，基本的操作包括如下：

(1)len()：返回字典中键—值对的数量；

(2)d[k]:返回关键字对于的值；

(3)d[k]=v:将值关联到键值k上；

(4)del d[k]:删除键值为k的项；

(5)key in d:键值key是否在d中，是返回True，否则返回False。

(6)clear函数：清除字典中的所有项

(7)copy函数：返回一个具有相同键值的新字典；deepcopy()函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题

(8)fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

(9)get函数：访问字典成员

(10)has_key函数：检查字典中是否含有给出的键

(11)items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

(12)keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器

(13)pop函数：删除字典中对应的键

(14)popitem函数：移出字典中的项

(15)setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值

(16)update函数：用一个字典更新另外一个字典

(17) values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

一、字典的创建

1.1 直接创建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1.2 通过dict创建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的内容:'

printitems

printu'利用dict创建字典，输出字典内容:'

d=dict(items)

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的内容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict创建字典，输出字典内容:

{'four':4,'three':3,'two':2,'one':1}

查询字典中的内容:

或者通过关键字创建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'输出字典内容:'

printd

printu'查询字典中的内容:'

printd['one']

printd['three']

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

输出字典内容:

{'three':3,'two':2,'one':1}

查询字典中的内容:

二、字典的格式化字符串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

三、字典方法

3.1 clear函数：清除字典中的所有项

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

请看下面两个例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

3.1.2与3.1.1唯一不同的是在对字典d的清空处理上，3.1.1将d关联到一个新的空字典上，这种方式对字典dd是没有影响的，所以在字典d被置空后，字典dd里面的值仍旧没有变化。但是在3.1.2中clear方法清空字典d中的内容，clear是一个原地操作的方法，使得d中的内容全部被置空，这样dd所指向的空间也被置空。

3.2 copy函数：返回一个具有相同键值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X复制到Y：'

y=x.copy()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，观察输出：'

printy

printx

printu'删除Y中的值，观察输出'

y['test'].remove('c')

printy

printx

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X复制到Y：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，观察输出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

删除Y中的值，观察输出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

注：在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改。deepcopy函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题。

# _*_ coding:utf-8 _*_

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=x.copy()

z=deepcopy(x)

printu'输出：'

printy

printz

printu'修改后输出：'

x['test'].append('e')

printy

printz

运算输出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

输出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后输出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

3.3 fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

运算输出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

或者指定默认的对应值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

3.4 get函数：访问字典成员

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

注：get函数可以访问字典中不存在的键，当该键不存在是返回None

3.5 has_key函数：检查字典中是否含有给出的键

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

3.6 items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

printkey,':',value

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

print"d[%s]="%k,v

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

3.7 keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=d.keys()

printlist

printu'\niterkeys方法：'

it=d.iterkeys()

forxinit:

printx

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

3.8 pop函数：删除字典中对应的键

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

3.9 popitem函数：移出字典中的项

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

3.10 setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

运算结果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

3.11 update函数：用一个字典更新另外一个字典

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3

}

printd

x={'one':1}

d.update(x)

printd

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

3.12 values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3,

'test':2

}

printd.values()

运算结果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]

python（14）：函数(1)

==================================================

前面定义函数greet_user()时，要求给变量username指定一个值，调用这个函数并提供这种信息（人名）时，它将打印相应的问候语。

在函数greet_user()种，变量username是一个形参，函数完成其工作所需要的一项信息。在代码greet_user('da ming')中，值'da ming'是一个实参。实参时调用函数时传递给函数的信息。

在调用函数时，将要让函数使用的信息放在括号内，在greet_user('da ming')中，将实参'da ming'传递给函数greet_user()，这个值被存贮在形参username中。

鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。

向函数传递实参的方式有很多，可使用位置实参，这要求实参的顺序与形参的顺序相同；也可使用关键字实参，其中每个实参都由变量名和值组成；还可以使用列表和字典

Python字典创建、基本操作以及常用方法

创建一个空字典自需要一对大括号即可,从已有的键-值对映射或关键字参数创建字典需要使用 dict 函数（类）

把一个列表转为字典，列表的每一项都是长度为2的序列。

还可使用 关键字实参 （**kwargs）来调用这个函数，如下所示：

字典的基本操作与序列十分相似：

字典与序列的不同：

方法 clear 删除所有的字典项（key-value）。

复制，得到原字典的一个新副本。

效果等同于调用 dict(d) 创建新字典。

copy() 执行的是 浅复制 ，若字典的值是一个可变对象，那么复制以后，相同一个键将关联到同一个对象，修改该对象，将同时修改两个字典。

模块copy中的函数deepcopy 可执行深复制。

方法fromkeys 创建一个新字典，其中包含指定的键，且每个键对应的值都是None,或者可以提供一个i额默认值。

方法get 为访问字典项提供了宽松的环境。通常，如果你试图访问字典中没有的项，将引发错误,而get直接返回None,或者可设置默认返回值。

当字典中不存在指定键时， setdefault（k，v） 添加一个指定键-值对；且返回指定键所关联的值。

这三个方法返回值属于一种名为 字典视图 的特殊类型。字典视图可用于迭代。另外，还可确定其长度以及对其执行成员资格检查。

这三个方法自大的特点是不可变，当你的接口试图对其他用户提供一个只读字典，而不希望他们修改的时候，这三个方法是很有用的；而且当原字典发生改变时，这些方法返回的对象也会跟着改变。

方法 pop 可用于获取与指定键相关联的值，并将该键-值对从字典中删除。

popitem随机删除一个键-值对，并返回一个二维的元组 (key, value) ，因为字典是无序的，所以其弹出的顺序也是不确定的。

书上说，这个方法在大数据量时执行效率很高，但没有亲测。

方法update 使用一个字典中的项来更新另一个字典。

文章名称：关于Python函数实参字典的信息
标题网址：http://kswjz.com/article/hpcggd.html