从零开始学习python 7（持续更新ing）

一、Python函数

1.1 函数的定义

函数的定义：实现【特定功能】的代码块。

函数的作用：

• 1. 简化代码
  2. 提高代码重用性
  3. 便于维护和修改
  4. 提高代码的可扩展性

函数的三要素：

• 1. 功能 len() max() sum()
  2. 参数 s.clear() s.append('华清远见')
  3. 返回值 s.sort() s1 = sorted(s)

函数定义的语法格式：

 

函数的分类：

• 1. 从定义角度—— 内置函数【别人写好的，你直接用】 自定义函数
  2. 从参数角度——无参函数 有参函数
  3. 从返回值角度——无返函数 None 有返函数

函数的调用/使用：

• 1. 无返函数 函数名()
  2. 有返函数 方法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']= 160for 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 = 0for i in num:my_sum += ireturn my_sumret = fun(3,7,2,9,8)
print(ret, type(ret))

def fun1(*num):my_sum = 0even_sum = 0odd_sum = 0for i in num:my_sum += iif i%2==0:even_sum += ielse:odd_sum += ireturn my_sum, even_sum, odd_sumres = 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=0for i in a:count +=1print(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=iif i<min:min=ireturn 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 = 0for i in range(1, 101):sum += ireturn sum
# 测试函数
print(fun8())

 

（9）定义函数，参数为关键字可变长参数，请计算并返回他们的平均身高， 使用(xiaoming='178cm',xiaobai='182cm',xiaohong='166cm',xiaohei='174cm')

def fun7(**kwargs):total_cm = 0for 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 -= 1if(N==0):breakfun(10)# 要求定义一个递归函数，实现输出N遍"我爱python"
def rec(N:int):if N==0:returnelse: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 1else:return n * rec(n-1)n = 5
print(rec(n))

 递归函数练习题

（1）求第6个斐波那契数

def fib(n):if n == 1 or n == 2:return 1else:return fib(n - 1) + fib(n - 2)
print(fib(6))

 

（2）使用递归函数求5的阶乘 

def fac(n):if n == 1:return 1else:return n * fac(n - 1)
print(fac(5))

 

 （3）使用递归函数求50-100的总和

def sum(n):if n == 50:return 50else:return n + sum(n - 1)
print(sum(100))

 

（4）已知有5个人坐在一起，第5个人说他比第四个人大5岁， 第4个人说他比第三个人也大5岁，以此类推，第一个人说他19岁， 请问，第五个人多少岁 

def age(n):if n == 1:return 19else:return age(n - 1) + 5
print(age(5))

 

（5）使用递归函数求n的k次方 

def power(n,k):if k == 1:return nelse:return n * power(n,k-1)
print(power(2,3))

 

（6）使用递归函数判断一个字符串是不是回文字符串 

def is_palindrome(s):if len(s) <= 1:return Trueelse:return s[0] == s[-1] and is_palindrome(s[1:-1])
print(is_palindrome("12345678987654321"))

 

1.5 函数中变量的作用域 

变量的作用域：是指变量能起作用的范围，根据作用范围大小不同分为全局变量和局部变量。

（1）全局变量：定义在函数外，作用范围是整个程序，程序结束时全局变量声明周期结束。

（2）局部变量：定义在函数代码块里或者函数的参数里，作用范围是整个函数，函数执行结束时局部变量生命周期结束。

 

quanju = 10def fun1():print(quanju)def fun2():print(quanju)# 全局变量都能用
print(quanju)
fun1()
fun2()

def fun1():a = 10print(a)def fun2():print(f"fun1函数中的{a}")# 局部变量只能在该函数内使用
fun1()
# fun2()  报错
# print(f"fun1函数中的{a}") 报错

def fun1():global aa = 10print(a)def fun2():print(f"fun1函数中的{a}")# 若想在函数外，使用该函数的局部变量，
# 使用global关键字将该变量修饰为全局变量
fun1()
fun2()
print(f"fun1函数中的{a}")

# 全局变量
a = 100def fun():# 局部变量a = 200print(a)print(a)    # 100
fun()       # 200# 从这里可以看到，局部变量可以和全局变量重名，但是
# 局部变量覆盖全局变量【遵循就近原则】

1.6 函数嵌套

函数嵌套：在一个函数的内部 还嵌套定义了 另外一个函数。

外部的我们称之为 外函数，内部的我们称之为 内函数。

 

x = 100
def out_fun():# global xx = 200def in_fun():# global xx = 300print(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 xx = 200def in_fun():# global xnonlocal xx = 300return xreturn in_fun()print(out_fun())
print(f"函数外输出{x}")