Python--函数

Python–函数

作用

函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求

函数在开发过程中，可以更高效的实现代码重用

函数的使用步骤

定义函数

def 函数名(参数):
	代码1
	代码2
	......

调用函数

函数名(参数)

注意:

​ 1.不同的需求，参数可有可无

​ 2.在Python中，函数必须先定义后使用

函数实例

需求：复现ATM机取款功能

# 1.定义函数
def sel():
    print("余额查询")
    print("取钱")
    print("存钱")
    print("转账")
# 2.整体框架
def sel():
    nu = input("请选择:")
    if nu == "余额查询":
        print("你的余额还有1块钱")
    elif nu == "取钱":
        ll = int(input("请输入你的取款金额"))
        print("你的取款已经完成，取款:%d元" % ll)
    elif nu == "存钱":
        hh = input("请输入存款金额:")
        print(f'存款金额为{hh},交易已经完成')
    elif nu == "转账":
        ss = int(input("请输入转账账号:"))
        mm = int(input("请输入转账金额:"))
        print("交易成功")
passwd = int(input("请输入密码:"))
if passwd == 147258:
    print("请选择你需要办理的业务")
    sel()
else:
    print("密码输入错误，请重新输入")

函数注意事项

1.函数先定义后调用，如果先调用会报错

2.如果没有调用函数，函数里的代码则不会执行

3.函数执行流程：

​ 当调用函数时，解释器会回到定义函数的地方执行下方缩进的代码，当这些代码执行完毕，回到调用函数的地方继续向下执行

​ 定义函数的时候，函数体内的代码并不执行

函数参数

作用：封装代码，高效的代码重用

形参：函数定义时书写的 参数（非真实数据）

实参：函数调用时书写的参数（真实数据）

位置参数

调用函数时根据函数定义的参数位置来传递参数

注意：传递和定义参数的顺序及个数必须一致

def user_info(name,age,gender):
    print(f'你的名字是{name}，年龄是{age},性别是{gender}') 
user_info("laow",20,"男")

指定参数的数据类型

标准化输出，限制参数的数据类型

def hello(name,age):
    print("%s,%d" %(name,age))  #输出的数据类型
hello("闫",18)  # 闫,18

关键字参数

函数调用，通过“键=值“的形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

def user_info(gender,name,age):
    print(f'你的名字是{name},年龄是{age}，性别是{gender}')
user_info("男",age=18,name="loaw") # 位置参数 gender要写在最前边，关键字参数先后顺序无所谓
# 输出结果：
你的名字是loaw,年龄是18，性别是男

缺省值参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值

**注意：**所有位置参数必须出现在默认参数之前，包括函数定义和调用。函数调用时，如果为缺省参数传值，则修改默认参数值，否则使用这个默认值

def user_info(gender,name,age=18):  # 缺省参数在最后
    print(f'你的名字是{name},年龄是{age}，性别是{gender}')
user_info("男",name="loaw")   # 位置参数在最前
# 输出结果:
你的名字是loaw,年龄是18，性别是男

不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景，此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

包裹位置传递

***args：**传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args为元组类型数据，这就是包裹位置传递。

def user_info(*args):
    print(args)
user_info()
user_info("Tom",20,"男")
# 输出结果：
()  # 返回空元组
('Tom', 20, '男')  # 返回元组数据

def hello(a,b,*args):  # 不定长数据类型命名不固定
    print(a,b,j)
hello(1,2，5)  # 1 2 (5,)

包裹关键字传递

** **kwargs：**会存放所有未命名的变量参数,kwargs为字典类型数据，输入形式：变量名=值

def user_info(**kwargs):
    print(kwargs)
user_info(name="laow",age=18)
# 输出结果;
{'name': 'laow', 'age': 18}

def hello(a,b,*j,**ll):
    print(a,b,j,ll)
hello(1,2,5,5,name="laow",age=18) 
# 输出结果：
1 2 (5, 5) {'name': 'laow', 'age': 18}  

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

函数返回值

1.在函数中，如果需要返回结果给用户需要使用函数返回值

2.退出函数，会导致return下方的所有代码（函数体内容）不执行（退出当前函数）

return 返回值  #return返回结果给函数调用的地方

举例

def jj():
    return "helloworld"
a = jj()  #结果返回给函数
print(a)  # helloworld

函数返回值应用

需求：制作一个计时器，计算任意两个数字之和，并保存结果

def result(a,b):
    return a + b
a = result(5,9)
print(a)  # 14

函数说明文档

help()函数作用：查看函数的说明文档（函数的解释说明信息）

语法

定义函数说明文档

def 函数名(参数)：
	"""说明文档的位置"""
	代码
	......

举例

def hh(a,b):
    """这是求和函数"""
    c = a + b
    print(c)
help(hh)  # 查看hh()函数的说明文档
# 输出结果
hh(a, b)
    这是求和函数

高级使用

def aa(a,b):  
	"""
	说明信息，自已定义和系统提示
	"""
	代码
	......

举例

def sum(a,b):
    """
    求和函数
    :param a:  参数1
    :param b:  参数2
    :return:  返回值
    """
    return a + b
help(sum)
# 输出结果：
sum(a, b)
    求和函数
    :param a:  参数1
    :param b:  参数2
    :return:  返回值

查看函数帮助文件

help(函数名称)

举例

help(sum)  #查看函数的帮助文档
# 输出结果：
sum(a, b)
    求和函数
    :param a:  参数1
    :param b:  参数2
    :return:  返回值

函数嵌套调用

所谓函数嵌套使用指的是一个函数里边又调用另外一个函数（减少代码量）

def hello():
    print("====A====")
    print("====B====")
    print("====C====")
def world():
    print("====1====")
    hello()  # 桥套调用hello()函数
    print("====2====")
    print("====3====")
world()
# 执行结果;
====1====
====A====
====B====
====C====
====2====
====3====

嵌套应用

打印图形

1.打印一条横线

def pr():
    print("-"*20)
pr()
# 输出结果：
--------------------

2.打印多条横线

def pr():
    print("-"*20)
def print_line(a):
    i = 1
    while i <= a:
        pr()
        i += 1
print_line(3)
# 输出结果：
--------------------
--------------------
--------------------

函数数学计算

1.求三个数的和

def hello(a,b,c):
    return a + b + c
a = hello(20,20,45)
print(a)  # 85

2.求三个数的平均值

def hello(a,b,c):
    return a + b + c
def world(a,b,c):
    return hello(a,b,c)/3
b = world(10,20,30)
print(b)  # 20.0

函数的变量

变量作用域

变量作用域指的是变量的生效范围，主要分为两类：局部变量和全局变量

局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

局部变量作用：在函数体内部，临时保存数据，当函数调用完成后，则销毁局部变量

def test():
    a = 100  #局部变量a
    print(a)
test()  # 100
print(a) # 报错，因为在函数test中没有变量a

全局变量

全局变量：在函数体内、外都能够生效的变量

a = 100  # 定义全局变量
def test():
    print(a)
test()  # 100
def age():
    print(a)
age() # 100

修改全局变量

注意：

如果在函数内部直接修改全局变量，其实修改的不是全局变量，而是重新定义了一个新的局部变量

a = 100  # 声明全局变量
print(a)  # 100
def testA():
    a = 10  # 定义一个局部变量
    print(a)  
testA()  # 10
def testB():
    print(a)
testB()  # 100

函数体内部修改或定义全局变量：

**global：**在局部声明全局变量，前提是，声明global的区域要执行，否则不生效

如果全局变量需要在函数中修改，就需要使用global进行声明

a = 100
print(a) # 100
def testA():
    global a  # 声明修改的全局变量
    a = 10  # 为全局变量重新赋值
    print(a)
testA()  # 10
def testB():
    print(a)
testB()  # 10

对于可变数据类型的全局变量来说，因其指向的数据可以修改，所以不适用global时也可以修改全局变量

多函数程序执行流程

一般在实际开发过程中，一个程序往往由多个函数组成，并且多个函数共享某些数据

共用全局变量

a = 100  # 定义全局变量
def hello():
    global a  # 修改全局变量，当调用hello()函数的时候，修改全局变量才会生效
    a = "helloworld"
    print(a)
def world():
    print(a)
world()  # 100

返回值作为参数传递

将一个函数的返回值作为另外一个函数的参数

def hello():
    return 20
sum = hello()
def world(a):
    print(a)
world(sum)  # 20

函数的返回多个值

函数如何返回多个返回值？

# 错误书写，return下边的代码不会执行
def hello():  
    return 1
	return 2
# 正确写法	
def hello():
    return 1,2
a = hello()
print(a)  #(1，2)

注意:

​ 1.return a,b写法，返回多个数据的时候，默认值元组类型

​ 2.return后面可以连接列表、元组或字典，以返回多个值

# 返回列表
def hello():
   return [1,3,4,5,6]
a = hello()
print(a)  # [1, 3, 4, 5, 6]

#返回元组
def hello():
   return (1,3,4,5,6)
a = hello()
print(a)  # (1, 3, 4, 5, 6)

#返回字典
def hello():
   return {"name":"Python","age":18}
a = hello()
print(a)  # {'name': 'Python', 'age': 18}

拆包和交换变量值

拆包

拆包：元组

def return_num():
    return 100,200
a,b = return_num()   #关键点，元组有一个值们就用几个变量去接受
print(a)
print(b)
# 输出结果：
100
200

拆包：字典

字典的拆包，变量接受的时key值，需要用这个变量去调用字典的value值

dict1 = {"name":"laow","age":18}
a,b = dict1  # 变量接受key值

# 打印key值
print(a)  # name
print(b)  # age 

# 调用字典的value值
print(dict1[a])  # laow
print(dict1[b])  # 18

交换变量值

需求：有变量a = 100和b = 200，交换变量的值

方法一：

借助第三变量存储数据

a = 100
b = 200
# 设置中间变量
c = a  # 将a的值赋值到变量c
# a和b交换值
a = b  # 将b的值赋值到变量a
b = c  #将c也就是a的值赋值到变量b
# 输出a和b的值
print(a)  # 200
print(b)  # 100

方法二：

简便方法

a = 100
b = 200
a,b = b,a  # a和b交换值
print(a)  # 200
print(b)  # 100

引用

引用介绍

在Python中，值是靠引用来传递的(应用说到底也是要给变量)

当要给变量赋值以后，它的值就会有一个引用，不论这个是如何改变，这个应用是唯一的

我们可以通过id()来判断两个变量是否为同一个值的引用。我们可以将id值理解为那块内存的地址标识。

# int类型--不可变类型测试
a = 100
b = a
print(id(a))  # 140726569172336
print(id(b))  # 140726569172336
# a和b的id值是相同的，所以它们的引用是相同的

# 列表--可变类型测试
aa = [1,2,3]
bb = aa 
print(id(aa))  # 1428361925128
print(id(bb))  # 1428361925128
# aa和bb的id值是相同的，所以它们的引用是相同的
aa.append(11)  # 修改aa列表
print(aa)  # [1, 2, 3, 11]
print(bb)  # [1, 2, 3, 11]
print(id(aa))  # 1428361925128
print(id(bb))  # 1428361925128

引用当作实参

验证应用可以当实参的代码：

def test1(a):
    print(a)
    print(id(a))

    a += a
    print(a)
    print(id(a))
b = 100
test1(b)
c = [10,20]
test1(c)
# 输出结果：
100
140726569172336
200
140726569175536
[10, 20]
2465605440008
[10, 20, 10, 20]
2465605440008

可变类型和不可变类型

所谓可变类型与不可变类型指的是：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变

可变类型

• 列表

• 字典

• 集合

不可变类型

• 整型
• 浮点型
• 字符串
• 元组