函数

封装功能，提高应用的模块性和代码重用率

1. 定义函数

1.1 函数内的第一条语句是字符串时，该字符串就是文档字符串（docstring）

def my_fun():
    \'\'\'我是文档字符串

    函数内第一句是字符串时
    该字符串就是文档字符串
    \'\'\'
    pass
print(my_fun.__doc__)

\'\'\' 运行结果：
我是文档字符串

    函数内第一句是字符串时
    该字符串就是文档字符串
\'\'\'

1.2 创建一个可以判断一个整数是否是素数的函数

# 判断某个整数是否是素数，是返回Ture，不是返回False
def isPrimer(num):
    if num == 1:
        return False
    for i in range(2, num//2 + 1):
        if num%i == 0:
            return False
    return True
# 判断某个区间内的素数
def CircleIsPrimer(head, stop):
    MyDict = {True: \'素数\', False: \'非素数\'}
    for i in range(head, stop+1):
        print(i, \' is \', MyDict[isPrimer(i)])
# 主函数
def main():
    print(isPrimer(2))
    CircleIsPrimer(1, 15)
# 调用主函数
main()

\'\'\' 运行结果
True
1  is  非素数
2  is  素数
3  is  素数
4  is  非素数
5  is  素数
6  is  非素数
7  is  素数
8  is  非素数
9  is  非素数
10  is  非素数
11  is  素数
12  is  非素数
13  is  素数
14  is  非素数
15  is  非素数
\'\'\'

1.3 创建一个可以输出限定数值内的斐波拉契数列函数

def fib(num):
    a, b = 0, 1
    result = []
    while a < num:
        result.append(a)
        a, b =b, a + b
    return result
print(fib(10))

\'\'\' 运行结果
[0, 1, 1, 2, 3, 5, 8]
\'\'\'

2. 参数传递

在Python中，对象有不同类型的区分，变量没有类型

2.1 默认参数。定义函数时，需要从右往左给参数默认值，调用函数时，如果没有传递参数，则会使用默认参数

def loves(who,how=\'sincerely love\',what=\'Python\',why=\'Only because I love it\'):
    print(who, end=\' \')
    print(how, end=\' \')
    print(what)
    print(why)
    return
loves(\'I\')

\'\'\' 运行结果
I sincerely love Python
Only because I love it
\'\'\'

2.2 关键字。使用关键字参数允许函数调用时参数的顺序与声明时不一致

# 判断某个整数是否是素数，是返回Ture，不是返回False
def isPrimer(num):
    if num == 1:
        return False
    for i in range(2, num//2 + 1):
        if num%i == 0:
            return False
    return True
# 判断某个区间内的素数
def CircleIsPrimer(head, stop):
    MyDict = {True: \'素数\', False: \'非素数\'}
    for i in range(head, stop+1):
        print(i, \' is \', MyDict[isPrimer(i)])
CircleIsPrimer(stop = 15, head = 1)

\'\'\' 运行结果
1  is  非素数
2  is  素数
3  is  素数
4  is  非素数
5  is  素数
6  is  非素数
7  is  素数
8  is  非素数
9  is  非素数
10  is  非素数
11  is  素数
12  is  非素数
13  is  素数
14  is  非素数
15  is  非素数
\'\'\'

2.3 不定长参数。加了*的参数会以元组的形式导入，存放所有未命名的变量参数。加了**的参数会以字典的形式导入

# 2.3.1 以元组形式导入，包含形参列表之外的位置参数
def isLovePython(who, how, what, *why):
    print(who, end=\' \')
    print(how, end=\' \')
    print(what)
    print(why)
    return
isLovePython(\'I\', \'love\', \'Python\', \'only\', \'because\', \'I\', \'love\', \'it\')

\'\'\' 运行结果
I love Python
(\'only\', \'because\', \'I\', \'love\', \'it\')
\'\'\'

# 2.3.2 以字典形式导入，包含已定义形参对应之外的所有关键字参数
def isLovePython(**lovePython):
    print(lovePython)
    return
isLovePython(who=\'I\', how=\'sincerely love\', what=\'Python\')

\'\'\' 运行结果
{\'who\': \'I\', \'how\': \'sincerely love\', \'what\': \'Python\'}
\'\'\'

# 2.3.3 二者组合使用，*形参 必须在 **形参之前
def LovePython(who_, *how_, **info):
    print(who_)
    print(how_)
    print(info)
    return
LovePython(\'I\', \'need\', \'Python\', who=\'live\', how=\'is short\')

\'\'\' 运行结果
I
(\'need\', \'Python\')
{\'who\': \'live\', \'how\': \'is short\'}
\'\'\'

2.4 强制位置参数。限制参数的传递方式

def my_fun(a, b, /, c, d, *, e, f):
    pass

# a,b   必须是位置形参
# c,d   位置形参或关键字形参
# e,f   必须是关键字形参

3. 解包实参列表

3.1 用*把实参从列表或元组中解包出来

love = [\'I\', \'need\', \'Python\']
def Printf(who: str, how: str, what: str = \'MySQL\') -> None:
    print(who, \'\', how, \'\', what)
    return
Printf(*love)

\'\'\' 运行结果
I  need  Python
\'\'\'

3.2 用**把实参从字典中解包出来

love = {\'who\': \'I\', \'how\': \'need\', \'what\': \'Python\'}
def Printf(who: str, how: str, what: str = \'MySQL\') -> None:
    print(who, \'\', how, \'\', what)
    return
Printf(**love)

\'\'\' 运行结果
I  need  Python
\'\'\'

4. Lambda 表达式

常规定义函数的语法糖，只能是单个表达式

# 4.1 把匿名函数作为传递的实参
# 案例1：把 python、pytorch、pandas 筛选出来
love = [\'python\', \'PHP\', \'pytorch\', \'MySQL\', \'pandas\']
loveAI = filter(lambda x: x[0] == \'p\', love)
print(list(loveAI))

\'\'\' 运行结果
[\'python\', \'pytorch\', \'pandas\']
\'\'\'

# 案例2：字母全变大写
love = [\'python\', \'PHP\', \'pytorch\', \'MySQL\', \'pandas\']
love = map(lambda x: x.upper(), love)
print(list(love))
\'\'\' 运行结果
[\'PYTHON\', \'PHP\', \'PYTORCH\', \'MYSQL\', \'PANDAS\']
\'\'\'

# 4.2 把匿名函数作为函数返回值
love = [\'python\', \'PHP\', \'pytorch\', \'MySQL\', \'pandas\']
def LoveAI():
    return lambda x: x[0] == \'p\'
love_AI = LoveAI()
loveAI = filter(love_AI, love)
print(list(loveAI))

\'\'\' 运行结果
[\'python\', \'pytorch\', \'pandas\']
\'\'\'

来源：https://www.cnblogs.com/ohwell2aha/p/16540312.html
本站部分图文来源于网络，如有侵权请联系删除。