零基础小白 Python这样学就对啦！——06篇

一、Python函数

1.0 函数的引入

# 素数——就是质数，只能被1和它本身整除 
# 1、从键盘输入一个数值num，判断是不是素数/质数 
num = 13 
for i in range(2, num): 
    if num%i==0: 
        print("不是素数") 
        break 
    else: 
        print("是素数") 
# 2、输出100-200之间所有的素数 
for num in range(100, 200+1): 
    for i in range(2, num): 
        if num % i == 0: 
            break 
    else: 
        print(num) 
# 3、从键盘输入起始值a 终止值b，输出a到b之间所有的素数之和 
# 发现问题： 
# 在上面的三个代码中，不管是判断一个数是素数、还是输出区间内的所有素数、还是计算区间内所有素数之和， 
# 有一部分代码是重复的————判断素数的代码。 
# 解决问题： 
# 将这一部分重复的代码——判断素数功能的，封装成【函数】。 
# 需要的时候，就调用这个函数。 
# 一次封装，实现多次调用/使用，减少代码量、提高执行效率

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(函数名())
3. 方法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 函数参数与返回值

实参

函数调用/使用时的参数，有实际意义

fun(1, 'a', 13.14, True, [1,2], (3,4), {1,2})

fun( len(s) )

位置实参：按照顺序传递实参，与形参一一对应。

关键字实参：使用形参名=实参值的方式传递，无需关注顺序。

默认值参数：在函数定义时，为形参指定默认值，调用时可选择是否传递该实参。

任意数量实参：使用*args传递任意数量的位置实参，使用**kwargs传递任意数量的关键字实参

形参

函数定义时的参数，没有实际意义

def fun(a)

def fun(a:int)

def fun(*a)

def fun(**a)

返回值

使用return关键字返回函数结果。

可以返回简单值、列表、字典等复杂数据类型。

函数可以有多个返回值，使用逗号分隔。

练习题：

（1）定义函数，参数为位置可变长参数， 请将传入的所有实参按照升序输出

（2）定义函数，参数为关键字可变长参数，请将其中HuaHua的身高修改为160， 然后打印出所有身高不足180的姓名， 使用fun(XiaoMing=155,XiaoHong=171,XiaoHei=192,HuaHua=2333)调用测试

1.3 函数的返回值

1. 如果函数的运行结果想在函数外使用，就需要设置返回值。
2. 使用关键字 return 进行返回。
3. return 可以在函数中出现多次，但是只执行 1 次，遇见return返回值并结束函数。
4. 与C语言不同，python中的return可以返回一个值或多个值，这个时候将返回的多个值到打包成一个元组。

def 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的数字（5分）

（2）定义函数，无参有返，可返回200-300所有偶数组成的数列（5分）

（3）定义函数，有参无返，可接收任意一个字符串，并计算该字符串有几个字符（5分）

（4）定义函数，有参有返，可接收任意一个字符串，对其进行去重，返回去重后的集合（5分） （5）定义函数, 可输入一个字符串，并打印出其中的所有数字（5分）

（6）定义函数，可接收一个数字列表，并返回其中的最大值和最小值， 要求：不可以在自定义函数内调用max和min函数（5分）

（7）定义函数，可打印三行四列矩形（5分）

（8）定义函数，计算1-100的所有数字的和（5分）

（9）定义函数，可打印9行9列的等腰直角三角形（5分）

（10）定义函数，参数为非关键字可变长参数，请将传入的所有实参按照降序输出

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

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. 递归前进段 不满足结束条件时，前进/继续递归

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. 内函数必须使用外函数的局部变量

1.8 匿名函数lambda的使用

高阶函数 map 和 reduce

（1）有一个列表n=[1,2,3,4,5,6,7,8,9], 请使用匿名函数输出[10,20,30,40,50,60,70,80,90] （2）使用匿名函数做出递归效果，求50-100的累加和 （3）使用匿名函数做出递归效果，求5的阶乘 （4）使用匿名函数求杨辉三角中第x行第y列的的数字，使用（6，3）调用测试

1.9 属性常用的内置函数

1. 内置函数

1. 数学函数

1. 迭代器操作函数

1. 常用的其他内置函数

（一）编写函数fun1: 模拟轮盘抽奖游戏 轮盘分为三部分: 一等奖, 二等奖和三等奖; 轮盘转的时候是随机的, 如果范围在[0,0.08)之间,代表一等奖, 如果范围在[0.08,0.3)之间,代表 2 等奖, 如果范围在[0.3, 1.0)之间,代表 3 等奖, 模拟本次活动 1000 人参加, 模拟游戏时需要准备各等级奖品的个数. 要求：

1. 函数是无参有返回值的

2. If 选择结构的使用

3、随机库的应用

4、最后将各个奖项和对应奖项的人数存到字典里

（二）编写函数 fun2：打印出所有的"水仙花数"， 所谓"水仙花数"是指一个三位 数，其各位数字立方和等于该数本身。 1. 用代码实现水仙花数，并打印 2．将所有的水仙花数存在列表中，并打印

（三）编写函数 fun3：判断 101-200 之间有多少个素数，并输出所有素数。 1. 求素数的逻辑正确，并能正确实现 2. 将所有素数存到集合中，并打印

（四）构建一个函数 fun4，参数关键字可变长参数，调用时用变量赋值传参方式。 如果 teacher 为‘Join’，则输出年龄 year， 如果 teacher 为其他，则输出学校 acad。 分别调用两次 (teacher=“Ｍike”，sex＝‘男’，year=22, acad＝“北京大学”)， (teacher=“Join”，sex＝‘女’，year=25, acad＝“清华大学”) 要求：

1） 函数的参数是关键字可变长参数的 

2） 键和值分开遍历

3） 根据字典的键去找值

4） 输出结果正确

5） 分别调用并打印结果

作者：一念之坤