# return关键字的作用
# 1.注意1：如果给函数没有显式的设置返回值，则默认返回None
def test1():
print('1111')
r1 = test1()
print(r1)
# 等价于
def test1():
print('1111')
return None
# 注意2：函数在哪里调用，返回值就返回到哪里，如果一个函数有返回值，可以使用变量将返回值接出来
r1 = test1()
print(r1)
print("*" * 30)
# 2.注意3：return是一个关键字，可以单独作为一条语句使用，作用：只能使用在函数中，作用是结束函数
# 所以，如果return语句有机会执行，则return后面其他语句将没有执行的机会
# a.
def test2():
print("start~~~2222")
return
print("end~~~2222")
test2()
# b.
def test2(n):
print("start~~~2222")
if n > 2:
return
print("end~~~2222")
test2(3)
test2(1)
print("*" * 30)
# 3.break和return的区别
# 注意4：break是结束当前循环，return是结束函数，而且return只能使用在函数中
# 从一定程度上来说，return的作用大于break
def test3():
print("start")
for i in range(3):
for j in range(5):
print(f"{i} = {j}")
if j == 2:
break # 结束当前循环
print("end")
test3()
print("over")
print("*" * 30)
def test3():
print("start")
for i in range(3):
for j in range(5):
print(f"{i} = {j}")
if j == 2:
return # 结束函数
print("end")
test3()
print("over")
print("*" * 30)
# def test3():
# print("start")
# for i in range(3):
# for j in range(5):
# print(f"{i} = {j}")
# if j == 2:
# exit() # 结束进程
# print("end")
# test3()
# print("over")
print("*" * 30)
# 4.return xxxx
# 注意5：return xxx表示结束函数，同时将指定的值返回,建议：封装函数的时候，尽量将print替换为return
# a.
def test4(a,b):
total = a + b
print(total)
test4(3,6)
def test4(a,b):
total = a + b
return total
r4 = test4(3,6)
print(r4)
print(r4 + 10)
print(test4(23,78))
# b
# 注意6.return的后面可以跟多个数据，最终会将数据进行打包，返回值会被当做元组处理
def test5(num1,num2,num3):
return num1,num2,num3
r5 = test5(3,5,7)
print(r5) # (3, 5, 7)
# c.
# 注意7：return可以使用在不同的分支中，每个分支的返回值类型可以不相同
"""
注意8：如何封装一个函数
是否需要设置参数：观察需求中是否有未知项参与运算，如：指定数，某个数，指定列表.....
是否需要设置返回值:观察需求实现完毕之后是否有结果
"""
# 需求：封装一个函数，比较两个数的大小，返回较大值
def compare(num1,num2):
if num1 > num2:
return num1
elif num1 < num2:
return num2
else:
return "相等"
r = compare(34,34)
print(r)
2.空函数和主函数
# 1.空函数
def test():
pass
# 2.主函数
# 主函数的作用是整个程序的入口，在Java语言中，有一个主函数main,但是，Python中没有主函数一说，我们可以通过if语句模拟
# 主要应用在模块中，目前只用于调用函数
def func():
pass
if __name__ == '__main__':
func()
3.函数练习
"""
如何封装一个函数
是否需要设置参数：观察需求中是否有未知项参与运算，如：指定数，某个数，指定列表.....
是否需要设置返回值:观察需求实现完毕之后是否有结果
"""
# 1.判断年份的平闰性
def isleapyear(year):
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
return True
return False
r = isleapyear(2020)
print(r)
# 2.统计2~某个数中质数的个数
# a.判断某个数是否是质数
def isprime(num):
if num < 2:
return False
else:
result = True
for i in range(2,num):
if num % i == 0:
result = False
break
return result
# b.统计质数的个数
def get_count(n):
count = 0
for m in range(2,n + 1):
if isprime(m):
count += 1
return count
r = get_count(100)
print(r)
# 3.模拟列表的sort功能，对列表进行排序，默认升序，也可以降序
def custom_sort(numlist,reverse=False):
if reverse:
# 降序
for i in range(len(numlist) - 1):
for j in range(i + 1,len(numlist)):
if numlist[i] < numlist[j]:
numlist[i],numlist[j] = numlist[j],numlist[i]
else:
# 升序
for i in range(len(numlist) - 1):
for j in range(i + 1,len(numlist)):
if numlist[i] > numlist[j]:
numlist[i],numlist[j] = numlist[j],numlist[i]
list1 = [23,45,6,6,45,124]
custom_sort(list1)
print(list1)
list1 = [23,45,6,6,45,124]
custom_sort(list1,reverse=True)
print(list1)
一、匿名函数【重点掌握】
二、函数的本质概念：不再使用def这种标准形式定义函数，而是使用lambda表达式来创建函数，该函数没有函数名，被称为匿名函数
语法：lambda 形参列表:返回值
说明：
a.lambda只是一个表达式，用一行代码实现一个简单的逻辑，可以达到对函数的简化【优点】
b.lambda主体是一个表达式，而不是一个代码块，只能封装有限的逻辑【缺点】
c.lambda拥有自己的命名空间，不能访问自有列表之外或者全局命名空间里的参数
# 语法：lambda 形参列表:函数体和返回值 # 1.基本用法 # 标准定义 def func1(): print("111") # 直接调用 func1() r1 = func1() # 函数的调用,直接调用 print(r1) f1 = func1 # 函数本身 # print(f1) ## print(func1) # # func1() f1() # 间接调用 # 匿名函数：lambda表达式 # 直接调用 r1 = (lambda :print("111~~~~~~"))() print(r1) # 间接调用 f2 = lambda :print("111~~~~~~") r2 = f2() print(r2) # 注意1：不管是def定义的函数，还是匿名函数，函数定义完成之后，都需要手动调用 print("*" * 30) # 2.匿名函数的返回值 # 需求：封装函数，求两个数的和 def add1(num1,num2): return num1 + num2 r1 = add1(3,5) print(r1) # 注意2：书写匿名函数的时候，如果有返回值，不需要通过return声明 add2 = lambda num1,num2:num1 + num2 r2 = add2(4,7) print(r2) # 3.在匿名函数中可以使用if语句,但是只能使用三目运算符 # 需求：封装函数，比较两个数是否相等 def compare1(a,b): if a == b: return True return False print(compare1(34,78)) compare2 = lambda a,b: True if a == b else False print(compare2(345,79)) compare3 = lambda a,b:a == b print(compare3(34,34)) # 需求：封装一个函数，比较两个数的大小，返回较大值 def compare4(num1,num2): if num1 >= num2: return num1 else: return num2 r = compare4(34,34) print(r) compare5 = lambda num1,num2:num1 if num1 >= num2 else num2 print(compare5(34,789)) # 4.在匿名函数中，同样可以使用默认参数，关键字参数和不定长参数 f1 = lambda x,y = 0:x ** 2 + y ** 2 print(f1(2)) print(f1(2,3)) print(f1(x=2,y=3)) f2 = lambda *x:sum(x) print(f2(45,7,5,8,8)) # 5.应用：将列表按学生成绩从大到小排序 students = [ {'name': '小花', 'age': 19, 'score': 90, 'gender': '女', 'tel': '15300022839'}, {'name': '明明', 'age': 20, 'score': 40, 'gender': '男', 'tel': '15300022838'}, {'name': '华仔', 'age': 18, 'score': 90, 'gender': '女', 'tel': '15300022839'}, {'name': '静静', 'age': 16, 'score': 90, 'gender': '不明', 'tel': '15300022428'}, {'name': 'Tom', 'age': 17, 'score': 59, 'gender': '不明', 'tel': '15300022839'}, {'name': 'Bob', 'age': 18, 'score': 90, 'gender': '男', 'tel': '15300022839'} ] # sort的工作原理：将列表中的元素依次传参给key指定的函数，该函数的返回值就是排序的规则，返回值一定要支持关系运算符 # 方式一 def rule1(a): return a['score'] students.sort(key=rule1,reverse=True) # 方式二 students.sort(key=lambda subdict:subdict["score"],reverse=True) for stu in students: print(stu) list1 = [45,67,7,8] list1.sort() """ 【面试题】什么是匿名函数，说明优缺点 """
函数就是一个变量，可以重新赋值，可以作为函数的参数，也可以作为函数的返回值
# 1.函数就是一个变量，可以重新赋值 print(abs(-18)) # 函数的调用 print(abs) # 函数本身 r = abs(-17) # 注意1：函数其实就是一个变量，函数名其实就是一个变量名，所以，将一个函数赋值给另一个变量，则该变量可以被当做函数调用 f = abs print(r) print(f) print(f(-13)) # 2.一个函数可以作为另一个函数的参数 def func(x,y,f): return f(x) + f(y) r = func(45,6,abs) # 传递系统函数 print(r) def test(n): return n ** 2 r = func(3,4,test) # 传递系统函数 print(r) # 注意2：一个函数可以作为另一个函数的参数使用，传参的时候，只需要传递函数名即可,表示将函数本地传递进去 # 3.一个函数也可以作为另一个函数的返回值 def t1(): return "abc" r1 = t1() print(r1) def t2(f): f() return f r2 = t2(t1) # f = t1 r2 = f r2 = t1 print(r2) print(r2()) # 注意3：一个函数可以作为另一个函数的返回值使用，只需要使用函数名即可
