程序模块化-函数

函数的概念

函数主要解决什么样的问题呢？

主要解决那些具有 重复性的 、 独立功能性 的代码（没有规律性）

相当于积木，编写代码的过程就类似于搭积木的过程， “ 积木 ” 要具有自身的特点，单独存在的，封闭的

""" 计算1~100的和 """ 
sum = 0
for i in range(1,101): 
    sum = sum + i 
print(sum) 
""" 计算50~150的和 """ 
sum = 0
for i in range(50,151): 
    sum = sum + i 
print(sum) 
""" 计算100~120的和 """ 
sum = 0
for i in range(100,121): 
    sum = sum + i 
print(sum) 
//都是求从a~b和的问题 具体的操作流程基本一致，
结果可能会不同 
无非具体的参数a和b不一样而已 
该段代码可以看做是一个小功能代码 
所以对于上述这三部分大致相同的代码 
我们可以使用函数来解决代码冗余的问题

def getSum(a,b): 
    sum = 0
    for i in range(a, b + 1): 
        sum += i 
    return sum 
n1 = getSum(50,100) 
n2 = getSum(1,100) 
n3 = getSum(100,120)
print(n1) 
print(n2) 
print(n3)

函数出现的好处：

将重复性的具有独立功能性的代码进行封装，省去了一些冗余的代码，提高代码的重用率

函数是一个封装体，内部的具体内容不向外提供的，提高了数据安全性

函数使得我们的程序进行模块化了，看到代码分工更加明确、利于大篇幅代码的书写，调试修改和

完善

函数的具体语法定义
def 函数名(参数列表):
函数体
return 返回值

参数列表：给函数输入原材料进行加工

函数体：指的就是对原材料具体加工的步骤和过程

return ：单独出现的 return 仅仅表示操作完成函数执行完毕并结束

返回值：操作的结果，如果被 return 则返回给该函数的调用者

函数名：就是对该独立功能模块的一个命名

调用函数的话，只需要调用 函数名(具体传入的数据) 即可

def getSum(a,b): 
    sum = 0
    for i in range(a, b + 1): 
        sum += i 
    return sum 
n1 = getSum(50,100)

return 一般都会返回什么东西

什么都不返回（函数不一定要有返回值 但必须有 return 关键字存在）

def showA(a,b): 
    print(a + b) 
    return 
# 如果函数没有返回值的话 return是隐藏的 也可以直接写出来 
showA(10,20)

返回任意数据类型（返回的数据类型 取决于传入参数的类型 和 具体的操作流程）

def showB(a,b): 
    c = a + b 
    return c 
r1 = showB(1,2) 
print(r1)
print(type(r1)) 
r1 = showB(3.14,1.28) 
print(r1) 
print(type(r1)) 
r1 = showB("Hello","你好") 
print(r1) 
print(type(r1)) 
结果： 
3
<class 'int'> 
4.42 
<class 'float'> 
Hello你好 
<class 'str'> 
r1 = showB("Hello",10) 
print(r1) 
print(type(r1)) 
结果： 
Traceback (most recent call last): 
    File "MethodDemo01.py", line 62, in <module> 
r1 = showB("Hello",10) 
File "MethodDemo01.py", line 48, in showB 
c = a + b 
TypeError: can only concatenate str (not "int") to str

返回多个值

def showC(): 
    return 1, 2, 3.14, "Hello" 
r1,r2,r3,r4 = showC() 
print(r1) 
print(type(r1)) 
print(r2) 
print(type(r2)) 
print(r3) 
print(type(r3)) 
print(r4) 
print(type(r4)) 
结果： 1
<class 'int'>
2
<class 'int'> 
3.14 
<class 'float'> 
Hello 
<class 'str'>

返回函数甚至是自身

def showD(a,b): 
    print(a + b) 
    return showD 
# 返回的是showD这个函数的对象 
r1 = showD(1,3) 
# r1就相当于是showD函数
print(r1) 
print(type(r1)) 
r1(3,4) 
结果： 
4
<function showD at 0x00000149C34F55E8> 
<class 'function'> 
7
def showD(a,b): 
    print(a + b) 
    return max 
# 返回内置函数max的函数对象 
r1 = showD(1,3) 
# r1就相当于是max函数 
print(r1) 
print(type(r1)) 
print(r1(3,4)) 
还有一种特殊的情况——递归 
def showE(): 
    print("This is showE") 
    return showE() showE() 
结果： This is showE This is showE This is showE This is showE........

函数的在内存运行流程

每一个函数模块，在内存中是作为一个函数帧，函数帧之间的运行是在栈内存中的，栈是一个先进后出

的存储空间，如果函数帧 A 先进栈，当前函数栈 A 为当前栈顶元素，则按照函数的内容依次去执行，如果

在执行的过程中又调用到了别的函数帧 B ，此时函数帧 A 暂停运行，函数帧 B 进栈称为新的栈顶元素，函

数帧 B 按照函数的内容依次去执行，每一个函数中的参数我们都称之为形式参数，在调用函数时传给函

数的参数我们叫做实际参数，形式参数其实就是在函数帧当中创建的一个变量（局部变量）而已，传递

参数的过程其实就是在传递数据对象的地址！