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

# 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

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

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

# global语句
"""
用于在函数内部声明全局变量，降低软件质量（不建议使用）
? nonlocal关键字
"""
basis = 100  # 全局变量

def func4(x, y):
    global basis  # 声明basis是函数外的局部变量
    print(basis)  # 100
    basis = 90
    sum = basis + x + y
    return sum

print(func4(75, 62))
print(basis)  # 90

# ？python的内置函数
# ？python操作相关的函数