python函数的作用域和常见的内置函数

测试小白00

已于 2022-08-16 19:29:04 修改

阅读量702

点赞数 1

CC 4.0 BY-SA版权

分类专栏：自动化测试文章标签： numpy python 测试工程师自动化开发语言

于 2022-08-16 19:26:36 首次发布

本文链接：https://blog.youkuaiyun.com/qq_49624649/article/details/126370835

自动化测试专栏收录该内容

27 篇文章

订阅专栏

本文详细探讨了Python中的函数，包括返回值的使用、局部与全局变量的区别以及如何修改全局变量。此外，还介绍了匿名函数lambda和常用的内置函数，如min、max、sum以及eval、enumerate、zip和filter。通过对这些概念的深入理解，可以更好地掌握Python编程技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、函数的返回值

return 语句：

1、给函数返回值(表达式)

2、用于终止函数的运行

return 语法：

1、如果不写return 或者写了return 但是后面不写值或者变量，默认返回None

2、reutrn返回一个数据时，返回的数据类型为返回值本身的数据类型object

3、return返回多个数据是，元素之间用逗号隔开，返回的数据类型为元组tuple

4、函数中不同分值可以有多个return语句

5、return是函数运行结束的标识符

# 1、不写return 或者 写了return 但是后面不写值或者变量，默认返回None
def add_func(a,b):
    total = a + b
    return
res = add_func(11, 22)
print("--------------------------------------")
print("add_func返回的值为：{}".format(res))
'''
运行结果：
--------------------------------------
add_func返回的值为：None
'''

# 2、return返回一个值
def add_func(a,b):
    total = a + b
    return total
res = add_func(11, 22)
print("--------------------------------------")
print("add_func返回的值为：{},其数据类型为{}".format(res,type(res)))
'''
运行结果：
--------------------------------------
add_func返回的值为：33,其数据类型为<class 'int'>
'''

# 3、return返回多个值
def add_func(a,b):
    total1 = a + b
    total2 = a - b
    total3 = a * b
    total4 = a / b
    return total1,total2,total3,total4
res = add_func(11, 22)
print("--------------------------------------")
print("add_func返回的值为：{},其数据类型为{}".format(res,type(res)))
'''
运行结果：
--------------------------------------
add_func返回的值为：(33, -11, 242, 0.5),其数据类型为<class 'tuple'>
'''

# 4、多分支，return
def add_func(a,b,method):
    if method == "+":
        print("{} + {} ,运算结果为：{}".format(a,b,a+b))
        return a + b
    elif method == "-":
        print("{} - {} ,运算结果为：{}".format(a, b, a - b))
        return a - b
    elif method == "*":
        print("{} * {} ,运算结果为：{}".format(a, b, a * b))
        return a * b
    elif method == "/":
        print("{} / {} ,运算结果为：{}".format(a, b, a / b))
        return a / b
print("--------------------------------------")
res = add_func(11, 22,"+")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
res = add_func(11, 22,"-")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
res = add_func(11, 22,"*")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
res = add_func(11, 22,"/")
print("add_func多分支返回的值为：{},其数据类型为{}".format(res,type(res)))
print("--------------------------------------")
'''
--------------------------------------
11 + 22 ,运算结果为：33
add_func多分支返回的值为：33,其数据类型为<class 'int'>
11 - 22 ,运算结果为：-11
add_func多分支返回的值为：-11,其数据类型为<class 'int'>
11 * 22 ,运算结果为：242
add_func多分支返回的值为：242,其数据类型为<class 'int'>
11 / 22 ,运算结果为：0.5
add_func多分支返回的值为：0.5,其数据类型为<class 'float'>
--------------------------------------
'''

二、函数的全局变量和局部变量

局部变量：

1、在函数内部定义的变量

2、其作用域仅为函数内部

3、函数的形参是局部变量

4、局部变量在函数调用时被创建，调用结束后被销毁

全局变量：

1、定义在函数体外，python模块中的变量

2、其作用域为整个python文件

3、全局变量不能在函数体内修改其绑定关系

全局变量的修改：

1、任何一个子函数，直接去使用全局变量，不对它进行修改，则只是引用共享全局变量

2、某个子函数，对全局变量进行修改，全局变量是不可变数据类型，相当于重新创建一个全局变量

3、某个子函数，对全局变量进行修改，全局变量是可变数据类型，确实是修改了全局变量

global 关键字：

1、声明函数内部操作的一个或多个变量是全局变量

2、不能先声明局部变量，再用global声明为全局变量

3、global变量列表里的变量名不能出现在次作用域内的形参列表

函数变量引用的优先级：

1、语句执行检查语法是从右到左

2、先在局部变量，再找全局变量

3、当局部变量和全局变量同名时，函数会优先使用局部变量

4、函数内部定义局部变量时，尽量不和全局变量同名

# Demo实例1：----全局和局部作用域区分
name = 'james' # 全局变量
print("-----------------------------")

def test():
    name = 'xiaowang'
    print("局部变量只在函数体内有效：",name)
    return name

res = test()   # 局部变量通过return返回
print("局部变量可以通过函数返回：",res)

# 全局变量不能在函数体内修改其绑定关系
print("全局变量不能在函数体内修改其绑定关系:",name)
print("-----------------------------")
'''
运行结果：
-----------------------------
局部变量只在函数体内有效： xiaowang
局部变量可以通过函数返回： xiaowang
全局变量不能在函数体内修改其绑定关系: james
-----------------------------
'''

# Demo实例2：----函数内使用全局变量，报错情况一
# 未进行全局声明前，如下代码会报错
number1 = 100

def func1():
    number1 = number1 + 100 # 会报错，原因如下：
    """
    这行会报错，函数找number1的定义时，
    从右到左，先执行number1+100，发现number1在该语句之前没定义，
    因其定义的语句：number1 = number1 + 100还未生效
    """
    print("number1的值为：{}".format(number1))

func1()
print("----------------------------------------------------------")
'''
执行结果：（报错提示：在赋值之前不能先使用，得先声明再使用）
UnboundLocalError: local variable 'number1' referenced before assignment
'''

# Demo实例3：----针对上述报错方案的优化
number2 = 100

def func2():
    # 修改为如下，则OK, global声明的必须先声明再使用
    global number2
    number2 = number2+ 100
    print("局部定义global number2后的值为：{}".format(number2))

func2()
"""
运行结果：
局部定义global number2后的值为：200
"""

# Demo4--global关键字的使用
test_list1 = [1,2,3] # 全局变量，作用域（整个当前的py文件）
def test01():
    global test_list  # 声明为全局变量
    test_list = [1,2,3] # 局部变量
    print("打印函数内部的局部变量的内存地址：",id(test_list))

def test02():
    test01()
    print("global声明 打印全局变量的内存地址",id(test_list))
    print("打印全局变量的内存地址",id(test_list1))

test02()
'''
运行结果：
-----------------------------
打印函数内部的局部变量的内存地址： 2585025008712
global声明 打印全局变量的内存地址 2585025008712
打印全局变量的内存地址 2585025008200
-----------------------------
'''

# 某个子函数，对全局变量进行修改，全局变量是可变数据类型，确实是修改了全局变量
test_list1 = [1, 2, 3] # 全局变量，作用域（整个当前py文件内使用）

def test01():
    print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))

def test02():
    test_list1.append(4)
    print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))
test01()
test02()
'''
-----------------------------
打印全局变量test_list1的内存地址t [1, 2, 3] 2021704487496
打印全局变量test_list1的内存地址t [1, 2, 3, 4] 2021704487496
-----------------------------
'''

# 某个子函数，对全局变量进行修改，全局变量是不可变数据类型，相当于重新创建一个全局变量
test_list1 = 3 # 全局变量，作用域（整个当前py文件内使用）

def test01():
    print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))

def test02():
    test_list1 = 5
    print("打印全局变量test_list1的内存地址t", test_list1, id(test_list1))
test01()
test02()
'''
-----------------------------
打印全局变量test_list1的内存地址t 3 140735760920896
打印全局变量test_list1的内存地址t 5 140735760920960
-----------------------------
'''

三、内置函数

4.1 匿名函数

lambda关键字：

python 使用 lambda关键字来创建匿名函数

lambda基本语法：

lambda [arg1 [,arg2,.....argn]]:expression

arg1...argn: 是参数列表，可以1个或者多个

expression: 是该匿名函数的返回值，或者返回逻辑，最多只能支持三元运算

lambda注意事项：

1）lambda只是一个表达式，函数体比def简单很多，无函数名称

2）lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑

3）lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局参数

4）最多支持三元运算符

三元运算符（条件为真时的结果 if 判段的条件 else 条件为假时的结果）

# demo1——简单的匿名函数
a = lambda x : x*x # x 为参数，x*x为返回的结果，a接受函数的返回值
print("两数相乘的匿名函数返回的结果：",a(10)) # 输出  100

add_func = lambda a,b: a+b
print("两数相加的匿名函数返回的结果：",add_func(10,20)) # 输出 30


# demo2——三元运算匿名函数
func = lambda x,y: x+y if x>y else x-y
print("若x>y，则相加,输入{},{}，结果为{}".format(5,3,func(5,3)))
print("若x<y，则相加,输入{},{}，结果为{}".format(3,5,func(3,5)))
'''
输出结果：
若x>y，则相加,输入5,3，结果为8
若x<y，则相加,输入3,5，结果为-2
'''

4.2 常用内置函数

数据统计相关：如下三个函数的参数必须为可迭代对象iterable

1、min()：获取最小值

2、max()：获取最大值

3、sum()：求和

可迭代对象：数据只能用一次

list1 = [1,2,3,4]
print("min的最小值为：",min(list1))
print("max的最大值为：",max(list1))
print("sum求和：",sum(list1))
'''
min的最小值为： 1
max的最大值为： 4
sum求和： 10
'''

高级内置函数：

1、eval：

识别字符串中的有效的python表达式并执行表达式====去引号+执行表达式

print("eval函数去引号，执行表达式结果为{}".format(eval('3*2')))
print("未用eval函数去引号，执行表达式结果为{}".format('3*2'))
'''
eval函数去引号，执行表达式结果为6
未用eval函数去引号，执行表达式结果为3*2
'''

2、enumerate：

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，

同时列出数据和数据下标，一般用在 for 循环当中。

返回的是元组数据的格式(索引，值)

list_test = ["james","study","python","good"]
for data in enumerate(list_test):
    print("enumerate函数打印序列的索引和值，结果为元组：{}".format(data))

for index,item in enumerate(list_test):
    print("enumerate函数打印序列的索引和值，元组拆包结果为：{}，{}".format(index,item))
'''
enumerate函数打印序列的索引和值，结果为元组：(0, 'james')
enumerate函数打印序列的索引和值，结果为元组：(1, 'study')
enumerate函数打印序列的索引和值，结果为元组：(2, 'python')
enumerate函数打印序列的索引和值，结果为元组：(3, 'good')
enumerate函数打印序列的索引和值，元组拆包结果为：0，james
enumerate函数打印序列的索引和值，元组拆包结果为：1，study
enumerate函数打印序列的索引和值，元组拆包结果为：2，python
enumerate函数打印序列的索引和值，元组拆包结果为：3，good
'''

3、zip：

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，

然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存

也叫做数据的聚合打包，聚合后的数据只能使用一次

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

利用 * 号操作符，可以将元组解压为列表。

# zip--两个list聚合以后才能转换成字典
list1 = ["a","b","c"]
list2= [1,2,3]
res = zip(list1,list2)
# print("zip函数打包两个list时，结果为字典：{}".format(dict(res)))
print("zip函数打包两个list时，结果为列表：{}".format(list(res)))
'''
zip函数打包两个list时，结果为字典：{'a': 1, 'b': 2, 'c': 3}
zip函数打包两个list时，结果为列表：[('a', 1), ('b', 2), ('c', 3)]
'''


list1 = [1, 2, 3, 4, 5]
list2 = [11, 22, 33, 44, 55]
list3 = [111, 222, 333, 444, 555]
list4 = [1111, 2222, 3333, 4444, 5555]
list5 = [11111, 22222, 33333, 44444, 55555]

ret = zip(list1, list2, list3, list4, list5)
print("zip函数打包多个list时，结果为列表，列表的每个元素为相同索引对应的值组成的子列表：\n{}"
      .format(numpy.array(list(ret))))
'''
zip函数打包多个list时，结果为列表，列表的每个元素为相同索引对应的值组成的子列表：
[[    1    11   111  1111 11111]
 [    2    22   222  2222 22222]
 [    3    33   333  3333 33333]
 [    4    44   444  4444 44444]
 [    5    55   555  5555 55555]]
'''

4、filter：

函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，

如果要转换为列表，可以使用 list() 来转换。接收两个参数，第一个为函数，第二个为序列，

序列的每个元素作为参数传递给函数进行判，

然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

stu = [90, 100, 25, 425, 32, 77]

ret = filter(lambda x: x > 80, stu)
print("filter函数过滤大于80的元素", list(ret))
'''
filter函数过滤大于80的元素 [90, 100, 425]
'''