NeVER GiVe uP for My DrEaMS,bECAusE No ONe KNoWs wHaT I Want better than me.
各种python 函数参数定义和解析
python 中的函数参数是赋值式的传递的，函数的使用中要注意两个方面:1.函数参数的定义过程，2.函数参数在调用过程中是如何解析的。首先说一下在python 中的函数调用过程是分四种方式的，这里且先说五种，。
1.参数枚举的函数定义：&&& def Fun(a,b,c):
return (a,b,c)
&&& Fun(1,2,3)
&&& Fun(1,2) # 枚举参数个数不对应
Traceback (most recent call last):
File "&pyshell#61&", line 1, in &module&
TypeError: Fun() takes exactly 3 arguments (2 given)
&&& def Fun(a,b,c):
print (a,b,c)
&&& Fun(a=22,b=33,c=44)
(22, 33, 44)
&&& Fun(22,33,44)&span style="white-space:pre"& &/span&# 不指定赋值对象，就是按照顺序匹配
(22, 33, 44)
&&& Fun(22,33,c=44)
&span style="white-space:pre"& &/span&# 可以指定参数的赋值对象，也可以不指定，
(22, 33, 44)
&&& Fun(b=22,a=33,c=44) # 参数顺序可以不对应
(33, 22, 44)
这是最常见的定义方式，一个函数可以枚举定义任意多的参数，每个参数之间使用逗号隔开，用这种方式定义的函数在调用的时候实参的个数和形参的个数必须相等，并且顺序是一一对应的，如果出现参数数量不对或者参数类型不对应就会报错。
2.带默认参数的函数定义（）:&&& def Fun(a,b,c=33):
print (a,b,c)
&&& Fun(11,22) # 可以不写默认参数
(11, 22, 33)
&&& Fun(1)
# 就是至少实参的个数和非默认参数的个数相同
Traceback (most recent call last):
File "&pyshell#66&", line 1, in &module&
TypeError: Fun() takes at least 2 arguments (1 given)
&&& Fun(1,2,3) &span style="white-space:pre"& &/span&# 可以覆盖默认参数
(1, 2, 3)这种方式就可以在调用的时候不填写默认参数了，但是要注意含有默认值的函数在定义的时候就已经把他的默认参数初始化了，这个在。
3.不确定参数个数的函数定义：&&& def Fun(*a):
if 0 == len(a):
print 'None'
&&& Fun(1,2,3)
# tuple 类型
&&& Fun(a=1,b=2,c=33)
# 不能在按照字典的方式赋值
Traceback (most recent call last):
File "&pyshell#93&", line 1, in &module&
Fun(a=1,b=2,c=33)
TypeError: Fun() got an unexpected keyword argument 'a'
&&& Fun() # 可以是0参数
None这种带*号的说明参数的个数是不确定的，在调用的时候想传多少个 参数都行[0,n]，呵呵，爽吧，但是他传入的参数都会放在一个
tuple中，如果有返回值的接受的时候也是用tuple行了，对于函数内部不确定的数量赋值时直接就循环迭代赋值就Ok了。
4.不确定个数的字典参数定义：
在定义的形参处加两个*,就是在函数内部处理函数的时候都是用字典的形式保存，当然调用的时候要用key=value的形式&&& def Fun(**a):
if 0 == len(a):
print 'None'
&&& Fun(1,2,3,4) # 字典赋值，这样就不行了
Traceback (most recent call last):
File "&pyshell#83&", line 1, in &module&
Fun(1,2,3,4)
TypeError: Fun() takes exactly 0 arguments (4 given)
&&& Fun(a=1,b=2,c=3) &span style="white-space:pre"&
&/span&# 必须key=value的赋值
{'a': 1, 'c': 3, 'b': 2}
&span style="white-space:pre"& &/span&# dict 类型
&&& Fun(aa=3,b=333,d=44)
{'aa': 3, 'b': 333, 'd': 44}
最后一个关于函数参数赋值优先级的例子：
&&& def Fun(a,b,c=22,*d,**e):
print a,b,c,d,e
&&& Fun(1)
Traceback (most recent call last):
File "&pyshell#98&", line 1, in &module&
TypeError: Fun() takes at least 2 arguments (1 given)
&&& Fun(1,2)
1 2 22 () {}
&&& Fun(1,2,3)
1 2 3 () {}
&&& Fun(1,2,3,4,5)
# 默认顺序匹配把多余的参数匹配给tuple
1 2 3 (4, 5) {}
&&& Fun(1,2,3,4,5,aa=33,bb=33)
# 把字典赋值匹配给dict
1 2 3 (4, 5) {'aa': 33, 'bb': 33}
&&& Fun(a=3,c=4,b=2b)
SyntaxError: invalid syntax
&&& Fun(a=3,c=4,b=22)
&span style="white-space:pre"& &/span& # 在字典赋值和枚举匹配赋值的时候优先考虑匹配赋值
3 22 4 () {}
&&& Fun(b=22,a=22,e=(1,2,3))
22 22 22 () {'e': (1, 2, 3)}
&&& Fun(b=22,c=77,2,3,4,5,6,)
# 没有给a 赋值,多一个逗号
SyntaxError: non-keyword arg after keyword arg
&&& Fun(b=22,c=77,2,3,4,5,6,k=44)
SyntaxError: non-keyword arg after keyword arg
&&& Fun(b=22,c=77,a=44,2,3,4,5,6,)
&&& Fun(1,2,3,(22,3334,34))
# 直接使用tuple的实参传递&br style="font-family: 'Microsoft YaHei';font-size:14" /&&span style="font-family: 'Microsoft YaHei';font-size:14"&1 2 3 ((22, 3334, 34),) {}&/span&&br style="font-family: 'Microsoft YaHei';font-size:14" /&
可以看出这里函数参数的赋值方式是有所差别的，按照 1 ，2，3，4的优先级依次降低，也就是先为枚举形参赋值，再为默认参数赋值，然后多出来的就都组装在在tuple中传过去，给带*的参数，最后把key=value的形式组装成字典的形式传进去，给**的参数
5.修饰器的函数调用方式（不是函数的定义方式，只是一种函数调用约定）：
人个论坛：
没有更多推荐了，Python程序的错误：变量未定义
Python程序的错误种类
Python程序的错误分两种。一种是语法错误（syntax error）。这种错误是语句的书写不符合Python语言的语法规定。第二种是逻辑错误（logic error）。这种错误是指程序能运行，但功能不符合期望，比如“算错了”的情形。
变量未定义的错误
Python程序中，变量需要先定义后使用。如果没有这样做，就会出现变量未定义错误。这属于语法错误。Pycharm中，语法错误会用红色的波浪线标出来，如图1所示。
Pycharm中，语法错误会用红色的波浪线标出来
Python程序运行的错误信息
Pycharm中，程序运行出错了，会在运行窗口（即输入数据或输出结果的窗口）中报告错误信息。强行运行图1的例子，将呈现图2所示的错误信息。
下方的运行窗口中报告了错误信息
错误信息中，显示列出了程序的运行轨迹（Traceback）。这里，运行轨迹不长，以后会遇到很长的情形。运行轨迹只有一条，指出文件2-2-5-varError.py中的第3行（line 3），内容是“print(mesage) #mesage的拼写错了，漏了一个s”，存在错误。文件路径用蓝色字体程序，说明它是一个超链接，点击它，上面编辑器就列出该行代码及其附近的代码。
错误信息的最后，给出了错误的结论，NameError: name ‘mesage’ is not defined. 译成中文就是，名字错误：变量名‘mesage’未定义。
要学会分析Python程序的错误信息。尽管它是英文的，你读多了就会抓住要领。利用错误信息，能更快的定位错误和纠正错误。
没有更多推荐了，陌上发花，可以缓缓醉矣， 忍把浮名，换了浅斟低唱。
Python 3语法小记（八）类class
Python 3 中只有新式类，没有旧式类，不需要显示的指定，你定义的类都是新式类如果你不知道新式类和旧式类的区别，那么，也不用知道了
&&& class Nothing:
#定义方法和属性
类里面用 def 定义方法，它不叫函数，因为每一个方法的第一个参数都是 self，但在调用时我们不必提供，程序会自动将第一个参数绑定到所属的实例上
&&& class Hello:
def greet(self,name):
print ("Hello,"+name)
&&& me = Hello() #要加（）不然，不是实例
&&& me.greet('Cheng') #只需第一个参数
Hello,Cheng
Python 中默认情况下的方法和特性都是公有的，如果你想变为私有的，那么要在方法和特性的名字前加上双下划线 __
&&& class Some:
name = "Jane"
&&& she = Some()
&&& she.name #这里可以访问
&&& class Some:
__name = "Jane"
&&& she = Some()
&&& she.name
#这里不可以
Traceback (most recent call last):
File "&pyshell#48&", line 1, in &module&
AttributeError: 'Some' object has no attribute 'name'
&&& she._Some__name #通过 _类名__方法或特性名，我们又可以访问它
&&& class C:
def __test(self):
print('in C...')
def call(self):
self.__test() #类内访问私有方法和特性
&&& c = C()
&&& c.call()
所以，你不可能完全限制其他人无法访问到你的类中方法和特性，所以，Python 并不能实现完全的封装
将其他类名写在class语句后的圆括号内就表示继承于某类
class 类名(基类名)
&&& class A:
def printA(self):
print("in A...")
&&& class B(A):
def printB(self):
print('in B...')
&&& issubclass(A,B) #A不是B的子类
&&& issubclass(B,A) #B是A的子类
&&& B.__bases__
(&class '__main__.A'&,)
&&& b = B()
&&& isinstance(b,B)
#询问b是否是B的实例
&&& b.printA() #访问A中的方法
多继承的方法很容易，把几个类名写在一起就行了
class 类名(基类名1，基类名2，基类名3)
子类中同名的方法会覆盖基类的方法，方法的调用跟继承的顺序有关，即方法在子类中未找到时，从左到右查找父类中是否包含方法
看下面的例子：
&&& class A:
def test(self):
print("in A...")
&&& class B(A):
def test(self):
print('in B...')
&&& class C(A):
def test(self):
print('in C...')
&&& class D(B,C):
def test(self):
print('in D...')
&&& d = D()
&&& d.test() #如果子类拥有该方法，那直接调用该方法
&&& class D(B,C): #重定义类D
&&& d = D()
&&& d.test() #B先继承，在B中首先找到该方法，调用B的方法
&&& class D(C,B): #再次重定义，改变了继承顺序
&&& d = D()
&&& d.test() #这次调用了C的方法
当然，如果D、B、C都没有该方法，而A有，那么自然是调用A的方法
&&& hasattr(d,'test') #对象d是否有test方法
&&& hasattr(d,'next') #对象d是否有next方法
&&& hasattr(d.test,'__call__') #询问d的test方法是否可调用
Python类的“构造函数” __init()__
将类实例化时,会创建一个空的类实例,一般的 Python 类的定义中会有一个特殊的方法来初始化,这个方法就是__init__(),当调用了类的实例化方法后,__init__()方法会立刻被这个类的实例调用。所以,__init__()不是构造函数,而是一个普通的方法.
&&& class A:
count = 0;
def __init__(self):
A.count += 1
#每次调用该方法 count 自增 1
def output(self):
print(self.count)
&&& a1 = A()
&&& a1.output()
&&& a2 = A()
&&& a2.output()
&&& class A:
def __init__(self,name):
self.name = name
&&& a = A('Jane')
Python 还有一个类似于“析构函数”的方法 __del__，但不建议使用，Python 的内存管理是用引用计数的，但引用数为0时销毁对象，但你很难确定什么时候 Python 会调用 del 方法，所以避免莫名其妙的错误的最好方法是不要使用它，将所有你要del做的事情写在一个主动调用的方法，然后自己进行管理
再说说Python的类属性和实例属性
类属性是属于一个类的变量，就像是C++中类的静态成员变量，你只需将该属性定义在所有方法的作用域外，即为类属性，但一般是紧跟在类名后面，类属性为所有实例所共有，你可以通过 类名.属性 来调用类属性&&& class A:
count = 0; #这就是类属性
def __init__(self):
A.count += 1
#每次调用该方法 count 自增 1
def output(self):
print(self.count)
&&& a1 = A()
&&& a1.output()
&&& A.count = 0
&&& A.count
&&& a1.output()
实例属性是属于实例自己的属性，你可以在任何方法中添加新的实例属性，甚至在类外添加，Python会在实例属性初次使用时，创建该属性并赋值
&&& class A:
def __init__(self):
self.num = 1
#添加实例属性num
def again(self,name):
self.name = name #添加实例属性name
&&& a1 = A()
&&& a1.num
&&& a1.name #这时实例 a1 中还没有实例属性 name
Traceback (most recent call last):
File "&pyshell#38&", line 1, in &module&
a1.name #这时实例 a1 中还没有实例属性 name
AttributeError: 'A' object has no attribute 'name'
&&& a1.again('Jane')
&&& a1.name #现在有了...
&&& a1.call = '123456' #添加a1的实例属性 call
&&& a1.call
继续看下面的例子：
&&& class A:
def __init__(self):
A.count += 1
def output(self):
print(self.count)
&&& a1 = A()
&&& a2 = A()
&&& a3 = A()
&&& A.count # A的类属性count这时为3
&&& A.count = 2 #更改A的类属性为2
&&& a1.count,a2.count, a3.count, A.count #A的所有实例的count也同样改变
(2, 2, 2, 2)
&&& a1.count = 5 #通过A的一个实例a1更改count
&&& a1.count, a2.count, a3.count, A.count #只有a1的count发生改变
(5, 2, 2, 2)
&&& A.count = 4 #再次更改A的类属性为4
&&& a1.count, a2.count, a3.count, A.count
#这时a1的count还是保持为5
(5, 4, 4, 4)
通过上面的例子我们可以看到，类属性为所有实例和类所共有，通过 类名.类属性 可以更改类属性，并且所有实例的类属性也随之改变，但通过 实例名.类属性 来改变类属性，该实例的该类属性会变为实例属性，而不影响其他实例的类属性，以后通过 类名.类属性 来更改类属性，也不会影响到该实例的这个属性了，因为它变为实例属性啦。（好吧，我承认有点晕o(╯□╰)o）
没有更多推荐了，在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
创建了两个类，其中 Human 是 Person 的元类，想要在实例化 Person 时，通过元类 Human 将 name 和 age 属性改为 NAME、AGE，但是没有成功，不知道哪里出错了，请大神看看：
class Human(type):
def __new__(cls, name, bases, dct):
attrs = ((name, value) for name, value in dct.items() if not name.startswith('__'))
uppercase_attr = dict((name.upper(), value) for name, value in attrs)
return super(Human, cls).__new__(cls, name, bases, uppercase_attr)
class Person():
__metaclass__ = Human
country = ''
"""Person class."""
def __init__(self, name, age):
self.name = name
self.age = age
def intro(self):
"""Return an introduction."""
return "Hello, my name is %s and I'm %s." % (self.name, self.age)
运行如下：
In [23]: a = Person('dobi', 2)
In [24]: a.__dict__
Out[24]: {'age': 2, 'name': 'dobi'}
In [25]: Person.__dict__
Out[25]: mappingproxy({'country': 'gg', '__init__': &function Person.__init__ at 0xBD9C80&, '__module__': '__main__', '__doc__': None, '__metaclass__': &class '__main__.Human'&, '__dict__': &attribute '__dict__' of 'Person' objects&, '__weakref__': &attribute '__weakref__' of 'Person' objects&})
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
你这样写，只对类属性有效
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
总结一下（ps:如果这段看起来有点费劲，可以直接跳过看示例）：
元类就是类的类，它的实例是类；
type() 并非函数，而是所有类的元类（至于为什么 type 要小写见，而 type 和 object 的关系，见“”）；
type() 既可以用于返回对象类型如：type(int)，也可以用于类的创建如 ：type(myList，List，{ })，事实上所有类的创建最终都是调用 type() 实现；
类创建时，python 首先会检测该类是否指定了元类，如果没有指定，则会去检测父类是否指定了元类…都没有找到则会检测该模块是否指定了元类，直至找到指定的元类，然后依据元类的定义创建并初始化该类（!!! 注意是创建的是该类，而不是该类的实例），不管元类如何定义，元类最终都会将自身以及其他指定的参数直接或间接的传递给 type() 创建该类 ；如果 python 最终未能找到指定的元类，便会将指定的参数直接传递给 type() 创建该类。
元类作为类的直接创建者，可以在类创建时拦截该类本身的创建程序，并可根据元类的意图创建并返回被修改后的类，因此，所有该类的实例都是被元类修改过的类的实例。这也是元类在应用中最大的价值！
Python 是动态语言，因此类只在该类作用域被创建时才会被创建，而元类则只会在该类被创建时才能做出响应，因此元类不会影响类的实例属性（因为实例属性只有在类实例创建时才会产生），元类也只能修改类的类属性，而不能修改该类的实例属性，但元类对类属性的修改，会影响到该类所有实例的属性，因为所有实例都是被修改过的类的实例。
事实上，被指定元类的类，其内定义的 new 和 init 是毫无意义的，因为该类不仅是通过元类创建的，也是通过元类实现初始化的。
class Human(type):
def __new__(cls, name, bases, dct):
attrs = ((name, value) for name, value in dct.items() if not name.startswith('__'))
uppercase_attr = dict((name.upper(), value) for name, value in attrs)
return super(Human, cls).__new__(cls, name, bases, uppercase_attr)
class Person(metaclass = Human):
country = ''
"""Person class."""
def __init__(self, name, age):
self.name = name
self.age = age
def intro(self): #这里的 self 不要忘记，否则类实例无法调用
"""Return an introduction."""
print('who am I?')
上例中，Person 指定 Human 为其元类，一旦 Person 所在的作用域被执行，Human 会将创建 Person 类，并将 Person 类中所有非"__"开头的类属性标识符全部变为大写，并返回被修改后的 Person，当我们运行这段代码后：
runfile('C:/Users/xu_zh/.spyder2-py3/temp.py', wdir='C:/Users/...')
Person.country
Traceback (most recent call last):
File "&ipython-input-63-fc010f0a9d88&", line 1, in &module&
Person.country
AttributeError: type object 'Person' has no attribute 'country'
Person.COUNTRY
Out[64]: ''
Person.INTRO
Out[65]: &function __main__.Person.intro&
Person 类中定义的 country 属性根本不存在，只存在被元类修改过的 COUNTRY，INTRO 方法也是如此，另外，我们再调用 init 方法看看：
Person.__init__
Out[66]: &slot wrapper '__init__' of 'object' objects&
可以发现完成 Person 类初始化的是 object 的 init 而非 Person 本身的 init，原因在于 Person 类是通过元类 Human 创建的，而 Human 并未定义 init 而是默认继承 object 的 init,因此 Person 类的创建就由 object 的 init 完成，如果此时我们按照 Person 本身的定义实例化一个 Person 对象，就会出现：
dobi = Person('dobi', 2)
Traceback (most recent call last):
File "&ipython-input-67-6bb1c8d0ad4d&", line 1, in &module&
dobi = Person('dobi', 2)
TypeError: object() takes no parameters
类型错误提示：object 对象无参数….这样印证了 Person 类初始化程序是调用 object 对象的初始化程序实现的，那么 Person 类中定义的 name 和 age 等实例属性就是毫无意义的，它根本不可能存在于实例中：
['COUNTRY',
'__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__format__',
'__getattribute__',
'__hash__',
'__init__',
'__module__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__']
dobi.INTRO()
Out[69]: who am I?
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。Python——函数参数类型以及用法Python——函数参数类型以及用法五佳科技百家号之前我们讲了Python的函数概念以及参数的基本用法，今天具体讲一下函数的参数类型用法。函数的参数def hs(a1,a2,a3,...):****statements其中a1,a2,a3是函数的参数，函数的参数类型可分为：必须参数、默认参数、可变参数（不定长参数）、关键字参数、组合参数，总共5种。必须参数其实我们之前举得例子就是必须参数，以下例子必须参数：def hello(str):****print('必须参数是：',str)hello('hello,world')我们可以看到在函数hello中，str作为一个参数，是形参，这形参个类型取决于你调用时输入的实参类型，我们这里调用函数hello时，传入了一个字符串'hello,world'，那么这个实参的类型就是字符串，所以形参str的类型也是字符串，所以当我们调用函数hello时传入‘hello,world’，就会执行函数里面的print语句，在屏幕上显示出如图所示：必须参数值得注意的是，我们在定义函数时形参数量只有一个，因此在调用函数时传入实参也必须是一个！如果传入的实参数量多余形参数量会出现错误，如图所示：传入实参数量多余形参数量会报错第二个注意的是，当传入实参数量少于形参数量时也会报错！形参有一个参数，调用函数时不传入参数，如图：实参适数量少于形参数量2.默认参数默认参数就是定义函数时，形参给定一个值。def hs(name,age=23):****print('我叫：',name)****print('我今年',age)hs('王二',23)默认参数例子从以上例子可以看，以上函数用了两个形参，调用函数时输入了两个实参，我们可以试一下省略实参23，看能不能得到结果，请看图：省略实参23得到结果我们可以发现，我们省略实参23后，仍然能得到有实参23时的结果，这是因为我们定义函数时，形参中已经赋了一个值，当我们调用函数时，如果没有给默认形参一个值作为实参，那么就会调用默认形参的值作为实参，因此会得到默认的值；如果我们在调用函数时输入了一个非默认形参值，这时候默认形参的值会发生变化，变为输入的那个值！如图所示：改变默认参数的值要注意的是，我们调用函数时也可以输入‘参数名=值’ 这样的形式，如图所示：参数名=值重点来了：当存在默认参数和必须参数两种以上参数时，调用函数时一定要注意：a : 调用函数时，实参的形式为都带参数名，如上图形式b : 一个参数带参数名，另一个参数不带参数名，其中默认参数必须带参数名c : 如果形参中默认参数在必须参数之前，那么调用函数时实参中默认参数也应当在前面；如果形参中默认参数在必须参 数之后，那么调用函数时实参中默认函数应当在后面，否则会报错。形参中默认参数在后，实参中默认参数在后形参中默认参数在前，实参中默认参数在后导致报错3.可变参数（不定长参数）我们用一个例子来说明可变参数：def change(age,*som):****print(age)****for i in som:********print(i)****returnchange('name','year','mon','yue')不定长参数我们可以看到，在形参中我们定义了两个参数，为什么实参中输入了4个参数还是正确的呢？这就是可变参数带来的好处！代码中实参name传给了形参age，而其余三个传给了*som，可以说som相当于一个无限大的容器，可以容纳很多个参数。4.关键字参数其实默认参数中已经出现了关键字参数！关键字参数就是在调用函数时，传入实参时带参数名，用这样的方式传入的实参叫做关键字参数。在这里，我们重点讲一下调用函数时传入关键字参数的几种方法。看一个例子：定义一个字典：dir={'name':'miss','age':'18'}def Deaf(school,banji,**other):****print('学校：','班级：','学生信息：',other)****Deaf('清华','大二',**dir)关键字参数实例1上面例子我们可以看出，调用函数时实参除了‘清华’、‘大二’这两个必须参数外，还有‘ **dir ’这个关键字参数。我们再看一个例子：关键字参数实例2从上面这个例子中我们发现，当形参中有不定长参数 *other，调用函数时用 *dir会发现结果是只有字典中键名，没有值！我们再看一个例子：关键字参数实例3上面这个例子中，形参有不定长参数 *other ，调用函数时用 dir 但其结果是 将字典 以元组的形式输出，既在字典外面加括号。5.组合参数组合参数就是将之前讲过的4中参数同时引入函数作为形参，值得注意的是，定义参数时的顺序必须为：必须参数、关键字参数、默认参数、不定长参数。举一个例子：xx={'name':'xiaozhi','age':'18','interesting':'basketbal'}tu=(1,2,3,4,5,6)zd={'m':26,'n':25}def hs(a1,a2,a3=10,*a4,**cs):****print('a1=',a1,'a2=',a2,'a3=',a3,'a4a=',a4,cs)hs(1,2,3,4,5,6,7,m=26,n=25,**xx)hs(*tu,**zd)不定长参数在第一次调用函数时，1、2分别给a1,a2，形参a3=10，但是传入实参为3，改变了原来的值，因此a3=3，*a4 是不定长参数，因此4、5、6、7给*a4，因此a4a是多个值，以元组的形式输出，**cs为关键字参数，所以m、n以及**xx 的值给**cs，以字典形式输出。在第二次调用函数时，tu为一个元组，调用时用*tu方法，因此a1=1，a2=2，a3=3，a4a=(4,5,6)；用**zd调用时以字典形式输出。作者帅照工作日常今天函数的参数就讲完了，喜欢的可以点一波关注，明天继续函数作用域以及匿名函数。本文由百家号作者上传并发布，百家号仅提供信息发布平台。文章仅代表作者个人观点，不代表百度立场。未经作者许可，不得转载。五佳科技百家号最近更新：简介:喜欢拆机，喜欢数码科技，并非专业作者最新文章相关文章