函数python参数带 python 带参数

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的函数参数总结

import math

a = abs

print(a(-1))

n1 = 255

print(str(hex(n1)))

def my_abs(x):

# 增加了参数的检查

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x = 0:

return x

else:

return -x

print(my_abs(-3))

def nop():

pass

if n1 = 255:

pass

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)

tup = move(100, 100, 60, math.pi / 6)

print(tup)

print(isinstance(tup, tuple))

def quadratic(a, b, c):

k = b * b - 4 * a * c

# print(k)

# print(math.sqrt(k))

if k 0:

print('This is no result!')

return None

elif k == 0:

x1 = -(b / 2 * a)

x2 = x1

return x1, x2

else:

x1 = (-b + math.sqrt(k)) / (2 * a)

x2 = (-b - math.sqrt(k)) / (2 * a)

return x1, x2

print(quadratic(2, 3, 1))

def power(x, n=2):

s = 1

while n 0:

n = n - 1

s = s * x

return s

print(power(2))

print(power(2, 3))

def enroll(name, gender, age=8, city='BeiJing'):

print('name:', name)

print('gender:', gender)

print('age:', age)

print('city:', city)

enroll('elder', 'F')

enroll('android', 'B', 9)

enroll('pythone', '6', city='AnShan')

def add_end(L=[]):

L.append('end')

return L

print(add_end())

print(add_end())

print(add_end())

def add_end_none(L=None):

if L is None:

L = []

L.append('END')

return L

print(add_end_none())

print(add_end_none())

print(add_end_none())

def calc(*nums):

sum = 0

for n in nums:

sum = sum + n * n

return sum

print(calc(1, 2, 3))

print(calc())

l = [1, 2, 3, 4]

print(calc(*l))

def foo(x, y):

print('x is %s' % x)

print('y is %s' % y)

foo(1, 2)

foo(y=1, x=2)

def person(name, age, **kv):

print('name:', name, 'age:', age, 'other:', kv)

person('Elder', '8')

person('Android', '9', city='BeiJing', Edu='人民大学')

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

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

def person2(name, age, *, city, job):

print(name, age, city, job)

person2('Pthon', 8, city='BeiJing', job='Android Engineer')

def person3(name, age, *other, city='BeiJing', job='Android Engineer'):

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

person3('Php', 18, 'test', 1, 2, 3)

person3('Php2', 28, 'test', 1, 2, 3, city='ShangHai', job='Pyhton Engineer')

def test2(a, b, c=0, *args, key=None, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'key=', key, 'kw =', kw)

test2(1, 2, 3, 'a', 'b', 'c', key='key', other='extra')

args = (1, 2, 3, 4)

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

test2(*args, **kw)

python函数调用的参数传递

python的函数参数传递是"引用传递（地址传递）"。

python中赋值语句的过程（x = 1）：先申请一段内存分配给一个整型对象来存储数据1，然后让变量x去指向这个对象，实际上就是指向这段内存（这里有点和C语言中的指针类似）。

在Python中，会为每个层次生成一个符号表，里层能调用外层中的变量，而外层不能调用里层中的变量，并且当外层和里层有同名变量时，外层变量会被里层变量屏蔽掉。函数  调用  会为函数局部变量生成一个新的符号表。

局部变量：作用于该函数内部，一旦函数执行完成，该变量就被回收。

全局变量：它是在函数外部定义的，作用域是整个文件。全局变量可以直接在函数里面应用，但是如果要在函数内部改变全局变量，必须使用global关键字进行声明。

注意 ：默认值在函数  定义  作用域被解析

在定义函数时，就已经执行力它的局部变量

python中不可变类型是共享内存地址的：把相同的两个不可变类型数据赋给两个不同变量a，b，a，b在内存中的地址是一样的。

python中函数参数带 ' ：'？

def __init__(self, root: TreeNode):

等效于

def __init__(self, root):

: TreeNode只是对root参数的说明。

python 是弱类型语言，解释器不会对root传入的数据类型做限制，但你的这个类，是希望创建实例，传入的是TreeNode类对象，所以通过这种方式来提醒引用者。

python 函数参数带*是啥意思

*代表的是参数个数不确定的情况；

带一个星号（*）参数的函数传人的参数存储为一个元组（tuple）；

而带两个星号（*）参数的函数传人的参数则存储为一个字典（dict）；

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

python函数中参数带有一个星号

*代表的是参数个数不确定的情况；带一个星号（*）参数的函数传人的参数存储为一个元组（tuple）；而带两个星号（*）参数的函数传人的参数则存储为一个字典（dict）；由于传入的参数个数不定，所以当与普通参数一同使用时，必须把带星号的参数放在最后。