Python基础--函数

产生原因：
在软件开发中，时常出现功能相同，处理数据不同的代码块，复制该段代码到相应位置稍加
修改，不利于后期维护。
解决方法：
将可能需要返回执行的代码封装为函数（组织代码的最小单元），然后在需要该功能的地方
调用函数，不仅可以实现代码的复用，更重要的是保证代码的一致性。
实际要求：
在设计时要提高函数的内聚性，减少不同函数之间的耦合性；尽量减少副作用，只实现指定
功能；在实际开发中，需要把调用的函数封装到一个模块中，使得管理方便。

一、函数的定义

函数是一段具有特定功能的、可重复使用的语句组，通过函数名来表示和调用。
单纯的定义函数不会对程序产生影响，只有当调用这个函数的时候它才会起作用。定义方式
如下：

def <函数名> (<参数列表>):
	<函数体>

【注意】

1. 函数形参不需要声明其类型，也不需要指定函数的返回类型。

2. 即使该函数不需要接收任何参数，也必须保留一对空括号。

3. 括号后面的冒号不能少。

4. 函数体相对于 def 关键字必须保持一定的空格缩进。

二、函数的使用

1. 函数定义，只是声明了一个函数，它不会被执行，需要调用；

2. 调用的方式，就是函数名加上小括号，括号内写上参数；

3. 调用时写的参数是实际参数，是实实在在传入的值，简称实参；
   

三、函数的参数传递

(一)位置参数

位置参数是比较常用的形式，调用函数时实参和形参的顺序必须严格一致，并且数量必须相同
【示例】

def praise(number,words):
    if number>0:
        while number>0:
            print("顾安真漂亮"+words)
            number-=1

    else:
        print("输入的数字需要大于零")

a=eval(input("请输入您想夸博主的次数"))
b="顾安真可爱"
c=1
praise(a,b)
#位置参数实参与形参数量必须一直，位置必须一致
praise(a,b,c)

运行结果：

(二)默认值参数

• 使用形参名称时，传参顺序可任意调整。
• 任何一个默认值参数右边都不能再出现位置参数。
• 多次调用函数且不为默认值参数传参，默认值参数只在定义时进行一次解释和初始化。
【示例】

def praise(number,words="，顾安真可爱"):
    if number>0:
        while number>0:
            print("顾安真漂亮"+words)
            number-=1

    else:
        print("输入的数字需要大于零")

a=eval(input("请输入您想夸博主的次数"))
praise(a)

运行结果

(三)关键字参数

• 关键字参数主要指调用函数时的参数传递方式，与函数定义无关。
• 指定参数名传参，实参顺序和形参顺序可以不一致。

【示例】

def praise(number,words):
    if number>0:
        while number>0:
            print("顾安真漂亮"+words)
            number-=1

    else:
        print("输入的数字需要大于零")

a=eval(input("请输入您想夸博主的次数"))

praise(words=",顾安真可爱~",number=a)

运行结果

(四)可变长度参数

• 可变长度参数主要有两种形式：*param 和**param；
• *param 接收任意多个参数放在一个元组中；
• **param 接收任意多个关键字参数放入字典中。

def a(*number):
   print(number)
def b(**number):
   print(number)
a(1,2,3)
b(p=1,c=2,l=3)

运行结果：

(五)传递参数时的序列解包

解包的意义就是将传递给函数的一个列表，元组，字典，拆分成独立的多个元素然后赋值给函数中的形参变量。解包字典有两种解法，一种用*解的只有 key，一种用**解的有 key、value。但是这个方法**只能在函数定义中使用。
• 与可变长度的参数相反，这里的序列解包指的是实参，包括两种形式，
• 调用多个位置参数时，使用迭代对象作为实参，在实参名称前加（*），Python 会自动解包。

1.对列表、元组的解包

【实例】

# 接收多个位置参数
def a(a,b,c):
   print(a* b * c)

lis=[2,3,4]
tup=(3,4,5)
# 对列表进行解包
a(*lis)
# 对元组进行解包
a(*tup)

运行结果：

2.对字典、集合的解包

1、对字典的键和值进行解包

# 接收多个位置参数
def a(a,b,c):
   print(a+ b + c)

dic={1:"a",2:"b",3:"c"}
# 对字典的键进行解包
a(*dic)
# 对字典的值进行解包
a(*dic.values())

运行结果

2、带有位置参数和默认值参数的函数，用两个星号*对其进行解包

def f(a, b, c=4):
   print(a, b, c)
p = {"a":1,"b":2,"c":3}
# 字典，可以使用两个星号*对其进行解包
f(**p)

运行结果

3、对集合进行解包

def f(a, b, c=4):
   print(a, b, c)

set = {4, 5, 6}
# 对集合进行解包
f(*set)

运行结果：

总结：
①多个位置可变参数在形参前使用一个星号*；
②多个关键字可变参数在形参前使用两个星号**；
③位置可变参数和关键字参数可以收集若干个实参，多个位置可变参数收集形成一个tuple，多个关键字可变参数收集形成一个 dict；
④混合使用参数时，遵循的参数顺序为：普通参数、位置可变参数、关键字可变参数、可变长度参数。

(六)函数的返回值

①return 语句用来结束函数并将程序返回到函数被调用的位置继续执行；
②return 语句可以出现在函数中的任何部分；
③可以同时返回 0 个或多个函数运算的结果给函数被调用处的变量；
④函数可以没有返回值，也可以有多个返回值，当 return 返回多个值时，返回的值形成元
组数据类型。

def cal(x,y):
   return x+y,x*y
print(cal(4,6))

a,b=cal(4,6)
print(a)
print(b)

运行结果：

(七)变量的作用域

1.局部变量

命名规则与标识符一样，在函数内部定义，仅在函数内部有效，当函数退出时销毁。

2.全局变量

命名规则与标识符一样，全局变量在函数内部使用时，需要用 global 关键字声明，且该变量与外部变量全局变量同名。在函数之外定义的变量，在程序执行全过程有效。
在函数内部通过 global 关键字声明或定义全局变量的两种情况：
（1） 变量已在函数外定义，如果在函数内需要修改这个变量的值，并将修改的结果反映到函数之外，可以在函数内用关键字 global 明确声明要使用已定义的同名全局变量。
（2） 在函数内部直接使用 global 关键字将一个变量声明为全局变量，如果在函数外没有定义该全局变量，在调用这个函数之后，会创建新的全局变量。

【实例】在函数体内声明全局变量

def demo():
   #创建全局变量，必须在使用之前
   global x
   x=3
   y=4
   print(x,y)
x=6
demo()
print(x)

运行结果：

如果在某个作用域内有为变量赋值的操作，那么该变量被认为是该作用域内的局部变量。局部变量与全局变量同名时，该局部变量会在自己的作用域内暂时隐藏同名的全局变量。

# 创建全局变量
x=6
def demo():

   x=3 # 创建局部变量
   y=4
   print(x,y)

demo()
print(x)

运行结果：

(八)代码复用

函数是程序的一种基本抽象方式，它将一系列代码组织起来通过命名供其他程序使用。函数封装的直接好处就是代码复用，任何代码只要输入参数即可调用函数，从而避免相同功能代码在被调用处重复编写。
模块化设计指通过函数的封装功能将程序划分为主程序、子程序和子程序间关系的表达。模块化设计是使用函数设计程度的思考方法，以功能为基本单位，一般由两个基本要求：
• 紧耦合：尽可能合理划分功能模块，功能块内部耦合紧密；
• 松耦合：模块间关系尽可能简单，功能块之间耦合度低。
耦合性指程序中各模块之间想相互关联的程度，它取决于各模块间接口的复杂程度和调用方式。耦合性是影响软件复杂程度和设计质量的一个重要因素。

(九)lambda 函数

匿名函数适合处理临时需要一个类似于函数的功能但又不想定义函数的场合，可以省去函数的定义过程和考虑函数的命名，让代码更加简洁，可读性更好。其通式为：

<函数对象名>=lambda <形式参数列表>:<表达式>

fun = lambda x, y: (print(x), x) if x > y else (print(y), y)
fun(5,6)