python函数基础与python函数的参数细节！

编程梦工厂 2018-11-10 13:52:06

函数基础（私信小编007即可自动获取大量python视频教程以及各类PDF！）

函数简介

• 定义：就是具有特定功能的一段代码
• 优点：
• 解决代码的重复书写
• 可以将功能的实现着和使用者分开，提高开发效率
• 分类：
• 库函数：print、input、abs等
• 自定义：用户自己封装的函数

函数使用

• 定义函数格式

def 函数名([参数列表]):
 函数体

• []表示可选，参数可以有，也可以没有，也可以是多个。
• 函数名：
• 与变量一样，只要遵循标识符的命名规范即可。
• 函数调用：
• 函数定以后不会执行，需要调用才会执行
• 调用格式： 函数名([参数])

函数分类(参数与返回值)

# 无参无返回值
def print_hello():
 for i in range(10):
 print('Hello world!')
​
# print_hello()
# 带参数无返回值
def print_n_hello(n):
 for i in range(n):
 print('Hello world!') 
 
# print_n_hello(5)
​
# 带参有返回值
def add(m, n):
 c = m + n
 # 使用return返回需要返回的值，不返回默认为None
 return c 
​
print(add(3, 5))

分类的标准是按照有无参数，以及有无返回值。

函数参数

• 形参：形式参数，就是写在函数定义出的参数
• 实参：实际参数，就是在函数调用时传递的参数
• 位置参数：也叫必传参数，没有默认值的参数
• 默认参数：定义时有默认值，调用时可以不传，必须写在最后
• 关键字参数：在函数调用时指定参数名字，参数的位置就无所谓。
• 可变长度参数：函数调用时可以传递比定义处更多的参数，多出来的参数会保存在args和kwargs中

def var_len_args(a, b, name='goudan', *args, **kwargs):
 print(a, b)
 print(name)
 # 是一个元组，保存多传的位置参数
 print(args)
 # 是一个字典，保存多传的关键字参数
 print(kwargs)
​
var_len_args(1, 2, 3, 4, age=10)

• *的使用：

def show(a, b):
 print(a, b)
​
lt = [1, 2]
# 需要从列表根据下表获取元素，然后作为参数传递
# show(lt[0], lt[1])
show(*lt)
​
def show2(aa=11, bb=22):
 print(aa, bb)
 
d = {'aa': 123, 'bb': 456}
# show2(aa=d['aa'], bb=d['bb'])
# 上下等价
show2(**d)

函数进阶

• 函数的定义位置是随意的？
• 不是，一定是先定义后调用，函数的调用一定要放在定义之后。
• 函数的名字可以相同吗？
• 不可以，若出现同名函数，后者会覆盖前者。
• 函数内容能否再定义函数？
• 可以，定义在函数内部的函数叫内部函数，它是很多高级功能实现的基础。

变量的作用域

• 块级作用域

if True:
 name = 'ergou'
​
# 能够在块的外部使用，说明没有块级作用域
print(name)

• 局部作用域
• 局部变量：定义在函数内部的变量叫局部变量，只能在函数内部使用。

def test():
 a = 10
​
# 不能再函数外部使用，此处会报错
print(a)

• 全局作用域
• 全局变量：定义在函数外部的变量叫全局变量，哪里都可以使用

num = 10
​
def show():
 # 声明使用的时外部的同名变量
 global num
 # 只能使用，不能修改，若想修改协议进行全局声明
 num = 20
 print(num)
​
show()
print(num)

1. 函数内部可以使用外部变量，但是不能修改
2. 若修改需要使用 global 进行全局声明
3. 当函数内部与外部出现同名变量，默认使用的时内部变量

• nonlocal使用
• 说明：内部函数使用外部函数的局部变量，需要使用nonlocal进行声明

def wai():
 n = 10
 def nei():
 # 声明使用非本地变量，外部函数的局部变量
 nonlocal n
 n = 20
 print(n)
 nei()
 print(n)
​
wai()

递归函数(了解)

• 定义：函数内部调用函数本身的函数叫递归函数。
• 组成：
• 函数内部调用自己
• 终止条件(停止调用自己的条件)
• 核心算法(具体功能)
• 特点：
• 代码简洁
• 可读性差(不易理解)
• 瞬间占用内存较大，没有终止条件立即崩溃
• 有些领域是禁止使用的(安全领域：汽车电子)
• 只有在不得不使用的时候才使用(遍历目录)
• 练习：
• 求n的阶乘
• 斐波那契数列的第n项
• 前两项都为1，从第三项开始，每一项都等于前两项的和
• 如： 1,1,2,3,5,8,13,21,...

常用函数

• 内置函数(无需导入)

print：打印，输出
input：输入
abs：求绝对值
type：获取变量的类型
chr：将ASCII数值转换为字符
ord：将字符转换为对应的ASCII
id：获取变量地址
len：统计元素个数
range：产生连续整数的可迭代对象
enumerate：枚举可迭代对象
​
强制类型转换：
int
float
str
list
tuple
set
dict
​
max：求多个参数的最大值，或可迭代对象中的最大元素
min：最小值
sum：求和，可迭代对象元素求和
pow：求幂，pow(2, 3)等价于2 ** 3
round：四舍五入，可以指定保留位数
​
hex：16进制
oct：8进制
bin：2进制

• 模块函数(需要导入)

time：
 sleep：休眠指定的秒数，可以是小数
math：
 e：自然对数
 pi：圆周率
 ceil：向上取整
 floor：向下取整
 sqrt：开方(请平方根)
 degrees：弧度转换为度
 radians：度转换为弧度
sys：
 argv：运行程序时所有的命令行参数列表，第一个是程序文件名
 练习：完成一个计算器，支持加、减、乘、除运算

练习：

• 前面练习全部以函数形式进行封装
• 终端计算器
• 删除列表中的重复元素
• 统计一个字符串中字母、数字及其他字符的个数，返回一个元组即可
• 返回一个列表中第二大的数
• 完整列表的排序函数(sort)，支持逆序
• 号码归属地查询：

'''5582|1860101|010|北京市|北京联通GSM卡
5583|1860100|010|北京市|北京联通GSM卡
5584|1368141|010|北京市|北京移动神州行卡
5585|1860111|010|北京市|北京联通GSM卡
5586|1358198|010|北京市|北京移动动感地带卡
5587|1361139|010|北京市|北京移动预付费卡
5588|1361138|010|北京市|北京移动神州行卡
5591|1360110|010|北京市|北京移动全球通卡
5748|1364110|010|北京市|北京移动神州行卡
10186|1581584|020|广东省广州市|广东移动全球通卡
15046|1391897|021|上海市|上海移动全球通卡
17250|1502207|022|天津市|天津移动全球通卡
21137|1345272|023|重庆市万州|重庆移动大众卡
22700|1347812|024|辽宁省沈阳市|辽宁移动大众卡
24256|1377065|025|江苏省南京市|江苏移动全球通卡
26360|1898606|027|湖北省武汉市|湖北电信CDMA卡
28709|1860802|028|四川省成都市|四川联通GSM卡
30641|1552961|029|陕西省西安市|陕西联通GSM卡
31700|1563007|0310|河北省邯郸市|河北联通GSM卡
33360|1583396|0311|河北省石家庄市|河北移动全球通卡
34825|1508122|0312|河北省保定市|河北移动全球通卡
35363|1551235|0313|河北省张家口|河北联通GSM卡
37700|1331326|0316|河北省廊坊市|河北电信CDMA卡
43500|1350358|0358|山西省吕梁市|山西移动全球通卡
43908|1553625|0359|山西省运城市|山西联通GSM卡
44521|1335360|0370|河南省商丘市|河南电信CDMA卡
50078|1509369|0378|河南省开封市|河南移动全球通卡
53603|1583981|0398|河南省三门峡|河南移动全球通卡
53916|1335897|0410|辽宁省铁岭市|辽宁电信CDMA卡
55248|1554254|0411|辽宁省大连市|辽宁联通GSM卡
58618|1374272|0427|辽宁省盘锦市|辽宁移动全球通卡
58932|1554183|0429|辽宁省葫芦岛|辽宁联通GSM卡
60268|1340475|0431|吉林省长春市|吉林移动大众卡'''
​

函数基础

函数简介

• 定义：就是具有特定功能的一段代码
• 优点：
• 解决代码的重复书写
• 可以将功能的实现着和使用者分开，提高开发效率
• 分类：
• 库函数：print、input、abs等
• 自定义：用户自己封装的函数

函数使用

• 定义函数格式

def 函数名([参数列表]):
 函数体

• []表示可选，参数可以有，也可以没有，也可以是多个。
• 函数名：
• 与变量一样，只要遵循标识符的命名规范即可。
• 函数调用：
• 函数定以后不会执行，需要调用才会执行
• 调用格式： 函数名([参数])

函数分类(参数与返回值)

# 无参无返回值
def print_hello():
 for i in range(10):
 print('Hello world!')
​
# print_hello()
# 带参数无返回值
def print_n_hello(n):
 for i in range(n):
 print('Hello world!') 
 
# print_n_hello(5)
​
# 带参有返回值
def add(m, n):
 c = m + n
 # 使用return返回需要返回的值，不返回默认为None
 return c 
​
print(add(3, 5))

分类的标准是按照有无参数，以及有无返回值。

函数参数

• 形参：形式参数，就是写在函数定义出的参数
• 实参：实际参数，就是在函数调用时传递的参数
• 位置参数：也叫必传参数，没有默认值的参数
• 默认参数：定义时有默认值，调用时可以不传，必须写在最后
• 关键字参数：在函数调用时指定参数名字，参数的位置就无所谓。
• 可变长度参数：函数调用时可以传递比定义处更多的参数，多出来的参数会保存在args和kwargs中

def var_len_args(a, b, name='goudan', *args, **kwargs):
 print(a, b)
 print(name)
 # 是一个元组，保存多传的位置参数
 print(args)
 # 是一个字典，保存多传的关键字参数
 print(kwargs)
​
var_len_args(1, 2, 3, 4, age=10)

• *的使用：

def show(a, b):
 print(a, b)
​
lt = [1, 2]
# 需要从列表根据下表获取元素，然后作为参数传递
# show(lt[0], lt[1])
show(*lt)
​
def show2(aa=11, bb=22):
 print(aa, bb)
 
d = {'aa': 123, 'bb': 456}
# show2(aa=d['aa'], bb=d['bb'])
# 上下等价
show2(**d)

函数进阶

• 函数的定义位置是随意的？
• 不是，一定是先定义后调用，函数的调用一定要放在定义之后。
• 函数的名字可以相同吗？
• 不可以，若出现同名函数，后者会覆盖前者。
• 函数内容能否再定义函数？
• 可以，定义在函数内部的函数叫内部函数，它是很多高级功能实现的基础。

变量的作用域

• 块级作用域

if True:
 name = 'ergou'
​
# 能够在块的外部使用，说明没有块级作用域
print(name)

• 局部作用域
• 局部变量：定义在函数内部的变量叫局部变量，只能在函数内部使用。

def test():
 a = 10
​
# 不能再函数外部使用，此处会报错
print(a)

• 全局作用域
• 全局变量：定义在函数外部的变量叫全局变量，哪里都可以使用

num = 10
​
def show():
 # 声明使用的时外部的同名变量
 global num
 # 只能使用，不能修改，若想修改协议进行全局声明
 num = 20
 print(num)
​
show()
print(num)

1. 函数内部可以使用外部变量，但是不能修改
2. 若修改需要使用 global 进行全局声明
3. 当函数内部与外部出现同名变量，默认使用的时内部变量

• nonlocal使用
• 说明：内部函数使用外部函数的局部变量，需要使用nonlocal进行声明

def wai():
 n = 10
 def nei():
 # 声明使用非本地变量，外部函数的局部变量
 nonlocal n
 n = 20
 print(n)
 nei()
 print(n)
​
wai()

递归函数(了解)

• 定义：函数内部调用函数本身的函数叫递归函数。
• 组成：
• 函数内部调用自己
• 终止条件(停止调用自己的条件)
• 核心算法(具体功能)
• 特点：
• 代码简洁
• 可读性差(不易理解)
• 瞬间占用内存较大，没有终止条件立即崩溃
• 有些领域是禁止使用的(安全领域：汽车电子)
• 只有在不得不使用的时候才使用(遍历目录)
• 练习：
• 求n的阶乘
• 斐波那契数列的第n项
• 前两项都为1，从第三项开始，每一项都等于前两项的和
• 如： 1,1,2,3,5,8,13,21,...

常用函数

• 内置函数(无需导入)

print：打印，输出
input：输入
abs：求绝对值
type：获取变量的类型
chr：将ASCII数值转换为字符
ord：将字符转换为对应的ASCII
id：获取变量地址
len：统计元素个数
range：产生连续整数的可迭代对象
enumerate：枚举可迭代对象
​
强制类型转换：
int
float
str
list
tuple
set
dict
​
max：求多个参数的最大值，或可迭代对象中的最大元素
min：最小值
sum：求和，可迭代对象元素求和
pow：求幂，pow(2, 3)等价于2 ** 3
round：四舍五入，可以指定保留位数
​
hex：16进制
oct：8进制
bin：2进制

• 模块函数(需要导入)

time：
 sleep：休眠指定的秒数，可以是小数
math：
 e：自然对数
 pi：圆周率
 ceil：向上取整
 floor：向下取整
 sqrt：开方(请平方根)
 degrees：弧度转换为度
 radians：度转换为弧度
sys：
 argv：运行程序时所有的命令行参数列表，第一个是程序文件名
 练习：完成一个计算器，支持加、减、乘、除运算

练习：

• 前面练习全部以函数形式进行封装
• 终端计算器
• 删除列表中的重复元素
• 统计一个字符串中字母、数字及其他字符的个数，返回一个元组即可
• 返回一个列表中第二大的数
• 完整列表的排序函数(sort)，支持逆序
• 号码归属地查询：

'''5582|1860101|010|北京市|北京联通GSM卡
5583|1860100|010|北京市|北京联通GSM卡
5584|1368141|010|北京市|北京移动神州行卡
5585|1860111|010|北京市|北京联通GSM卡
5586|1358198|010|北京市|北京移动动感地带卡
5587|1361139|010|北京市|北京移动预付费卡
5588|1361138|010|北京市|北京移动神州行卡
5591|1360110|010|北京市|北京移动全球通卡
5748|1364110|010|北京市|北京移动神州行卡
10186|1581584|020|广东省广州市|广东移动全球通卡
15046|1391897|021|上海市|上海移动全球通卡
17250|1502207|022|天津市|天津移动全球通卡
21137|1345272|023|重庆市万州|重庆移动大众卡
22700|1347812|024|辽宁省沈阳市|辽宁移动大众卡
24256|1377065|025|江苏省南京市|江苏移动全球通卡
26360|1898606|027|湖北省武汉市|湖北电信CDMA卡
28709|1860802|028|四川省成都市|四川联通GSM卡
30641|1552961|029|陕西省西安市|陕西联通GSM卡
31700|1563007|0310|河北省邯郸市|河北联通GSM卡
33360|1583396|0311|河北省石家庄市|河北移动全球通卡
34825|1508122|0312|河北省保定市|河北移动全球通卡
35363|1551235|0313|河北省张家口|河北联通GSM卡
37700|1331326|0316|河北省廊坊市|河北电信CDMA卡
43500|1350358|0358|山西省吕梁市|山西移动全球通卡
43908|1553625|0359|山西省运城市|山西联通GSM卡
44521|1335360|0370|河南省商丘市|河南电信CDMA卡
50078|1509369|0378|河南省开封市|河南移动全球通卡
53603|1583981|0398|河南省三门峡|河南移动全球通卡
53916|1335897|0410|辽宁省铁岭市|辽宁电信CDMA卡
55248|1554254|0411|辽宁省大连市|辽宁联通GSM卡
58618|1374272|0427|辽宁省盘锦市|辽宁移动全球通卡
58932|1554183|0429|辽宁省葫芦岛|辽宁联通GSM卡
60268|1340475|0431|吉林省长春市|吉林移动大众卡'''
​

按"指针"传递

python中 变量赋值、参数传递都是通过"指针"拷贝的方式进行的 。除了按"指针"拷贝，还有一种按值拷贝的方式，关于按值、按指针拷贝的细节，参见 按值传递 vs. 按指针传递 。

所以在python中，变量赋值、参数传递，都只是拷贝了源数据的一个地址，而不会拷贝内存中完整的数据对象副本。所以，如果在函数内部修改变量指向的数据对象，会影响函数外部的数据。

例如：

def f(x):
 print(x+3)
a=4
f(a)

在将 a 赋值给本地变量x的时候，只是拷贝了a目前保存的地址给x，使得x也保存了内存中数据对象4的地址。

如果传递的数据对象是可变数据对象(例如列表)，那么在函数内部修改它，会影响函数外部的原始数据对象：

L1=[11,22,33,44]
def f(x):
 x[0] += 1
f(L1)
print(L1) # 输出：[12, 22, 33, 44]

显然，在函数内部修改 x[0] 的值，函数外部原始的L1也发生了改变。因为L1赋值给x的时候，只是拷贝了一份L1所指向列表的地址给x，使得x也指向这个列表。

为了避免这种情况，可以新创建一份列表的副本，然后传递给函数参数。

L1=[11,22,33,44]
def f(x):
 x[0] += 1
f(L1[:])
print(L1) # 输出：[11, 22, 33, 44]

上面传递给函数参数x的是 L1[:] ，它会在内存中创建一个新的列表副本，所以x指向的是这个新的副本列表，修改它不会影响原始的列表L1。

函数参数

Python的函数对参数和返回值方面非常宽松，参数变量可以是任意数据类型，返回值也一样，只需使用变量名代替它们即可。

例如，下面的参数x可以是任意类型的结构，可以是数值、字符串、列表、字典等等类型。返回值语句return同理。

def f(x):
 print(x)
 return x
f(2)
f("haha")

实际上，上面调用函数时是按照参数位置进行传参对本地变量x进行赋值的。除此之外，还可以指定为 key=value 的方式进行传参。例如：

f(x=2)
f(x="haha")

按位置传参

如果是多个参数，则按从左到右的顺序进行参数变量的赋值：

def f(x,y,z):
 print(x)
 print(y)
 print(z)
f(2,3,4)

调用 f(2,3,4) 的时候，会按照从左向右的位置方式对本地变量x、y、z赋值： x=2,y=3,z=4。

按关键字key/value方式传值

python还支持 key=value 的方式设置函数调用时的参数，使用 key=value 的方式赋值时，顺序不重要。这种函数调用时的传值方式称为"关键字传值"。

例如：

def f(x,y,z):
 print(x)
 print(y)
 print(z)
 
f(x=3,y="haha",z=4)

也可以打乱顺序：

f(x=3,z=4,y="haha")

还可以将 key=value 和位置传参的方式进行混合：

f(3,"haha",z=4)

但混合按位置传参方式的时候， 位置参数必须在其它传参方式的前面 ，不仅此处结合 key=value 时如此，后文中 位置参数结合其它方式传参也都如此：位置参数必须在最前面 。

例如，下面的传参方式是错的：

f(z=4,3,"haha")

参数默认值

在def或lambda声明函数的时候，可以通过 var=default 的方式指定参数的默认值。

例如：

def f(x=3):
 print(x)
f(4)
f("haha")
f()

上面的 f(4) 和 f("haha") 都对函数f()的本地变量x进行了赋值。但是最后一个调用语句 f()未赋值，而是使用参数的默认值3。

设置参数默认值时，如果函数有多个参数，则带默认值参数后面必须放在最后面。例如：

# 正确
def f(x,y,z=4)
def f(x,y=1,z=4)
# 错误
def f(x,y=4,z)

只要为参数设置了默认值，那么调用函数的时候，这个参数就是可选的，可有可无的，如果没有，则采用默认值。

def f(x,y=2,z=4):
 print(x)
 print(y)
 print(z)
# 不采用任何默认值
f(2,3,4)
# 采用z的默认值
f(2,3)
# 采用y的默认值
# 此时z必须按key=value的方式传值
f(2,z=5)
# y、z都采用默认值
f(2)

变长参数：*

对于任意长度的参数，可以在 def 声明的函数中使用 * 将各 位置参数 收集到一个元组中。例如：

def f(*args):
 print(args)
f(1,2,3,4)

上面调用 f(1,2,3,4) 的时候，将所有参数都收集到了一个名为args的元组中。所以上面的函数将输出：

(1, 2, 3, 4)

既然是元组，就可以对参数进行迭代遍历：

def f(*args):
 for arg in args:
 print(arg)
f(1,2,3,4)

必须注意， * 是按位置收集参数的。

def f(x,y,*args):
 print(x)
 print(y)
 for arg in args:
 print(arg)
f(1,2,3,4)

按照从左向右的传参规则，首先将1赋值给x，将2赋值给y，然后将剩余所有的 位置参数 收集到args元组中，所以 args=(3,4) 。

如果 * 后面还有参数，则调用函数的时候，后面的参数必须使用 key=value 的方式传递，否则会收集到元组中，从而导致参数缺少的问题：

def f(x,*args,y):
 print(x)
 print(y)
 for arg in args:
 print(arg)
# 正确
f(1,3,4,y=2)
# 错误
f(1,2,3,4)

上面调用 f(1,3,4,y=2) 的时候，会按照位置参数对x赋值为1，然后将所有位置参数收集到元组args中，因为 y=2 是非位置参数传值方式，所以 args=(3,4) 。

如果为上面的y设置默认值：

def f(x,*args,y=2)

那么 f(1,2,3,4) 会将 (2,3,4) 都收集到元组args中，然后y采用默认值2。

变长参数：**

除了可以使用 * 将位置参数收集到元组中，还可以使用 ** 将 key=value 格式的参数收集到字典中。

例如：

def f(x,**args):
 print(x)
 print(args)
f(1,a=11,b=22,c=33,d=44)

上面首先按位置传参的方式赋值 x=1 ，然后将剩余的所有 key=value 参数收集到名为args的字典中。所以，args字典的内容为：

{'a': 11, 'b': 22, 'c': 33, 'd': 44}

既然是将参数收集到字典中，就可以使用字典类的工具操作这个字典。例如，遍历字典。

在 ** 的 后面不能出现任何其它类型的参数 。例如，下面的都是错误的def定义方式：

def f(x,**args,y)
def f(x,**args,y=3)
def f(x,**args,*t)

只能将位置参数或者 * 的收集放在 ** 的前面。

def f(x,y,**args)
def f(x,*args1,**args2)

函数调用时的*和**

除了在def定义函数时，参数中可以使用 * 或 ** 收集参数，在 函数调用 的时候也可以使用 *或 ** 分别解包元组(列表或其它对象)、字典。一定要注意区分函数定义和函数调用时的 * 、 ** ，它们的用法是不通用的。

例如，解包元组：

def f(a,b,c,d):
 print(a)
 print(b)
 print(c)
 print(d)
T=(1,2,3,4)
f(*T)

* 除了可以解包元组，还可以解包其它可迭代对象，例如列表。甚至是字典也能解包，只不过* 解包的字典得到的 是key组成的参数列表 ，和value无关：

D=dict(a=11,b=22,c=33,d=44)
f(*D)
# 输出：
a
b
c
d

而 ** 解包的字典则是 key=value 组成的参数列表。以下是函数调用时使用 ** 进行解包，字典D中的key名称必须和def中定义的参数名称相同：

def f(a,b,c,d):
 print(a)
 print(b)
 print(c)
 print(d)
D=dict(a=11,b=22,c=33,d=44)
f(**D)
# 输出：
11
22
33
44

在函数调用时，可以混合位置参数、关键字参数、 * 解包参数、 ** 解包参数。用法非常的灵活：

def f(a,b,c,d):
 print(a)
 print(b)
 print(c)
 print(d)
f(*(1,2),**{'d':4,'c':3})
f(1,*(2,3),**{'d':4})
f(1,c=3,*(2,),**{'d':4})
f(1,*(2,3),d=4)
f(1,*(2,),c=3,**{'d':4})

上面调用函数时的效果都等同于 f(1,2,3,4) 。

keyword-only参数形式

keyword-only的参数传值方式表示def中如果使用了 * ，那么在调用函数时， 它后面的参数必须只能使用关键字传值 。其实在前面的内容中已经出现过几次与之相关的说明。

另外注意， * 才是keyword-only开关， ** 不是，虽然 ** 也有自己的一些语法限制：任意类型的参数定义都必须在 ** 之前，包括keyword-only类型的参数。这个前面已经解释过了。

例如：

def f(a,*b,c):
 print(a,b,c)

按照keyword-only的规则，被 *b 收集的位置参数不包括c，这个c必须只能使用关键字的方式传值，否则就被当作位置参数被收集到元组b中。

# 正确
f(1,2,3,c=4)
# 错误
f(1,2,3,4)
# 错误
f(1,c=4,2,3)

其中最后一个错误和如何def的定义无关，而是函数调用时的语法错误，前面已经解释过：位置参数必须放在最前面。

还可以直接使用 * 而非 *args 的方式，这表示 不收集任何参数，但却要求它后面的参数必须按照关键字传值的方式 。

def f(a,*,b,c):
 print(a,b,c)

以下是正确和错误的调用方式示例：

# 正确
f(1,b=2,c=3)
f(1,c=3,b=2)
f(b=2,c=3,a=1)
# 错误
f(1,2,3)
f(1,2,c=3)
f(1,b=2,3)

不过，keyword-only后面的参数可以使用参数默认值。

def f(a,*,b,c=3)

那么c是可选的，但如果给定，则必须按关键字方式传值。

参数定义和参数传值的规则

对于 函数定义中的参数 ，有3种方式：普通位置参数、 * 开启的keyword-only参数、 **args收集参数。它们之间的规则是：

• **args 必须在最后面
• * 或 *args 后面可以是普通参数，但是函数调用传值时，它后面的参数必须按照关键字的方式指定

所以，函数定义时参数的通用形式为：其中c和d必须使用关键字传值方式

def f(a,b, *,c,d, **dicts)
def f(a,b, *args,c,d, **dicts)

对于函数调用中的参数，有：普通位置参数、关键字参数、 * 解包参数、 ** 解包参数。它们之间的规则时：

• 普通位置参数必须在最前面
• ** 解包必须在最后面
• 关键字参数和 * 解包参数只要求在上述两种参数形式中间，顺序可以随意

所以，函数调用时的传参形式为：

f(a,b,c, *(d,e,f),g=1,h=2, **dict(j=3,k=4))
f(a,b,c, d=1,e=2,*(f,g,h), **dict(j=3,k=4))

例如：

def f(a,*b,c,**d):
 print(a,b,c,d)
f(1, 2,3, c=4, x=5,y=6)
f(1, c=4,*(2,3), **dict(x=5,y=6))
f(1, *(2,3),c=4, **dict(x=5,y=6))
f(1, *(2,3), **dict(c=4,x=5,y=6))
f(1, 2,3, **dict(c=4,x=5,y=6))

函数注解(annotations)

python函数有一个名为 __annotations__ 的属性(可以使用dir(Func_Name)来查看)。它表示函数的注解。

函数的注解使得参数变得更规范、更通用，它有点类似于强调数据类型。但 它们仅仅只是注解，只是给人看，用来起提示作用的，不会对实际的调用有任何影响 。

例如，下面是没有给注解的函数参数，也就是平时见到的参数方式：

def myfunc(a,b,c):
 return a+b+c
myfunc(1,2,3)

函数的注解分两种：参数注解和返回值注解。

• 参数注解：定义在各参数名之后，使用冒号分隔参数和参数的注解
• 返回值注解：定义在参数列表之后，冒号之前，使用瘦箭头 -> 分隔

例如：

def myfunc(a:'string',b:[1,5],c:int)->int:
 return a+b+c
print( myfunc(1,2,3) )
print( myfunc("a","b","c") )

虽然上面的函数注解提示了参数a是一个字符串，b是一个列表，c是一个int类型的数据，以及返回值是一个int类型的值，但在函数调用的时候，这些"强调"并没有发生影响，只不过在使用该函数的时候，如果使用IDE编写代码，会有代码提示。

可以通过函数的 __annotations__ 属性查看函数的注解：

print(myfunc.__annotations__)

输出：

{'a': 'string', 'b': [1, 5], 'c': <class 'int'>, 'return': <class 'int'>}

可以只对其中一个或多个参数进行注解。

如果使用了注解，还要设置参数的默认值，则默认值需要在注解的后面。例如：

def f(a:'string'=4):

函数注解只对def语句有效，对lambda无效，因为lambda已经限制了函数的定义方式。