Python入门-基础篇笔记04

函数结构

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

• 定义函数以def关键词开头，后面跟着函数名、圆括号()、括号中的参数、冒号；
• 接着，在缩进块中编写函数体，函数的第一行语句一般是写文档字符串，用于存放函数说明，也可以选择不写；
• Return[expression]表示结束函数，并返回值。而不带表达式的return相当于返回空值。 
• Python不允许前向引用，即在函数定义之前，不允许调用该函数。 

函数的参数

必选参数

——在调用函数的时候必须指定参数值

示例：

def add(x, y): #参数x, y就是必选参数
    result = x + y
    return result

print(add(11, 22)) #33
print(add(s1, s2)) #输入类型错误

默认参数 

——是指给函数参数提供默认值，如果在调用函数的时候没有给该参数传递值，则该参数使用默认值。

示例：

def add(x, y = 10): #参数x是必选参数，参数y是默认值10的参数
    result = x + y
    return result

print(add(20))

注：

• 默认参数要放在所有必选参数的后面；
• 默认参数必须指向不变对象。

可变参数 

——传入的参数数量是可变的

示例：

def addplus(*numbers): # 参数numbers是可变参数，表示输入的参数个数可以为任意值
    add_result = 0
    for i in numbers:
        add_result += i
    return add_result

print(addplus(1, 2, 3, 4, 5, 6, 7, 8, 9)) # 45

注：在函数内部，可变参数numbers接收到的值是一个tuple。我们在调用参数是可变参数的函数时，可以给该函数传递任意个数的参数，包括0个参数。 

关键字参数

——关键字参数允许我们传入任意个含参数名的参数，这些关键字参数在函数调用时自动组装为一个dict。也就是说，关键字参数将长度任意的键-值对，作为参数传递给函数。

示例：

def addpluss(**kw):
    return kw

d1 = addpluss()
# 参数值为空
d2 = addpluss(x = 1)
# 参数值为 x = 1
d3 = addpluss(x = 1, y = 9)
# 参数值为 x = 1, y = 1

print(d1)
print(d2)
print(d3)

输出：

{}
{'x': 1}
{'x': 1, 'y': 9}

在上面的例子中，kw就是一个关键字参数，关键字参数前面加**表示。关键字参数可以扩展函数功能，使传递参数过程更为简便。

使用关键字参数**dict的方法，可以大大提高参数传递的效率：

# 定义一个plus函数，有3个参数，返回值是3个参数之和
def plus(x,y,z):
   return x+y+z
# 有一个dict列表，当中3个键的值分别为1,2,3
dict = {'x':1, 'y':2, 'z':3}
# 用关键字参数的方法将dict列表中的3个值传入plus函数中，得到返回值d
d = plus(**dict)
print(d)
# d = 6

参数组合 

        我们在函数定义过程中，可以同时用到必选参数、默认参数、可变参数、关键字参数中的一种或几种。但是需要特别注意的是，这四种参数在使用的过程中是有顺序的，顺序依次应该是必选参数、默认参数、可变参数和关键字参数。

示例：

# 定义一个包含必选参数、默认参数、可变参数和关键字参数的函数plus
def plus(x, y = 0, *z, **p):
    print("x = ", x)
    print("y = ", y)
    print("z = ", z)
    print("p = ", p)

plus(1)

输出：

x =  1
y =  0
z =  ()
p =  {}

小结 

• 不同类型的参数是有顺序的，依次是必选参数、默认参数、可变参数和关键字参数；
• 默认参数一定要用不可变对象，用可变对象容易产生逻辑错误；
• *args表示的是可变参数，*args接收的是一个元组；
• **kw表示的是关键字参数，**kw接收的是一个字典。

函数的返回值

return语句将值返回到调用函数的出口，函数中一定要有return返回值才是完整的函数。如果我们没有在函数中定义函数返回值，那么程序会自动让函数返回一个结果，该结果是None对象，而None对象表示没有任何值。

将值作为返回值

函数的返回值只有一个，但有时我们会发现有的函数好像有多个返回值，其实这里的“多个”并不是指多个返回值。比如函数返回一列表，里面包含很多个元素值。这就类似于，只能从超市带走一个箱子，但是允许我们把一些东西都装到箱子里面看做一个东西带走。例如：

def f():
    return 1,'abc','1234'
print(f())

输出结果：

(1, 'abc', '1234')

调用f()函数，程序输出为一个元组，所以函数返回值表面上是3个值，其实是返回一个元组，元组里面有三个不同元素（元组语法上不需要一定带上圆括号）。

将函数作为返回值 

我们除了可以将各种类型的值作为返回值外，也可以将函数作为返回值。例如，我们要定义一个函数来求列表中数值元素的和，一般情况下我们是这样定义的：

def plus(*args):
    s = 0
    for n in args:
        s = s + n
    return s

但是，如果我们不需要立刻求和，而是在后面的程序中，根据需求再计算，这种情况怎么办呢？这时我们定义的函数可以不返回求和的结果，而是返回计算求和的函数。所以我们还可以用如下方法定义函数：

def lazy_plus(*args):
    def plus():
        s = 0
        for n in args:
            s = s + n
        return s
    return plus

当我们调用lazy_plus()时，返回的并不是求和结果，而是计算求和的函数：

# 定义求和函数，返回的并不是求和结果，而是计算求和的函数
def lazy_plus(*args):
    def plus():
        s = 0
        for n in args:
            s = s + n
        return s
    return plus
# 调用lazy_plus()时，返回的并不是求和结果，而是求和函数
f = lazy_plus(1,2,3,4,5)
print(f)

 输出结果：

<function lazy_plus.<locals>.plus at 0x000001B984BC4E00>

调用函数f时，才真正计算求和的结果：

# 定义求和函数，返回的并不是求和结果，而是计算求和的函数
def lazy_plus(*args):
    def plus():
        s = 0
        for n in args:
            s = s + n
        return s
    return plus
# 调用函数f时，得到真正求和的结果
f = lazy_plus(1,2,3,4,5)
print(f())

输出结果：

15

在上述例子中，我们在函数lazy_plus中又定义了函数plus，而且内部函数plus是可以引用外部函数lazy_plus的参数和局部变量的。当函数lazy_plus返回函数plus时，相关参数和变量也将会保存在返回的函数中，这种方式也称为“闭包”（Closure）。

 函数的使用范围

在 Python 中，正常的函数和变量名是公开的（public），是可以被直接引用的。比如abs()、abc、dir()等。

• 类似__xxx__这种格式的变量是特殊变量，允许被直接引用，但是会被用作特殊用途。比如__author__、__name__就是属于特殊变量。hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己编程定义的变量一般不会用这种变量名。

• 类似_xxx和__xxx这种格式的函数和变量就是非公开的（private），不应该被直接引用。

• 补充：_xxx的函数和变量是protected，我们直接从外部访问不会产生异常。__xxx的函数和变量是private，我们直接从外部访问会报异常，我们要注意前缀符号的区别。

我们要注意用词的区别，我们说的private函数和变量是“不应该”被直接引用，而不是“不能”被直接引用。这是因为在 Python 中并没有一种方法可以真正完全限制访问private函数或变量。但是我们为了养成良好的编程习惯，是不应该引用private函数或变量的。private函数的作用是隐藏函数的内部逻辑，让函数有更好的封装性。例如：

def _private_1(name):
    return 'Hello, %s' % name
def _private_2(name):
    return 'Hi, %s' % name
def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)

我们在上述程序块里公开了greeting()函数，greeting()函数需要使用_private_1()和_private_2()函数。学习者并不需要知道greeting()函数中的内部实现细节，所以我们可以将内部逻辑用private函数隐藏起来，这是一种十分常用的代码封装的方法。

为了让程序的封装性更好，我们一般都限定函数的使用范围。一般我们把外部需要使用的函数定义为public函数，而把只在内部使用而外部不需要引用的函数定义成private函数。

实例：

写一个计算BMI的函数，函数名为 calculate_BMI
1.可以计算任意体重和身高的BMI值
2.执行过程中打印一句话，”您的BMI分类为：×ד
3.返回计算出的BMI值

BMI = 体重 / (身高 ** 2)

BMI分类：
偏瘦：user_BMI <= 18.5
正常：18.5 < user_BMI <= 25
偏胖：25 < user_BMI <= 30
肥胖：user_BMI > 30

def calculate_BMI(weight, height):
    BMI = weight / (height ** 2)
    if BMI <= 18.5:
        category = "偏瘦"
    elif BMI <= 25:
        category = "正常"
    elif BMI <= 30:
        category = "偏胖"
    else:
        category = "肥胖"
    print(f"您的BMI分类为：{category}")
    return '%.2f'%BMI
weight = float(input("请输入您的体重：(单位：kg)"))
height = float(input("请输入您的身高：(单位：m)"))

result_BMI = calculate_BMI(weight, height)

print("您的BMI数值是" + str(result_BMI))

 输出：

请输入您的体重：(单位：kg)80
请输入您的身高：(单位：m)1.8
您的BMI分类为：正常
您的BMI数值是24.69