目录
- 1.函数参数
- 2.递归函数
- 总结
1.函数参数
# 1.位置参数：调用函数时，传入的值需要按照位置顺序传入
# 实例：求x的n次方
def xpown(x,n): # 传入的值按照x,n的位置顺序传入
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print("2的5次方的值为：",xpown(2,5))
print("5的2次方的值为：",xpown(5,2))
# 结果输出：
# 2的5次方的值为： 32
# 5的2次方的值为： 25
# 2.默认参数
# 实例：求x的n次方
def xpown(x,n = 2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print("2的5次方的值为：",xpown(2,5)) # 当n有新的值传入，则使用新值计算，如果没有，则默认
print("5的2次方的值为：",xpown(5)) # n的值默认为2
print("---------------------------")
print("---------------------------")
# 设置默认参数的注意事项：
# 1.必选参数在前，默认参数在后；
# 2.当函数有多个参数时，把变化大的参数放在前面，变化小的参数放在后面；
# 变化小的参数可以作为默认参数；
# 3.使用默认参数可以降低调用函数的难度；
# 4.定义默认参数时，默认参数必须指向不变对象，如果是可变对象，则出现问题，如：list
# 实例：学生信息登记
def studentinfo(name,gender,age,city = "shenzhen"):
print("学生的名字为：",name)
print("学生的性别为：",gender)
print("学生的年龄为：",age)
print("学生来自的城市为：",city)
print("同学1的信息如下：")
print("-----------------------------")
studentinfo("willard","男",18) # 使用默认参数shenzhen
print("*****************************")
print("同学2的信息如下：")
print("-----------------------------")
studentinfo("chenjd","女",18,"maoming") # 传入新的参数maoming替换shenzhen
# 结果输出：
2的5次方的值为： 32
5的2次方的值为： 25
—————————
—————————
同学1的信息如下：
—————————–
学生的名字为： willard
学生的性别为： 男
学生的年龄为： 18
学生来自的城市为： shenzhen
*****************************
同学2的信息如下：
—————————–
学生的名字为： chenjd
学生的性别为： 女
学生的年龄为： 18
学生来自的城市为： maoming
# 3.可变参数：传入的参数个数是可变的，可以是0、1、2到任意个
# 传统方式传入参数时，可以以list或tuple传入
# 实例(传统方式)：
def sumofn(intnumbers):
sum = 0
for n in intnumbers:
sum = sum + n
return sum
print("前100项累加和为：",sumofn(range(101)))
print("前50项累加和为：",sumofn(range(51)))
print("任意项累加和为：",sumofn([1,2,5,6,7,8,9,10]))
print("任意项累加和为：",sumofn((1,2,3,4,5,7,8,9,12)))
print("---------------------------------------------------------")
# 可变参数：在参数前添加*号
def sumofn(*intnumbers):
sum = 0
for n in intnumbers:
sum = sum + n
return sum
print("任意项累加和为：",sumofn(1,2,3,4,6,7,8,9))
print("任意项累加和为：",sumofn(1,2,4))
print("任意项累加和为：",sumofn(3,4,5,6,7))
print("---------------------------------------------------------")
# 把list或tuple作为可变参数传入
def sumofn(*intnumbers):
sum = 0
for n in intnumbers:
sum = sum + n
return sum
# 已经有list,*nums表示把nums的所有元素作为可变参数传入
nums = [1,2,3,5]
print("传入一个list：",sumofn(*nums))
# 结果输出：
前100项累加和为： 5050
前50项累加和为： 1275
任意项累加和为： 48
任意项累加和为： 51
———————————————————
任意项累加和为： 40
任意项累加和为： 7
任意项累加和为： 25
———————————————————
传入一个list： 11
# 4.关键字参数
# 可变参数允许传入任意个参数，这些可变参数在函数调用时自动组装为一个tuple;
# 关键字参数允许传入任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict;
def personinfo(name,age,**kw):
print("name:",name,"age:",age,"other:",kw)
print("willard个人信息：")
personinfo("willard",18)
print("------------------------------------------------------------------")
print("willard更详细的个人信息：")
personinfo("willard",18,gender = "男",job = "enginner")
print("------------------------------------------------------------------")
print("chenjd个人信息：")
personinfo("chenjd",18,gender = "女")
print("------------------------------------------------------------------")
# 关键字参数：可以扩展函数的功能
# eg：用户注册功能，用户名和年龄是必填信息，其他信息均为可选
# 可以先组装出dict，然后把dict转换为关键字参数传入
extrainfo = {"gender":"man","city":"shenzhen","job":"engineer"}
print("hackerluo个人信息如下：")
personinfo("hackerluo",18,gender = extrainfo["gender"],job = extrainfo["job"])
print("------------------------------------------------------------------")
# 使用简化写法
print("简化写法传入hackerluo个人信息：")
personinfo("hackerluo",18,**extrainfo)
# 结果输出：
willard个人信息：
name: willard age: 18 other: {}
——————————————————————
willard更详细的个人信息：
name: willard age: 18 other: {‘gender’: ‘男’, ‘job’: ‘enginner’}
——————————————————————
chenjd个人信息：
name: chenjd age: 18 other: {‘gender’: ‘女’}
——————————————————————
hackerluo个人信息如下：
name: hackerluo age: 18 other: {‘gender’: ‘man’, ‘job’: ‘engineer’}
——————————————————————
简化写法传入hackerluo个人信息：
name: hackerluo age: 18 other: {‘gender’: ‘man’, ‘city’: ‘shenzhen’, ‘job’: ‘engineer’}
# 5.命名关键字参数
# 函数调用者可以传入任意不受限制的关键字参数；
# 传入了哪些参数，需要在函数内通过kw检查；
def personinfo(name,age,**kw):
if "city" in kw:
pass
if "job" in kw:
pass
print("name:",name,"age:",age,"other:",kw)
# 如果要限制关键字参数的名字，可以用命名关键字参数
# 只接收gender,job作为关键字参数
# 命名关键字参数需要*作为分隔符，*后面的参数视为命名关键字参数
# 命名关键字参数必须传入参数名
def personinfo(name,age,*,gender,job):
print(name,age,gender,job)
# 调用方式：
print("命名关键字参数调用！")
personinfo("willard",18,gender = "男",job = "engineer")
print("------------------------------------------------------------------")
# 如果函数定义中已经有一个可变参数，则后面跟着命名关键字参数不需要*分隔符
def personinfo(name,age,*args,gender,job):
print(name,age,args,gender,job)
# 命名关键字参数的缺省值
def personinfo(name,age,*,gender,job = "engineer"):
print(name,age,gender,job)
print("命名关键字参数有缺省值！")
personinfo("willard",18,gender = "男")
# 结果输出：
命名关键字参数调用！
willard 18 男 engineer
——————————————————————
命名关键字参数有缺省值！
willard 18 男 engineer
# 6.参数组合
# 常用参数：必选参数、默认参数、可变参数、关键字参数、命名关键字参数
# 参数定义顺序：必选参数、默认参数、可变参数、命名关键字参数、关键字参数
def egfunc1(name,age,gender = "男",*args,**kw):
print("name:",name,"age:",age,"gender:",gender,"args:",args,"kw:",kw)
def egfunc2(name,gender = "男",*,job,**kw):
print("name:",name,"gender:",gender,"job:",job,"kw:",kw)
# 调用
print("egfunc1传入name和age参数：")
egfunc1("willard",18)
print("------------------------------------------------------------------")
print("egfunc1传入name，age，gender参数：")
egfunc1("chenjd",18,"女")
print("------------------------------------------------------------------")
print("egfunc1传入name,age,gender,args参数：")
egfunc1("hackerluo",18,"男",170,60)
print("------------------------------------------------------------------")
print("egfunc1传入name,age,gender,args,kw参数：")
egfunc1("willard",18,"男",170,60,job = "engineer")
print("------------------------------------------------------------------")
print("egfunc2传入name,gender,job,kw参数：")
egfunc2("willard",job = "engineer",ext = none)
print("------------------------------------------------------------------")
print("egfunc1通过tuple和dict传入参数：")
args = ("willard",18,"男",170,60)
kw = {"job":"engineer"}
egfunc1(*args,**kw)
# tips:
# 1.默认参数一定要用不可变对象，如果是可变对象，程序运行时出现逻辑错误；
# 2.*args是可变参数，args接收的是一个tuple；
# 3.**kw是关键字参数，kw接收的是一个dict；
# 4.可变参数可以直接传入:func(1,2,3,4)，也可以先组装list或tuple，
# 通过*args传入：func(*(1,2,3,4))；
# 5.关键字参数可以直接传入：func(a = 1,b = 2)，也可以先组装dict，
# 通过**kw传入：func(**{"a":1,"b":2})；
# 6.命名关键字参数在没有可变参数的情况下需要写分隔符*
# 结果输出：
egfunc1传入name和age参数：
name: willard age: 18 gender: 男 args: () kw: {}
——————————————————————
egfunc1传入name，age，gender参数：
name: chenjd age: 18 gender: 女 args: () kw: {}
——————————————————————
egfunc1传入name,age,gender,args参数：
name: hackerluo age: 18 gender: 男 args: (170, 60) kw: {}
——————————————————————
egfunc1传入name,age,gender,args,kw参数：
name: willard age: 18 gender: 男 args: (170, 60) kw: {‘job’: ‘engineer’}
——————————————————————
egfunc2传入name,gender,job,kw参数：
name: willard gender: 男 job: engineer kw: {‘ext’: none}
——————————————————————
egfunc1通过tuple和dict传入参数：
name: willard age: 18 gender: 男 args: (170, 60) kw: {‘job’: ‘engineer’}
2.递归函数
# 在函数内部，可以调用其他函数，亦可以调用函数本身，则为递归函数
# 计算阶乘：n!=1×2×3...×n
def fact(n):
if n == 1:
return 1
return n * fact(n - 1)
print("5的阶乘为：",fact(5))
print("100的阶乘为：",fact(50))
# print("10000的阶乘为：",fact(10000))
# print("10000的阶乘为：",fact(10000)) # 栈溢出
# 在计算机中，函数调用是通过栈数据结构实现，每进入一个函数调用，
# 栈会加一层栈帧，当函数返回，栈减少一层栈帧，递归调用次数过多，会导致栈溢出；
# 读者尝试fact(1000),fact(10000)，可能fact(1000)就已经栈溢出，
# 笔者测试fact(1000)还是可以正常输出的，fact(10000)栈溢出
# 结果输出：
5的阶乘为： 120
100的阶乘为： 30414093201713378043612608166064768844377641568960512000000000000
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注www.887551.com的更多内容!
