一、Python函数
1.1 函数的定义
函数的定义：实现【特定功能】的代码块。
函数的作用：
-
- 简化代码
- 提高代码重用性
- 便于维护和修改
- 提高代码的可扩展性
函数的三要素：
-
- 功能 len() max() sum()
- 参数 s.clear() s.append('华清远见')
- 返回值 s.sort() s1 = sorted(s)
函数定义的语法格式：
函数的分类：
-
- 从定义角度—— 内置函数【别人写好的，你直接用】 自定义函数
- 从参数角度——无参函数 有参函数
- 从返回值角度——无返函数 None 有返函数
函数的调用/使用：
-
- 无返函数 函数名()
- 有返函数 方法1：print(函数名())
方法2：变量名 = 函数名()
def my_fun():
print("这是我的函数")
print(my_fun)
# 输出结果是 <function my_fun at 0x000002AA6DF7A3E0>
# 说明函数名是一个内存地址
# 无返函数直接调用
my_fun()
def you_fun():
return 100
# 有返函数，输出调用
print(you_fun())
# 有返函数，使用变量接收调用
ret = you_fun()
print(ret)1.2 函数的参数传递
函数在进行参数传递的时候，分为：位置参数、关键字参数、默认参数、位置不定长参数、关键字不定长参数。
位置参数：传递参数时应该 和 定义时的参数 保持位置和数量一 一对应。
def fun(a, b, c):
print(a, b, c)
# fun()
# TypeError: fun() missing 3 required positional arguments: 'a', 'b', and 'c'
fun(1, 2, 3)
#运行结果 1 2 3
fun('张三', 18, '男')
#运行结果 张三 18 男
fun([1,2,3], (4,5,6), {7,8,9})
# 运行结果 [1, 2, 3] (4, 5, 6) {8, 9, 7}def fun(a:int, b:float, c:str):
print(a, b, c)
# 有警告，无报错，以实际传参为准
fun(1, 2, 3)
fun(3.15, 7, [1,2,3])关键字参数：调用函数传递参数时，按照 参数名=值 的方式，传参的顺序可以和定义参数的顺序不一致。
def fun(name, age, sex):
print(name, age, sex)
# 关键字参数
fun(name='张三', age=18, sex='男')
fun(age=18, sex='男', name='张三')默认参数：在函数定义时给参数设置默认值，那么在函数调用时，若不传参就是用默认值，若传参就是用传参的值。
def fun(name='张三', age=18, sex='男'):
print(name, age, sex)
# 默认参数
fun()
fun('李四')
fun(age=66)
fun('小明', 30)
fun('小华', 23, '女')位置不定长参数：在定义函数时参数名前加 * ，也就是def fun( *args )，那么在传参的时候就可以传若干个位置参数。将参数打包成——元组。
def fun(*num):
print(num)
fun(1)
fun(1,2)
fun(1,2,3,4,5,6)
# 问：在一个函数中，位置不定长参数，可以有两个吗？
# 不允许
# 再问：一旦定义了位置不定参参数，是不是就不可以定义其他参数了呢？
# 答：可以定义，但是传参时必须是关键字参数
def test(*num, a, b):
print(num)
print(a)
print(b)
test(1,2,3,4,a=5,b=6)
def test1(a, b, *num):
print(a)
print(b)
print(num)
test1(1, 2, 3,4,5,6,7)
def test2(a, *num, b):
print(a)
print(num)
print(b)
test2(1, 2,3,4,5, b=66)关键字不定长参数：在定义函数参数名前加 ** ，也就是 def fun( **kwargs )，那么传参的时候就可以传若干个 关键字参数。
将参数打包成——字典。
def fun(**kwargs):
print(kwargs)
fun(a=12, b=13, c=15)
fun(姓名='张三', 年龄=18, 性别='男')形参：函数定义时的参数，没有实际意义
def fun(a)
def fun(a:int)
def fun(*a)
def fun(**a)
实参：函数调用/使用时的参数，有实际意义
fun(1, 'a', 13.14, True, [1,2], (3,4), {1,2})
fun( len(s) )
练习题： （1）定义函数，参数为位置可变长参数， 请将传入的所有实参按照升序输出
def fun(*num):
return sorted(num)
print(fun(5,4,7,8,9,1,2,3,0))
（2）定义函数，参数为关键字可变长参数，请将其中HuaHua的身高修改为160， 然后打印出所有身高不足180的姓名， 使用fun(XiaoMing=155,XiaoHong=171,XiaoHei=192,HuaHua=2333)调用测试
def fun(**name):
name['HuaHua']= 160
for i in name:
if name[i] < 180:
print(i,end=' ')
fun(XiaoMing=155,XiaoHong=171,XiaoHei=192,HuaHua=2333)
1.3 函数的返回值
（1）如果函数的运行结果想在函数外使用，就需要设置返回值。
（2）使用关键字 return 进行返回。
（3）return 可以在函数中出现多次，但是只执行 1 次，遇见return返回值并结束函数。
（4）与C语言不同，python中的return可以返回一个值或多个值，这个时候将返回的多个值到打包成一个元组。
ef fun(*num):
my_sum = 0
for i in num:
my_sum += i
return my_sum
ret = fun(3,7,2,9,8)
print(ret, type(ret))def fun1(*num):
my_sum = 0
even_sum = 0
odd_sum = 0
for i in num:
my_sum += i
if i%2==0:
even_sum += i
else:
odd_sum += i
return my_sum, even_sum, odd_sum
res = fun1(2, 8, 7, 3, 11, 10)
print(res, type(res))
a, b, c = fun1(2, 8, 7, 3, 11, 10)
print(a, b, c)简单函数练习题
（1）定义函数，无参无返，可求出200以内所有包含7的数字
def fun():
for i in range(0,200):
if '7' in str(i):
print(i,end=' ')
fun()
print()
（2）定义函数，无参有返，可返回200-300所有偶数组成的数列
def fun1():
list1=[]
for i in range(200,300,2):
list1.append(i)
return list1
print(fun1())
（3）定义函数，有参无返，可接收任意一个字符串，并计算该字符串有几个字符
def fun(a):
count=0
for i in a:
count +=1
print(count)
fun("abcd")
（4）定义函数，有参有返，可接收任意一个字符串，对其进行去重，返回去重后的集合
def fun1(a):
list1=[]
for i in a:
if i not in list1:
list1.append(i)
return list1
print(fun1("abcddcs"))
（5）定义函数, 可输入一个字符串，并打印出其中的所有数字
def fun5():
a=input()
for i in a:
if i.isdigit():
print(i,end=" ")
fun5()
（6）定义函数，可接收一个数字列表，并返回其中的最大值和最小值， 要求：不可以在自定义函数内调用max和min函数
def fun(list):
max=list[0]
min=list[0]
for i in list:
if i>max:
max=i
if i<min:
min=i
return max,min
a,b=fun([1,2,3,4,5,6,7,8,9,10])
print(a,b)
（7）定义函数，可打印三行四列矩形
def fun7():
for i in range(3):
for j in range(4):
print('*', end='')
print()
# 测试函数
fun7()
（8）定义函数，计算1-100的所有数字的和
def fun8():
sum = 0
for i in range(1, 101):
sum += i
return sum
# 测试函数
print(fun8())
（9）定义函数，参数为关键字可变长参数，请计算并返回他们的平均身高， 使用(xiaoming='178cm',xiaobai='182cm',xiaohong='166cm',xiaohei='174cm')
def fun7(**kwargs):
total_cm = 0
for height in kwargs.values():
total_cm += int(height.replace('cm', ''))
average_cm = total_cm / len(kwargs)
return average_cm
# 测试函数
res=fun7(xiaoming='178cm', xiaobai='182cm', xiaohong='166cm', xiaohei='174cm')
print(f"平均身高是：{res}cm")
1.4 递归函数
问：一个函数的调用放在哪里？——函数外
问：能在一个函数里面调用这个函数本身吗？——可以，但是会出现"死递归"，类似于"死循环"
问：函数自己调用自己，有几种形式呢？
直接调用 A 调用 A
间接调用 A 调用 B ， B 调用 A
观察：函数调用的执行顺序
函数自己调用自己的时候，若不添加控制条件，会一直调用。
所谓的递归函数就是自己调用自己的函数。
递归的思想：把一个大规模问题分解成相似的小规模问题，再将小规模问题分解成相似的小小规模问题……。
# 要求定义一个函数，实现输出N遍"我爱python"
def fun(N:int):
while True:
print("我爱python")
N -= 1
if(N==0):
break
fun(10)
# 要求定义一个递归函数，实现输出N遍"我爱python"
def rec(N:int):
if N==0:
return
else:
print(f"{N}我爱python")
rec(N-1)
rec(10)
对比发现：循环和递归很相似，基本上他们两个可以相互转换。
（1）大多数情况下，循环的效率、性能更好一些
（2）循环代码容易书写，阅读性差
（3）递归代码写起来稍难，阅读性好
递归函数有三要素：
（1）边界条件/基线条件 跳出/结束递归的条件
（2）递归返回段 满足结束条件时，返回
（3）递归前进段 不满足结束条件时，前进/继续递归
# 定义一个递归函数，求n的阶乘
# 阶乘：就是累乘，从1累乘到本身 或者从本身累乘到1
# 5! = 1*2*3*4*5 = 5*4*3*2*1
def rec(n):
"""
求一个数n的阶乘
:param n: 接收到一个整型值
:return: 计算的阶乘结果
"""
if n==1:
return 1
else:
return n * rec(n-1)
n = 5
print(rec(n))递归函数练习题
（1）求第6个斐波那契数
def fib(n):
if n == 1 or n == 2:
return 1
else:
return fib(n - 1) + fib(n - 2)
print(fib(6))
（2）使用递归函数求5的阶乘
def fac(n):
if n == 1:
return 1
else:
return n * fac(n - 1)
print(fac(5))
（3）使用递归函数求50-100的总和
def sum(n):
if n == 50:
return 50
else:
return n + sum(n - 1)
print(sum(100))
（4）已知有5个人坐在一起，第5个人说他比第四个人大5岁， 第4个人说他比第三个人也大5岁，以此类推，第一个人说他19岁， 请问，第五个人多少岁
def age(n):
if n == 1:
return 19
else:
return age(n - 1) + 5
print(age(5))
（5）使用递归函数求n的k次方
def power(n,k):
if k == 1:
return n
else:
return n * power(n,k-1)
print(power(2,3))
（6）使用递归函数判断一个字符串是不是回文字符串
def is_palindrome(s):
if len(s) <= 1:
return True
else:
return s[0] == s[-1] and is_palindrome(s[1:-1])
print(is_palindrome("12345678987654321"))
1.5 函数中变量的作用域
变量的作用域：是指变量能起作用的范围，根据作用范围大小不同分为全局变量和局部变量。
（1）全局变量：定义在函数外，作用范围是整个程序，程序结束时全局变量声明周期结束。
（2）局部变量：定义在函数代码块里或者函数的参数里，作用范围是整个函数，函数执行结束时局部变量生命周期结束。
quanju = 10
def fun1():
print(quanju)
def fun2():
print(quanju)
# 全局变量都能用
print(quanju)
fun1()
fun2()def fun1():
a = 10
print(a)
def fun2():
print(f"fun1函数中的{a}")
# 局部变量只能在该函数内使用
fun1()
# fun2() 报错
# print(f"fun1函数中的{a}") 报错def fun1():
global a
a = 10
print(a)
def fun2():
print(f"fun1函数中的{a}")
# 若想在函数外，使用该函数的局部变量，
# 使用global关键字将该变量修饰为全局变量
fun1()
fun2()
print(f"fun1函数中的{a}")# 全局变量
a = 100
def fun():
# 局部变量
a = 200
print(a)
print(a) # 100
fun() # 200
# 从这里可以看到，局部变量可以和全局变量重名，但是
# 局部变量覆盖全局变量【遵循就近原则】1.6 函数嵌套
函数嵌套：在一个函数的内部 还嵌套定义了 另外一个函数。
外部的我们称之为 外函数，内部的我们称之为 内函数。
x = 100
def out_fun():
# global x
x = 200
def in_fun():
# global x
x = 300
print(f"内函数中输出{x}")
in_fun()
print(f"外函数中输出{x}")
out_fun()
print(f"函数外输出{x}")
运行结果： 【和C语言是有区别的，可以通过绑定关键字global修改】
内函数中输出300
外函数中输出200
函数外输出100
通过上面的例子可以发现：
内函数局部变量 > 外函数局部变量 > 全局变量
对比global 和 nonlocal：
① global 修饰全局变量
② nonlocal 修饰该函数上一层的局部变量1.7 闭包函数
什么是闭包函数？——如果内函数中使用了外函数的局部变量，并且外函数把内函数返回的过程就叫闭包。
形成闭包的条件：
（1）函数嵌套
（2）将内函数作为返回值返回
（3）内函数必须使用外函数的局部变量
x = 100
def out_fun():
# global x
x = 200
def in_fun():
# global x
nonlocal x
x = 300
return x
return in_fun()
print(out_fun())
print(f"函数外输出{x}")
