return语句
语法：
return [表达式]
[ ]可以省略
作用：
用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时返回一个对象的引用关系
说明：
1.return语句后跟的表达式可以省略，省略后相当于return None
2.如果函数没有return语句，则函数执行完最后一条语句后返回None（相当于在最后加了一条return None语句）
3.函数调用一定会返回一个对象引用
def myfun(a,b):
s=a+b#在函数内部定义的变量是局部变量
print("和是：",s)
return s#给调用者返回的值
# 此示例示意return语句的用法和执行过程
def myf1():
print("assdg")
print("vfsg")
return 100 #return语句执行后，后面的语句便不再执行，以遇到return马上回到调用函数的地方
print("wtehn")
v=myf1()#一遇到函数名加括号立马执行函数内容
print("我是返回值：",v)
练习：
写一个函数myMax,实现返回两个数的最大值：
如：
def myMax():
print(myMax(100,200)) #200
print(myMax(10,20)) #20
print(myMax(“abcd,”“abc”) #abcd
def myMax(a,b):
v=max(a,b)
return v
print(myMax(100,200))
print(myMax(20,10))
print(myMax("abcd","abc"))
写一个函数input_number()：
。。。。。
此函数用来获取用户循环输入的整数，当用户输入负数时，结束输入
将用户输入的数以列表的形式返回，再用再建函数max,min,sum示出用户输入的最大值，最小值以及和
def input_number():
li=[]
sum=0
while 1:
i=int(input("请输入整数："))
if i<0:
break
if i not in li:
li.append(i)
for x in li:
sum+=i
print("最大值",max(li),"最小值：",min(li),"和：",sum)
return li
print(input_number())
Python函数的参数传递
传递方式
- 位置传参
- 序列传参
- 关键字传参
- 字典关键字传参
位置传参
实际参数（实参）的对应关系与形式参数（形参）的对应关系是按位置来一次对应的
示意：
def myFun(a,b,c):
pass
myFun(1，2，3)
说明：
实际参数和形式参数通过位置进行传递和匹配
实参个数必须与形参个数相同
# 此示例示意位置传参
def myFun(a,b,c):
print("a绑定的是：",a)
print("b绑定的是：",b)
print("c绑定的是：",c)
myFun(1,2,3)
序列传参
序列传参是指在函数调用过程中，用*将序列拆解后按位置传参的方式进行参数传递
def myFun(a,b,c):
print("a绑定的是：",a)
print("b绑定的是：",b)
print("c绑定的是：",c)
s=[1,2,3]
myFun(*s) #*表示把s拆开s[0,1,2]分别对应a,b,c
s2="asd"
myFun(*s2)
关键字传参
关键字传参是指传参时，按着形参的名称给形参赋值
实参和形参按照名称进行匹配，实参和形参可以不按位置分配
# 此示例示意关键字传参
def myFun(a,b,c):
print("a绑定的是：",a)
print("b绑定的是：",b)
print("c绑定的是：",c)
myFun(b=22,c=23,a=12) #实参和形参可以不按位置分配
字典关键字传参
是指实参为字典，将字典用**拆解后进行关键字传参
说明：
字典的键名必须和形参名一致
字典的键名必须是字符串
字典的键名要在形参中存在
# 此示例示意字典关键字传参
def myFun(a,b,c):
print("a绑定的是：",a)
print("b绑定的是：",b)
print("c绑定的是：",c)
d={"c":12,"a":45,"b":23}
myFun(**d)#拆解字典后再传参
函数的综合传参
函数传参方式，在能确定形参能唯一匹配到相应实参的情况下可以任意组合
说明：
传参时，先位置传参，后关键字传参
# 此示例示意综合传参
def myFun(a,b,c):
print("a绑定的是：",a)
print("b绑定的是：",b)
print("c绑定的是：",c)
myFun(100,*[200,400])
myFun(*"as",200)
myFun(1,**{"c":3,"b":5})
myFun(100,b=200,c=10)
myFun(**{"b":2,"c":2},a=1)
myFun(b=2,c=1,a=5)
练习
1.写一个函数sum3(a,b,c)
用于返回三个数的和
2.写一个函数pow3(x),用于返回x的三次方
用以上函数计算
1），13+23+3**3
2）计算1+2+3的和的立方
def sum3(a,b,c):
d=a+b+c
return d
def pow3(x):
y=x**3
return y
print(sum(pow3(1),pow3(2),pow3(3)))
print(pow3(sum3(1,2,3)))
以下讲的是形参
函数的缺省参数
语法：
def 函数名（形参名1=默认实参，
形参名2=默认实参2，
形参名3=默认实参3.。。。）
说明
-
缺省参数必须自右至左依次存在，如果一个参数由缺省参数，则及右侧的所有参数必须有缺省参数
-
缺省参数可以有0个1个或多个，甚至全部都有缺省参数
如：
def test(a,b=10,c):------------------>错误！
# 以下示意缺省参数
def info(name, age=1, address="未填写"):
print(name,"今年", age,"岁", "家住：", address)
info('csaf',25)
info("暴风")
info("梵蒂冈",21,"浙江杭州")
练习
写一个函数，mySum(),可以传入两个实参或三个实参，
如果传入两个实参则返回两个实参的和
如果传入三个实参，则返回前两个实参和对第三个实参求余的结果
def mySum(a,b,c=None):
if c is None:
return a+b
return (a+b)%c
print(mySum(12,3))
print(mySum(12,4,5))
函数的形参定义方式
- 位置形参
- 星号元祖形参
- 命名关键字形参
- 双星号字典形参
位置形参
语法：
def 函数名（形参1，形参2，。。）：
语句块
星号元祖形参
语法
def 函数名（*元祖形参名）：
语句
作用：
收集多余位置传参
说明：
元祖形参名通常用：“args”
练习
写一个函数，mySum,可以传入任意个实参的数字，返回所有实参的和
def mySum(*args):
return sum(args)
print(mySum(1,2,3,4,5,6,7,8))
命名关键字形参
语法：
def 函数名（*，命名关键字形参）：
语句
或
def 函数名（*args,命名关键字形参）：
语句
作用：
所有的参数都必须用关键字传参或字典关键字
def fn(*,d,e): # * 是语法表示符
print("d=",d)
print("e=",e)
fn(d=200,e=300)# 所有传参必须是以关键字传参
fn(100,200) #不合法!不能用位置传参
fn(1,2,d=12,e=34) #不合法
def fn(*args,d,e):
print(args)
print("d=",d)
print("e=",e)
fn(1,2,d=12,e=34) # 合法
fn(*"as",**{"e":12,"d":4})
双星号字典形参
语法：
def 函数名（**字典形参名）：
语句
作用：
收集多余的关键字传参
说明：
通常字典形参名定为
def func(**kwargs):
print("关键字参数个数是：",len(kwargs))
print("kwargs:",kwargs)
print(func(name="das",age=12))
函数的参数说明
缺省参数 位置形参 星号元祖形参 ，命名关键字形参和双星号字典形参可以混合使用
函数参数自左至右的顺序为：
位置形参
星号元祖形参
命名关键字形参
双星号字典形参
综合示例：
# # 综合示例
def f1(a,b,*args,c,**kwargs):
print("位置形参：",a,b)
print("星号元祖形参：",args)
print("关键字传参：",c)
print("双星号字典传参：",kwargs)
f1(12,34,*"gjfsdf",c=21,**{"name":"as","age":12})
函数不定长参数：
def fn(*args,**kwards):
pass
#可以接受任意的位置传参和关键字传参
def fn(*args, **kwards):
print(args)
print(kwards)
fn("as",12,2,23,34,45,**{"name":"dasf","afe":321})
练习
写一个myRange()函数，此函数返回一个符合rang规则的完整数列表
如：
L=myRange(3)
print(L) [0,1,2]
def myRange(start,stop=None,step=1):
li=[]
i=start
if stop is None:
stop=start
start=0
i=start
while i<stop:
li.append(i)
i+=1
if stop is not None:
while i<stop:
li.append(i)
i+=1
if step is not 1:
while i<stop:
li.append(i)
i+=step
return li
练习
1.素数prime函数练习
1）写一个函数isprime（x)判断x是否是素数，如果是返回True ,否则返回False
2）写一个函数prime_m2n(m,n)
返回从m开始到n结束（不包含n）的范围内的素数列表
3）写一个函数primes(n),返回指定范围内素数（不包含n）的全部素数的列表，并打印这些素
数
1）打印100以内的全部素数
2）打印100以内的全部素数和
def isPrimes(x):
if x<=1:
return False
for i in range(2,x):
if x%i!=0 or x==2:
return True
return False
def prime_m2n(m,n):
return [x for x in range(m,n) if isPrimes(x)]
def primes(n):
return prime_m2n(0,n)
print(prime_m2n(0,100))
print(sum(primes(100)))
2.修改之前的学生信息管理程序
编写两个函数用于封装
录入学生的信息和打印学生信息的功能
1）def input_student():
#此函数获取学生信息，并返回学生信息的列表
2） def output_student(L):
#以表格形式再打印学生信息
验证测试：
L=input_student()
output_student(L)
print（“在添加几个学生的信息”）
L+=input_student(L)
print(“添加后的学生信息如下：”)
l = []
def input_student():
while 1:
name = input("请输入学生姓名：")
if not name:
break
age = int(input("请输入学生年龄："))
score = int(input("请输入学生成绩："))
d = {} # 创建一个新的字典
d["name"] = name # 值 对 键
d["age"] = age
d["score"] = score
l.append(d)
def output_student(l):
print("+--------+-----+--------+")
print("| name | age | score |")
print("+--------+-----+--------+")
for d in l:
t = ((d["name"]).center(8),
str(d["age"]).center(5),
str(d["score"]).center(8))
line = "|%s|%s|%s|" % t # t是元祖
print(line)
print("+--------+-----+--------+")
input_student()
output_student(l)