找往期文章包括但不限于本期文章中不懂的知识点：
个人主页：我要学编程(ಥ_ಥ)-CSDN博客
所属专栏： Python
目录
函数的定义及调用
函数的概念
函数是将一段实现功能的完整代码，使用函数名称进行封装，通过函数名称进行调用。以此达到一次编写，多次调用的目的。
函数分为两种：一种是Python的开发人员将带有某些特殊功能的代码封装成函数，这也叫内置函数；另一种是咱们在写代码的时候，自己定义的函数来实现某种功能，这也叫自定义函数。
常见的内置函数：Input、print、eval、math...
函数的定义
语法：
def 函数名(参数列表): # 函数名要符合定义标识符的规范
// 函数体
... // 函数的功能
[return 返回值列表] // []内的内容可有可无代码演示：
# 对1-100进行求和
def get_sum():
sum = 0
for i in range(1, 101):
sum += i
i += 1
return sum
def get_sum2():
sum = 0
i = 1
while i <= 100:
sum += i
i += 1
return sum注意：我们自定义的函数并不是直接就可以运行的，要在定义函数的外面去调用它才行。
函数的调用
函数的调用就只需要在 定义函数的外面，去写上该函数的函数名+参数列表即可。
语法：
# 当函数没有参数时，我们也不需要去传参
函数名([参数1, 参数2, ...])代码演示：
print(f'1-100的和为: {get_sum()}')
print('1-100的和为: {0}'.format(get_sum2()))运行结果：
水仙花数等自幂数的练习
有了上述知识，我们可以来写一个稍微复杂一点的函数：
要求：求出所有的水仙花数。
水仙花数：是指一个 3 位数，它的每个数位上的数字的 3次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153。
代码实现：
# 定义一个函数计算水仙花数
def get_water_flower():
lst = []
for i in range(100, 1000): # 三位数
# 拿出每一位：注意使用整数除法：//
a = i % 10 # 个位
b = i // 10 % 10 # 十位
c = i // 100 # 百位
if a**3 + b**3 + c**3 == i:
lst.append(i)
return lst
print(f'水仙花数为: {get_water_flower()}')当然如果想要拓展的话，可以在原函数的基础上进行传参，从而求出更多的自幂数。
代码实现：
def get_water_flower2(num):
lst = []
# 计算出num的位数
count = 0
while num > 0:
count += 1
num //= 10
# 根据位数计算出1-对应位数的自幂数
for i in range(10 ** count): # 1-10^count
# 拿出每一位：注意使用整数除法：//
# 这里不是三位就不能直接使用 // % 的方式了
# 并且上述方式也比较low，可以换一种写法
# 先求出i的位数
j = i
size = 0
while j > 0:
size += 1
j //= 10
# 循环 size 次进行对应位数的求和
sum = 0
countOfValue = size
j = i
while countOfValue > 0:
sum += (j % 10) ** size
countOfValue -= 1
j //= 10
# 判断是否为自幂数
if sum == i:
lst.append(i)
return lst
try:
num = int(input('请输入待求的自幂数范围：'))
if num < 0:
raise Exception('请输入合法的整数，再重试！')
print(f'{num}范围内的自幂数为: {get_water_flower2(num)}')
except ValueError as e:
print('请输入整数，再重试!')
except Exception as e:
print(e)运行结果：
函数相关参数的概念
注意：在Python中，有下面这几个关于参数的概念：
1、形式参数：定义函数时参数列表中的参数，简称：形参；
2、实际参数：在调用函数时，所传输的真实参数，简称：实参；
3、位置参数：调用函数时的参数个数与顺序必须与定义的参数个数和顺序一致；
例如：
def send(form, to, string):
print(f'{form}给{to}发送了一条消息: {string}')
def happy_birthday(name, age):
print('祝'+name+'生日快乐')
print(str(age)+'岁生日快乐')
# 调用函数
# 下面的 true、false 是指结果对不对，而不是输出结果
send("I", "You", "I love you") # true
send("You", "I", "I love you") # true
happy_birthday("张三", 18) # true
# happy_birthday(18, "张三") # false
最后一行代码之所以报错，就是位置参数在作怪，我们传入的参数默认是对应传输的，即按照 name，age 的顺序，如果我们打乱了，就可能会导致代码报错，但是如果参数全部是 字符串类型的话，就不会报错，但是代码的逻辑会出错。 如果我们执意不按顺序传呢？要用到关键字参数。
4、关键字参数：是在函数调用时，使用 "形参名称=值" 的方式进行传参，传递参数顺序可以与定义时参数的顺序不同。因为这相当于是直接对形参赋予相应的值了。还要注意的是，当位置传参与关键字传参一起使用时，得遵循 "位置参数在前，关键字参数在后" 的原则。并且 使用关键字传参时，一定是赋值给形参，因此得写形参的名称，不能写别的。
5、默认值参数：是在函数定义时，直接对形式参数进行赋值，在调用时如果该参数不传值，将使用默认值，如果该参数传值，则使用传递的值。
代码演示：
def happy_birthday(name='张三', age=18):
print('祝'+name+'生日快乐')
print(str(age)+'岁生日快乐')
# 不传参数，使用默认值，给name与age赋值
happy_birthday() # true
# 传一个参数：使用位置参数
# 当只传入一个参数时，默认是将该参数赋值给最前面的形参
happy_birthday("李四") # true
# happy_birthday(20) # false
# 传一个参数：使用关键字传参
# 由于关键字参数指定了固定的形参，因此不存在顺序问题了
happy_birthday(name='李四') # true
happy_birthday(age=20) # true
# 传两个参数：使用位置参数
# 不能颠倒顺序
# happy_birthday(20, "李四") # false
# 传两个参数：使用关键字参数
# 同样指定了固定的形参，便不再要求顺序了
happy_birthday(age=20, name='李四') # true
happy_birthday(name='李四', age=20) # true既然传参时，有这些顾虑，那在定义函数时，是否也有这些顾虑呢？答案是有的。
代码演示：
# 普通参数
def fun1(a, b):
pass
# 默认值参数与普通参数混用
def fun2(a=18, b): # Error，这里会有错误
pass
def fun3(a, b=18):
pass
# 默认值参数
def fun4(a=18, b=20):
pass从上面的代码来看，我们可以得出一个结论：当普通形参与带有默认值的形参，一起使用时，默认值形参要放到后面，得让普通形参往前放。因为在赋值时，是按照从前到后的方式赋值的，如果前面已经有默认值的话，再赋值可能并不是我们想要的结果，我们可能只是想给普通形参赋值。
6、可变参数：又分为个数可变的位置参数和个数可变的关键字参数两种，其中个数可变的位置参数是在参数前加一颗星（*para），para形式参数的名称，函数调用时可接收任意个数的实际参数，并放到一个元组中。个数可变的关键字参数是在参数前加两颗星（**para），在函数调用时可接收任意多个“参数=值”形式的参数，并放到一个字典中。
位置参数：代码演示：
def fun(*args):
# args是一个元组
print(type(args))
for i in args:
print(i,end='\t')
fun(1,2,3,4,5)
fun('张三')
fun(['张三', 18, 180]) # 这是传了一个列表，作为一个位置参数
# 若想要序列将其中的元素作为参数传递，需要用到解包操作：*
fun(*['张三', 18, 180])运行结果：
关键字参数：代码演示：
def fun(**kwargs):
# kwargs是一个字典
print(type(kwargs))
for key, value in kwargs.items():
print(key, value, end='\t')
print()
fun(name='张三', age='18')
fun(name='李四')
d = {'张三':18, '李四':20, '王五':25}
# 一定要是关键字参数
# 下面这种写法，key为kwargs, value为d
fun(kwargs=d)
# 还可以解包操作：**
fun(**d) # 这就是把字典中的元素传了过去运行结果：
注意：只有和字典一样的表示形式，才可以使用可变参数中的关键字参数
函数的返回值
前面我们已经简单的学习了函数的定义，并且也为部分函数写了返回值，但是前面的返回值都是单个的返回值，现在我们来学习多变量返回值的实现。
代码演示：
def get_sum(num):
# 计算奇数和、偶数和、总和
sum = 0
odd_sum = 0
even_sum = 0
for i in range(1, num+1):
if i % 2 == 0: # 偶数
even_sum += i
else: # 奇数
odd_sum += i
# 总和
sum += i
return odd_sum, even_sum, sum
result = get_sum(10)
print(type(result)) # 元组类型
# 使用多变量赋值操作（解包）
a,b,c = result
print(a,b,c)运行结果：
变量的作用域
变量的作用域是指变量其作用的范围，根据范围作用的大小可分为局部变量 与 全局变量。
局部变量：在函数定义处的参数与函数内部定义的变量。作用的范围：仅仅在函数内部，函数执行结束，局部变量的生命周期也随之结束。
全局变量：在函数外部定义的变量或者函数内部使用 global 关键字修饰的变量。作用的范围：整个程序，当程序运行结束，全局变量的生命周期才结束。
生命周期：是指某个变量存活的范围内。例如，在函数内部定义的局部变量，其生命周期就是在该函数内部。
代码演示：
# 局部变量:函数的参数、函数内定义的变量
def fun(a):
b = 10
a = b
# print(a) # error
# print(b) # error# 全局变量：函数外定义+函数内定义时，使用global关键字声明
def fun2(a): # 参数不能使用global声明
global b # 不能在声明时，去赋值
b = 100
c = 200
fun2(1) # 在打印b的值之前得调用fun函数去初始化b的值才行
print(b) # 不能在别的函数中出现同名的变量
print(c)当全局变量与局部变量同名时，遵循局部变量优先的原则，即 地头蛇原则：当两个变量同名时，且被调用时，看谁定义的近，谁就其作用。
代码演示：
# 全局变量与局部变量同名，遵循局部变量优先
def fun():
a = 10
print(a)
a = 100
fun()运行结果：
注意：全局变量在函数内部直接访问是没问题，但是如果想要在函数内部实现修改的话，就需要在修改其的地方加上 global 关键字。如下所示：
修改后的代码：
i = 0
def fun1():
print(i) # 普通访问操作
def fun2():
# 声明这是一个全局变量（如果确实存在，就拿到所有权限；反之，则创建一个全局变量）
global i
i += 1 # 修改操作
print(i)
fun1()
fun2()
这里的 global 相当于 是让 全局变量，对这个函数开放其所有权限。
匿名函数：lambda
匿名函数，是指没有名字的函数，这种函数只能使用一次，一般是在函数的函数体只有一行代码且只有一个返回值时，可以使用匿名函数来简化。
语法：
# lambda 是一个关键字，表明后面是一个匿名函数
# result 是一个函数
# 将匿名函数赋值给了result，可以把result当成一个函数去调用
result = lambda 参数:函数体(执行的操作)代码演示：
# 使用普通的函数：
def fun(a, b):
return a+b
print(fun(1,2))
# 使用匿名函数：lambda
# a,b 是参数，a+b是函数体
result = lambda a,b:a+b
# result是一个函数，可以去调用它
print(result(1,2))
# 因为这里是将这个匿名函数赋值给了result
# result可以反复使用，但是匿名函数却只能使用一次
print(result(1,2))运行结果：
代码演示：
lst = [1,2,3,4,5]
for i in range(len(lst)):
print(lst[i],end='\t')
print()
# 使用匿名函数
for i in range(len(lst)):
# 参数是lst，函数体是print(lst[i])
result = lambda lst: print(lst[i],end=' ')
print(result(lst))运行结果：
注意：使用匿名函数时，lambda 会根据 函数体的具体实现来决定是否存在返回值。像，x+1这种函数体，这就是返回了 x+1，但是像，print(x)，这种函数体，就没有返回值（或者说为None）。
函数递归
函数递归是指，在调用函数体的过程中，出现了自己调用自己的情况。例如，下面这种情况：
i = 1
def fun():
global i # 声明这是一个全局变量（与上面的i相呼应）
print('这是第{0}次调用fun()函数'.format(i))
i += 1
fun() # 自己调用自己（外部fun调用内部fun）
fun()如果我们去尝试运行上面的代码的话，就会出现下面这种情况：
如果有学过别的编程语言的小伙伴，应该对这个不陌生。这是 "栈溢出"，因为函数每一次调用都需要创建与之对应的栈帧，用于存储当前函数的执行情况（变量的值，执行到哪里了等） ，这份空间是有限的，与内存一样，不可能无限使用。因此当函数调用过多时，就会发生栈溢出的情况。而内存不足，则是会使当前程序启动失败。（这些了解即可）
那怎么解决上述问题呢？只需要写出一个正确的递归函数，即需要一个递归的截止条件与递推公式。当函数递归到某个临界点时，不需要再递归了，而是可以直接回退了，这就是递归的截止条件；递推公式，则是需要我们自己去推测出来，后面有例子解释。
递归的两个经典案例：1、阶乘；2、斐波那契数列。
我们先来看阶乘的计算：5! = 5 * 4!，4! = 4 * 3! ... 1! = 1，这里的 1! = 1就是函数递归的截止条件，因为到这里已经无需计算了，而 5! = 5 * 4! 就是函数的递推公式，即 n! = n * (n-1)!。
代码实现：
# 阶乘的计算
def fac(n):
# 当 n == 1时，已经知道了其阶乘的值了，可以不用继续计算了
# 因此直接返回其值即可，而其余情况，则是 n! = n * (n-1)!
if n == 1:
return 1
return n*fac(n-1)
print(fac(5))我们可以推演一下上述的递归过程。
上图就是计算5的阶乘的全部过程了，大家也可以自己画图来理解递归的过程。
接着来学习 斐波那契数列，相信这个大家都不陌生，我们在数学中是学过这个的。是以兔子繁殖为例子而引入，故又称为“兔子数列"，指的是这样—个数列：1、1、2、3、5、8、13、21、34、……从第三项开始，每项都等于前两项之和，这里其实就已经给出了我们斐波那契数列的递推公式了：n <= 2，fib(n) = 1；n >= 3，fib(n) = fib(n-1) + fib(n-2)。
注意：可能有小伙伴见过是0、1、1、2、3、5 .... 这样的说法，这两者都算正确的，但是我们这里讨论的是 1、1 开头的。
代码实现：
# 斐波那契数列
def fib(n):
# 当 n==1 或者 n==2时，我们已经知道了值为1
# 因此直接返回即可，但 n是其他值时，我们需要递归计算
if n == 1 or n == 2:
return 1
return fib(n-1) + fib(n-2)
print(fib(10))这里的递推过程就不演示了，感兴趣的小伙伴可以自己去画图推演。
可能有小伙伴，对递归是在是学不明白，没关系，递归最终是为了计算出结果，而能用递归计算出来的结果，都是可以使用循环计算出来的。下面我们来对阶乘与斐波那契数列进行改版。
代码实现：
# 阶乘
def fac(n):
sum = 1 # 这里初始化的结果一定不能是0
for i in range(1, n+1):
sum *= i
return sum
print(fac(5))
# 斐波那契数列
# 因为当计算的斐波那契数超出2时，需要用到前面的斐波那契数
# 因此将全部的数都存储起来，易于计算
# 这也就是优化计算斐波那契数列的方法
def fib(n):
lst = [1,1]
if n == 1 or n == 2:
if n == 1:
return lst[0]
else:
return lst
# 循环计算
for i in range(2, n): # 这里的i是列表的索引，因此第三项的索引是2
# fib(i) = fib(i-1)+fib(i-2)
sum = (lst[i-1]+lst[i-2])
lst.append(sum)
return lst
print(fib(10))运行结果：
常用的内置函数
Python中常用的内置函数，根据功能分类有四种：数据类型转换函数、数学函数、迭代器操作函数、其他函数。
数据类型转换函数
| 函数名 | 描述 |
| bool(obj) | 获取指定对象obj的布尔值 |
| str(obj) | 将指定对象obj转为字符串类型 |
| int(x) | 将 x 转为 int 类型 |
| float(x) | 将 x 转为 float 类型 |
| list(seqence) | 将序列转成列表类型 |
| tuple(sequence) | 将序列转成元组类型 |
| set(sequence) | 将序列转成集合类型 |
上述的函数，我们在前面学习的时候，基本上都是用过的，这里就不再演示了。
注意：当字符串的字面值为浮点数时，不能转为 int 类型。int() 在针对 字符串 时，可以理解为只将字符串的引号去掉了，其余的就不管了，因此当字面值为浮点数时，就会转换失败。
数学函数
| 函数 | 说明 |
| abs(x) | 获取 x 的绝对值 |
| divmod() | 获取 x 与 y 的商和余数 |
| max(sequence) | 获取 sequence 的最大值 |
| min(sequence) | 获取 sequence 的最小值 |
| sum(iter) | 对可迭代对象进行求和运算 |
| pow(x，y) | 获取 x 的 y 次幂 |
| round(x，d) | 对 x 进行保留 d 位小数，结果是四舍五入 |
代码演示：
# 内置数学函数的使用
# 1、abs()：绝对值
print(abs(100), abs(-100), abs(0))
# 2、divmod()：商、模
# 10 // 3 => 3 10 % 3 => 1
print(divmod(10, 3))
# 3、max()：最大值
print(max([1,2,3,4,5]))
# 对于字符串的比较，就是比较首字母的最大值
# 对于在ASCII码值之内的，就是比较ASCII码值
# 对于不在ASCII码值的，就是比较Unicode编码
print(max(['hello', 'python', 'java', 'c']))
# 4、min()：最小值
print(min([1,2,3,4,5]))
print(min(['hello', 'python', 'java', 'c']))
# 5、sum()：求和
print(sum([1,2,3,4,5]))
print(sum((1,2,3,4,5)))
# 不能对除数字之外的进行sum
# print(sum('hello')) # error
# 6、pow()：x**y
print(pow(2,3))
# 7、round()：精确数值
print(round(3.1415926535, 2))
print(round(3.146, 2))
# 当第二个参数为不写时，默认为保留整数位：同样四舍五入
# 但如果写成0的话，就是在取整的基础上保留一位小数
print(round(3.146, 0))
print(round(3.6, 0))
print(round(3.146))
print(round(3.6))
# 当第二个参数为负数时，就是整数部分进行取舍操作
# -1 是指对个位进行四舍五入，且保留一位小数
print(round(314.15, -1))运行结果：
迭代器操作函数
| 函数 | 说明 |
| sorted(iter) | 对可迭代对象进行排序 |
| reversed(sequence) | 反转序列生成新的迭代器对象 |
| zip(iter1，iter2) | 将iter1与iter2打包成元组并返回一个可迭代的zip对象 |
| enumerate(iter) | 根据iter对象创建一个enumerate对象 |
| all(iter) | 判断可迭代对象iter中所有元素的布尔值是否都为True。如果都为True，则返回True；反之，则返回False |
| any(iter) | 判断可迭代对象iter中所有元素的布尔值是否都为False。如果都为False，则返回False；反之，则返回True |
| next(iter) | 获取迭代器的下一个元素 |
| filter(function,iter) | 通过函数function过滤序列并返回一个迭代器对象 |
| map(function,iter) | 通过函数function对可迭代对象iter的操作返回一个迭代器对象 |
代码演示：
lst1 = [10,2,30,4,50]
lst2 = [1,20,3,40,5]
# sorted()
# 是在新的可迭代对象的基础上排序的，不会影响原来的对象
new_lst1 = sorted(lst1)
print('对lst1进行升序排序：',new_lst1)
new_lst2 = sorted(lst2,reverse=True) # 升序完后转置就变成了降序
print('对lst2进行升序排序：',new_lst2)
# reversed()
# 对序列反转，并生成新的迭代器对象
new_lst1 = reversed(lst1)
# 需要将迭代器对象转换才行
print(list(new_lst1))
# zip()
# 将参数组成元组并返回zip对象
# 参数谁的长度短，以谁为基准
obj_zip = zip(lst1, lst2)
# 同样需要转换
print(list(obj_zip))
# enumerate()
# 根据参数生成一个enumerate对象
# 也是一个元组，默认初始值从0开始（可设置）
obj_enum = enumerate(lst1)
print(list(obj_enum))
# all()
lst3 = [1,2,'']
# 元素的布尔值都为True时，返回True；有False，返回False
print(all(lst3))
# any()
# 元素的布尔值都为False时，返回False；有True，返回True
print(any(lst3))
# next()
# 生成一个迭代器对象
obj_iter = iter(lst2)
# 在配合while循环遍历
while True:
try:
# 打印迭代器中的值，当迭代器中没有值时，就会报错
print(next(obj_iter), end=' ')
except StopIteration:
print()
break # 没有值了，就停止循环
# filter()
def fun(n):
return n%2 == 1
# 对lst2中的元素进行fun处理，满足条件的添加到迭代器中
# 即 lst2中所有满足 使fun函数返回True的元素，组成一个迭代器对象
# 再将迭代器对象转为列表
print(list(filter(fun, lst2)))
# map()
lst4 = ['hello', 'python', 'java', 'c']
def upper(s):
return s.upper()
# 将lst4中的元素进行upper处理，将处理后的结果放到迭代器对象中
# 再将迭代器对象转换为列表
print(list(map(upper, lst4)))运行结果：
注意：
1、filter 函数 与 map 函数 的第一个参数都是 函数名，这里只需要写函数名，而不需要在后面加上()，加上() 属于调用函数了，不符合要求。
2、可能有小伙伴对最后map的地方有疑惑。有两个 upper ，map是怎么判断使用哪个呢？其实这里涉及到我们后面将要学习的类与对象的知识。我们自己定义的upper 是属于函数的范畴，但是 s.upper 这是属于方法的范畴，虽然两者干的事差不多，但是两者的含义不同。
方法是依附于类而存在的，我们使用方法要么是通过类是调用，要么是通过类的实例去调用。而函数就不一样了，其不依赖于谁，直接使用即可，只需要传参。
upper(s) —> 这是一个函数，调用只需传参。 s.upper() —> 这是一个方法，调用需要通过实例（这里将s理解为实例）。这里不理解没关系，后面我们会学到的。
其他函数
其他函数是指这些函数不属于上述分类中的函数。常用的有下面这几种：
| 函数 | 说明 |
| format(value，format_spec) | 将value以format_spec格式进行显示 |
| len(s) | 获取s的长度或者s元素的个数 |
| id(obj) | 获取对象的内存地址 |
| type(x) | 获取x的数据类型 |
| eval(s) | 取出s字符串所对应的字面值 |
上面的函数除了 format 与 id 之外，其余的都在前面的学习过程中，接触并且使用过，因此这里就不再赘述了。 这里的format函数是对 字符串的format方法的一个补充扩展，为了更好的格式化数据，前面在学习字符串时，format方法只能针对字符串其效果，而这里的format函数是可以对任意数据其作用的。下面这是简单演示一下，具体请看字符串章节。
代码演示：
# format()：可以和格式化字符串一样，格式化这些数据
# 对数值型数据进行格式化时，默认是右对齐
# 同样超出格式长度，就不再进行格式了
print(format(3.14,'20'))
# 对字符串数据进行格式化时，默认是左对齐
print(format('hello python', '20'))
# id()
# 对象在内存中的地址是固定的
print(id(10))
print(id(10))
print(id('python'))
print(id('python'))运行结果：
课后练习（实战四）
要求：编写函数实现操作符in的功能。使用input()从键盘获取一个字符串，判断这个字符串在列表中是否存在（函数体不能使用in），返回结果为True或False。
注意：整个函数中不能出现in操作符。
思路：判断字符串是否在列表中存在，肯定是需要去遍历列表的，但是由于不能使用 in 操作符，因此这里就需要用到 while循环。
代码实现：
lst = ['hello', 'python', 'java', 'c']
def fun(x):
i = 0
while True:
try:
if lst[i] == x: # 找到了，返回
return '存在'
i += 1
except Exception: # 说明找不到
return '不存在'
s = input('请输入您要判断的字符串：')
print(fun(s))好啦！ 本期 初始Python篇（9）—— 函数 的学习之旅就到此结束啦！我们下一期再一起学习吧！