包含两个位置参数的函数print_str
-
def print_str(first, second): -
print(first) -
print(second) -
if __name__ == "__main__": -
print_str("hello", "world")
如果只想传一个参数去调用print_str函数，执行print_str("hello")，此时会发生什么呢？
输出结果：
TypeError: print_str() takes exactly 2 arguments (1 given)TypeError：CPython明确告知print_str函数是需要两个参数的，而你只为print_str函数传了一个参数，如何修改print_str函数为既可以传一个参数、也可以传入两个参数去调用呢？
可传递一个参数、或者更多个参数的函数print_str
将print_str函数的最后一个参数修改为可变参数（备注：也可使用默认参数），此时再次调用：print_str("hello")，看看结果是什么？
-
def print_str(first, *second): -
print(first) -
print(second)
输出结果：
-
hello -
()
发现控制台输出的结果：传入的字符串"hello"打印出来了，没有传入参数的*second则打印的是一个tuple对象的字符串表示形式"()" (注意：（）代表0个元素的tuple对象）
再做一个实验，为print_str函数多传几个参数？这次传入四个参数……看看会发生什么？
print_str("hello","one","two","three")输出结果：
-
hello -
('one', 'two', 'three')
发现传入的第二个参数"one"，第三个参数“two”，第四个参数“three”全部成为可变参数组成的元组中的元素！
所有传入的参数，按照从左到右的顺序依次被使用，最左侧的参数先由位置参数（必选参数）去使用，剩余未使用的参数则是在方法的内部自动的被组装成为一个tuple对象！！！！！
调用print_str函数时直接传入一个 *参数会发生什么呢？
-
numbers_strings = ("1","2","3","4","5") -
def print_str(first, *second): -
print(first) -
print(second) -
if __name__ == "__main__": -
print_str(*numbers_strings) #注意这里的*numbers_strings -
输出结果： -
1 -
('2', '3', '4', '5')
此时print_str(*numbers_strings) 语句等同于 print_str("1","2","3","4","5")语句，这个*numbers_strings称为元组的解包功能（一个*字符后面紧挨着一个tuple对象），numbers_strings自身是一个tuple对象，所以它称为元组的解包
没有可变参数的函数，使用元组解包，会发生什么呢？
-
numbers_strings = ("1","2") -
def print_str(first, second): -
print first -
print second -
if __name__ == "__main__": -
print_str(*numbers_strings)
输出结果：
-
1 -
2
此时我们发现print_str(*numbers_string)语句等同于print_str("1","2")语句。元组解包的过程中会将每一个元素依次放入到位置参数上！
参数名称前有两个**，称作关键字参数，也称作字典参数
-
def printStr(**anything): -
print(anything) -
printStr(first = 5, second = 100)
{'second': 100, 'first': 5}关键字参数允许传入0个或多个包含参数名的参数,这些含有参数名的参数也被称作关键字参数，他们会在函数的内部自动组装为一个dict对象
函数调用时使用一个字典的解包（字典对象前面需加**，两个字符），它会把dictionary中每个的键值对元素，转换为一个一个的关键字参数传到函数中
-
def printStr(first, **dict): -
print(str(first) + "\n") -
print(dict) -
printDic = {"name": "tyson", "age":"99"} -
printStr(100, **printDic) -
#等同于 -
printStr(100, name = "tyson", age = "99")
总结
Python语法中，当*和**符号同时出现在函数定义的参数列表中时，说明参数列表可接受任意数量的参数，它们俩个统称为可变参数
*second表示任意个（包含0个）无名参数，又称为元组参数，当函数被调用时，传入的参数会在函数中自动组装成一个tuple对象后再使用（注意：就算你传递一个元素，也会在方法内部组装成一个tuple对象）
**anything表示任意个（包含0个）关键字参数，又称为字典参数，当函数被调用时，实际传入的参数会在函数内组装成一个dict对象
注意：二者同时存在，一定需要将*second放在**anything之前
注意：二者同时存在，一定需要将*second放在**anything之前
注意：二者同时存在，一定需要将*second放在**anything之前
（重要的事情说三遍）
注意事项
1、可变参数（元组参数或者字典参数），可以传0个参数，也可以传1个参数，还可以传多个参数
2、可变参数（元组参数或者字典参数），必须定义在普通参数（也称位置参数、也称必选参数）的后面
3、*参数必须定义在**参数的前面（元组参数与字典参数同时存在，元组参数一定需要在前）
-
def printStr(普通参数，*参数，**参数): -
pass
4、*参数，虽然称为元组参数，千万不要直接传入一个tuple对象进去（如果传进去一个tuple对象，那么这个tuple对象会作为在函数内组装的tuple对象中一个元素），tuple对象记得一定要使用元组解包语法，解包语法：*turple
5、**参数，虽然称作字典参数，不要传入一个字典对象进去（一个字典对象只能算一个参数，此时会报错，因为它不符合关键字参数的语法规范），字典记得也是要做解包，解包语法： **dict
-
def jsonify(*args, **kwargs): -
indent = None -
separators = (',', ':') -
if current_app.config['JSONIFY_PRETTYPRINT_REGULAR'] or current_app.debug: -
indent = 2 -
separators = (', ', ': ') -
if args and kwargs: -
raise TypeError('jsonify() behavior undefined when passed both args and kwargs') -
elif len(args) == 1: # single args are passed directly to dumps() -
data = args[0] #注意看这里：对于元组参数的使用 -
else: -
data = args or kwargs -
return current_app.response_class( -
dumps(data, indent=indent, separators=separators) + '\n', -
mimetype=current_app.config['JSONIFY_MIMETYPE'] -
)
===============================================================================================
阅读目录
可变参数
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。
在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。
定义函数为：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用：
print(calc(1,2)) #5 print(calc(1,2,3,4)) #30
把list或tuple的元素变成可变参数传进去：
nums = [1, 2, 3] nums_2 = (1, 2, 3, 4, 5) print(calc(*nums)) #14 print(calc(*nums_2)) #55
*nums表示把nums这个list的所有元素作为可变参数传进去。
关键字参数
关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数：
person('Michael', 30) #name: Michael age: 30 other: {}
也可以传入任意个数的关键字参数：
person('Bob', 35, city='Beijing') #name: Bob age: 35 other: {'city': 'Beijing'}
person('Adam', 45, gender='M', job='Engineer') #name: Adam age: 45 other: {'job': 'Engineer', 'gender': 'M'}
关键字参数可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。
也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra) #name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
命名关键字参数
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
调用方式如下：
person('Jack', 24, city='Beijing', job='Engineer') #Jack 24 Beijing Engineer
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名，如果没有传入参数名，调用将报错：
person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
File "E:/ru/231n/exer.py", line 4, in <module>
person('Jack', 24, 'Beijing', 'Engineer')
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'
由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。
命名关键字参数可以有缺省值，从而简化调用：
def person(name, age, *, city='Beijing', job):
print(name, age, city, job)
由于命名关键字参数city具有默认值，调用时，可不传入city参数：
person('Jack', 24, job='Engineer') #Jack 24 Beijing Engineer
使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：
def person(name, age, city, job):
# 缺少 *，city和job被视为位置参数
pass