Python中用函数实现代码的复用

阅读原文时间：2023年07月09日阅读：1

# Python中用函数实现代码复用
"""
def funcname(paras):
statements
return [expression]

关于函数定义说明如下：
函数定义以def关键字开头，后接函数名称和圆括号（）
paras是函数的参数，放在函数名后面圆括号（）内，参数之间用逗号分隔
statemengts是函数体，函数体的前部可以选择性的使用字符串，用于说明函数功能
函数声明以冒号结束，函数体内需要缩进
return语句用于结束函数，将返回值传递给调用语句。不带表达式的return返回None值

说明：
如果函数的参数是多个，默认情况下，函数调用时，传入的参数和函数定义时参数定义的顺序是一致的,调用必须在定义之后

执行help(函数名)命令，将显示函数的说明信息
"""

def hello():
print("Hello Python")

def getarea(x, y):
'''
参数为两个数值数据，或者一个字符串和一个整数
'''
return x * y

hello()
print(help(getarea))
print(getarea(2, 3))

def getcirclearea(r):
'''
参数为数值数据（圆的半径）
'''
print("圆的面积是：{:>8.2f}".format(3.14 * r * r))
return

getcirclearea(3)
print(type(getcirclearea))
print(getcirclearea(3)) # return 语句无返回值，返回None

函数的嵌套

'''
函数嵌套的定义：
函数嵌套的定义指的是在函数内部定义的函数，但内嵌的函数只能在该函数中使用
'''

使用嵌套定义的函数求阶乘和

def sum(n):
def fact(a):
t = 1
for i in range(1, a + 1):
t *= i
return t

s = 0  
for i in range(1, n + 1):  
    s += fact(i)  
return s

函数的嵌套使用

def mai():
print("输入数据")
userinput()
print("处理数据")
userprocessing()
print("输出数据")
useroutput()

def userinput():
pass

def userprocessing():
pass

def useroutput():
pass

mai()

'''
函数的参数和返回值
1.位置参数
函数调用时，默认情况下按照位置顺序传递给形参
2.赋值参数
如果参数很多，按位置传递参数的方式可读性较差，python提供了按照形参名输入实参的方式，这种参数称为赋值参数
3.参数值的类型
参数的类型是指函数调用时，传递的实际参数是基本数据类型还是组合数据类型。参数类型不同，在函数调用后，参数值的变化也是不同的。
基本数据的变量在函数体外，是全局变量，作为实际参数时，是将常量或者变量的值传递给形参，是一种值传递的过程，实参和形参是两个独立
不相关的变量，因此，实参值一般不会改变的。
'''

def getvolume(r, h):
print("圆的体积是：{:>8.2f}".format(3.14 * r * r * h))
return

v = getvolume(2, 5)

def getscore(pe, eng, math, phy, chem):
return pe * 0.5 + eng * 1 + math * 1.2 + phy * 1 + chem * 1

print(getscore(60, 90, 70, 100, 80)) # 按位置传递
s = getscore(pe=60, math=70, chem=80, eng=90, phy=100) # 使用赋值参数
print(s)

a = 10

def func(num):
num += 1
print("形参的地址：{}".format(id(num)))
print("形参的值：{}".format(num))
a = 1 # 局部变量，之在函数内部有效

func(a)
print(a, id(a)) # 函数调用后，变量a的值不发生变化

组合数据类型作为实参进行参数传递

tup = (1, 5, 7, 8, 12, 9)
ls = []

def getodd(tup1, ls1):
for i in tup1:
if i % 2:
ls1.append(i)
return ls1

getodd(tup, ls)
print(tup, ls) # 函数调用前后，ls的值放生了变化，但id值不变

默认参数

"""
定义函数时，可以给函数的形式参数设置默认值，这种参数称为默认参数。
当函数调用的时候，由于默认参数在定义是已经被赋值，所以可以直接忽略，
二其他参数势必需要传入的值。如果默认参数没有传入值，则直接使用默认值，
如果默认参数传入了值，则使用传入的新值替代。
"""

def showmessage(name, age=18):
print("姓名：", name)
print("年龄：", age)
return

调用shoumessage函数

showmessage(age=19, name='Kate')
print("-----------------------")
showmessage(name='John')

可变参数

'''
在Python的函数中，可以定义可变参数。可变参数指的是在函数定义时，
该函数可以接受任意个数的参数，参数的个数可能是一个或者多个，也
可能是0个，可变参数有两种形式，参数名称前加星号（*）或者加两个
星号（**）。定义可变参数语法格式如下：
def funname(formal_args,*args,**kwargs)
statemengts
return expression
formal_args:定义的传统参数，代表一组参数
*args和**kwargs:可变参数
函数传入的参数个数会优先匹配formal_args参数的个数，
*args以元组的形势保存多余的参数，**kwargs以字典的形式
保存带有指定名称形式的参数，这种参数也成为关键字参数
调用函数的时候，如果传入的参数和formal_args参数的个数相同，
可变参数会返回空的元组或字典，如果传入的参数个数和formal_args
相同，可变参数会返回空元组或字典，如果传入的参数比formal_args
参数多，可分为如下两种情况：
1.如果传入的参数没有指定名称，那么*args会议元组的形式存放这些多余的参数
2.如果传入的参数指定了名称，如score=90，那么**kwargs会以字典的形式存放
这些被命名的参数
'''

def showmessage1(name, *p_info):
print("姓名：", name)
for e in p_info:
print(e, end=",")
return

showmessage1("Kate")
print("----------------------")
showmessage1("Kate", "male", 18, "Dalian")

def showm2(name, *p_info, **scores):
print("姓名：", name)
for e in p_info:
print(e, end=" ")
for item in scores.items(): # ?这里不懂
print(item, end=" ")
print()
return

showm2("Kate", "male", 18, "Dalian")
print("-----------------------")
showm2("Kate", "male", 18, "Dalian", math=88, pe=99, eng=60)

函数的返回值

'''
返回值可以是任意数据类型，不带参数值的return语句返回None
'''

def compare(arg1, arg2):
"比较两个参数大小"
result = arg1 > arg2
return result

btest = compare(10, 9.99)
print("函数的返回值：", btest)

def findwords(sentence):
"统计参数中含有字符e的单词，保存到列表中，并返回"
result = []
words = sentence.split() # ？split()
for word in words:
if word.find("e") != -1:
result.append(word)
return result

ss = "Return the lowest index in S where substring sub is found"
print(findwords(ss))

lamda函数

"""
lambda parameters:expression
parameters是可选参数表，通常使用逗号分隔的变量或者表达式，即位置参数
expression是函数表达式，该表达式中不能包含分支或者循环语句，expression
表达式的值将会作为lambda函数的返回值
lambda函数的应用场景是定义简单的、能在一行内表示的函数，返回一个函数类型
"""
import math

area = lambda r: math.pi * r * r
volume = lambda r, h: math.pi * r * r * h
print("{:6.2f}".format(area(2)))
print(volume(2, 5))

list = [3, 5, -4, -1, 0, -2, -6]
list2 = sorted(list, key=lambda x: abs(x))
print(list2)

闭包和递归函数

"""
闭包（Closure）是一种重要的语法结构，Python支持闭包这种结构，如果一个内部函数
引用了外部函数作用域中的变量，那么这个内部函数就被称为闭包，被引用的变量将和
这个闭包函数一同存在，即使离开了创建它的外部函数也不例外。
闭包：函数和与其相关的引用环境组合而成的实体
在Python中创建一个闭包需要满足以下条件：
1.闭包函数必须有嵌套函数
2.嵌套函数需要引用外部函数中的变量
3.外部函数需要将嵌套函数作为返回值返回
"""

def greeting_conf(prefix):
def greeting(name):
print(prefix, name)

return greeting

mGreeting = greeting_conf("Good Morning")
mGreeting("Wilber")
mGreeting("Will") # ？没懂
print()
mGreeting = greeting_conf("Good Afternoon")
mGreeting("Wilber")
mGreeting("Will")

"""
递归特点：
1.一个递归的方法即为直接或间接地调用自身的方法
2.任何一个递归方法都必须有一个递归出口
"""

def fib(i):
"""
斐波那契数列
"""
if i == 0:
return 0
elif i == 1:
return 1
else:
return fib(i - 1) + fib(i - 2)
print(fib(8))

print(fib(8))

def factorial(i):
"""
求指定参数的阶乘
"""
t = 1
for i in range(1, i + 1):
t *= i
return t

print(factorial(6)) # 720

def factorial(i):
"""
递归方式求阶乘
"""
if i == 0:
return 1

变量的作用域

"""
局部变量：
局部变量指的是定义在函数内的变量，其作用范围是从函数定义开始，到函数执行结束。
局部变量定义在函数内，只在函数内使用，他与函数外具有相同名称的变量没有任何关系。
"""

"""
全局变量：
全局变量可以在整个程序范围内访问，局部变量只能在声明他的函数内部访问。全局变量是定义
在函数外的变量，它拥有全局作用域，但其在各函数内部只是可访问的、只读的，全局变量的使
用是受限的。
函数中如果定义了与全局变量同名的变量，其实质是局部变量
不允许在函数中先使用与全局变量同名的变量
"""