python里 列表是否不像全局变量，会在函数中被改变

Posted 2023-05-06

我在函数外定义了一个列表，在函数内作为行参调用，之后这个列表就被改变了

list1=['abc','-','efg']
def f1(the_list):
while '-' in the_list:

the_list.remove('-')

print(the_list)

f1(list1)
print(list1)

输出的结果是：
['abc', 'efg']
['abc', 'efg']
中间的‘-’被去掉了

如果用变量，比如说
a=100
def f2(num):
a=num+10

print(a)

f2(a)
print(a)
输出的结果就是：
110
100
a的值没有变，因为a是全局变量
所以说为什么在函数里对列表做操作就会改变函数外的列表？

参考技术A 我觉得是，列表是个一种数据结构，而100是个整数类型的数据，其值是存在在内存里，调用函数可以改变数据结构，但是改变不了内存里的值，你可以试下改变列表里的值。追问

在函数里改变列表里的值，运行函数以后函数外的列表值一样会变

比如：
list2=[2,3,5]

def: f3(the_list):
the_list[0]=1

print(the_list)

f3(list2)
print(list2)

输出的结果是：
[1,3,5]
[1,3,5]
列表里的第一个数字被改变了

追答

在f2里声明global a 会不会有效？

追问

在函数里声明全局变量，当然会改变全局变量的值，奇怪的是不没有声明的列表在函数里还是被当做全局变量修改了，算了，也灭有明确的答案就不深究了。。。。

本回答被提问者和网友采纳

Python的闭包和装饰器

闭包

变量作用域

作用域是程序运行时变量可以被引用的范围。

• 函数内部的变量被称为局部变量，它只能在函数内部中被引用。
• 定义在代码最外层的变量为全局变量，它可以整个代码中被引用。

在函数内部可以访问全局变量，在函数外部不能访问局部变量。

函数嵌套

把一个函数定义在另外一个函数的内部，就是函数嵌套。外边的函数为外层函数，里边的函数为内层函数。

闭包

在函数嵌套中，内层函数对外层函数的局部变量进行了引用，并且外层函数的返回值是内层函数的引用，就构成了一个闭包。

def outer(a, b):
    a = a
    b = b
    def inside():
        print(a+b)
    return inside


function_inside = outer(10, 20)
function_inside()

运行结果:

30

• 函数是一个对象，可以作为返回值被返回，也可以作为参数被传递。
• 函数执行完毕后变量会被回收，但是因为内层函数对外部函数的变量进行了引用，所以即使外层函数执行完毕，变量也不会被回收。

• 修改外层函数的变量使用nonlocal关键字

  创建一个闭包

• 闭包函数必须有函数嵌套
• 内层函数需要引用外层函数中的变量

• 闭包函数必须返回内层函数的引用

注意点

1. 闭包就是函数和函数独有的数据 结合在一起，它比类要轻量级，比一般的函数功能更强。

2. 每次调用外层函数都会创建一个新的闭包对象。

3. 内层函数没有引用的变量会在外层函数执行结束后销毁。

   装饰器

问题提出

1. 当电脑的硬盘空间不够用的时候。
2. 我们能想到的一个办法就是把电脑拆开，再添加一块硬盘。（功能增强）
3. 但是这样做，不仅麻烦，而且改变了原有的电脑结构。（复杂，改变了原有函数）
4. 我们不想做改变原有电脑这么复杂的事情，但是又要储存更多东西。
5. 所以聪明的人就发明了移动硬盘，它可以在不改变原有结构的情况下，又做了功能增强，并且还可以为被多个电脑使用，一台电脑也可以使用多个移动硬盘。（功能增强，方便，不改变原有函数）

而我们需要给函数增加新的功能，又不想改变函数的代码的时候，便用到了 装饰器

python函数

python函数可以被当作参数传递给其他函数。

def say(func):
    func()


def test():
    print("this is a function")


say(test)

运行结果:

this is a function

python的函数可以像变量一样作为返回值返回，被定义在函数内部，而且还可以作为参数被传递。

装饰器

原有函数：

def test():
    print("this is a function")

现在需要给函数增加另外一个功能，限制该函数的调用。

print("use limit")

把功能加入到函数内部

我们可以直接把功能加入到函数内部：

def test():
    print("use limit")
    print("this is a function")


test()

但是如果有函数test1、test2()...也想使用该功能，我们就需要一一修改，这就造成了：

1. 修改工作量巨大
2. 造成大量的重复代码
3. 不利于以后功能的添加

定义一个新的函数

我们可以定义一个新的函数，来完成新增加的功能，把原有函数当作参数传入新函数执行。

def limit(func):
    print("use limit")
    func()


def test():
    print("this is a function")


limit(test)

这样不仅没修改原有的函数，而且增加了新的功能，但是也存在新的问题：

1. 调用的时候，不是在调用 test 而是调用新函数 limit
2. 每次使用 test 函数的时候都需要调用 limit ，如果有已存在的调用，将无法使用新加入的功能，会对代码结构造成破环。

使用装饰器

如果想对函数增加新的功能，并且不修改原有函数，且调用方式不做出改变的话，就要使用装饰器。

简单的装饰器实现：

def limit(func):
    def addlimit():
        print("use limit")
        func()
    return addlimit


def test():
    print("this is a function")


test = limit(test)


test()

函数 limit 就是一个装饰器，它把函数 test 当作参数传入，在内层函数中增加功能后，又把内层函数返回，重新赋值给 test 变量。这里使用到了闭包，外层函数负责接收要修饰的函数，返回修饰后的函数，内层函数赋值修饰传入的函数。

装饰器的进阶

@语法糖

装饰器的使用有一种简写方式，就是在函数定义之前使用 @ +装饰器名字：

def limit(func):
    def addlimit():
        print("use limit")
        func()
    return addlimit

@limit  # 相当于test = limit(test)
def test():
    print("this is a function")


test()

@limit 便相当于 test = limit(test) 。

使用@语法糖 便相当于把定义在后边的函数当作参数传入装饰器。

• 可以省去最后一步再赋值的操作，使用方便。
• 可以不修改原有的函数增加新的功能。
• 不改变函数的调用方式。
• 可以为多个函数进行装饰。

被装饰函数带有参数

def limit(func):
    def addlimit(a, b):
        print("use limit")
        func(a, b)
    return addlimit


@limit
def test(a, b):
    print("I tell you : %s" % a)
    print("I tell you : %s" % b)


a = "hello"
b = "hi"
test(a, b)

因为装饰器调用的是闭包中的内部函数，所以我们先在内部函数接收参数，再传递给被装饰的函数。这样，参数经过传递便被传递给了原有的 test 函数。

但是，如果其他函数不是两个参数，在使用该装饰器的时候，便会运行错误，为了装饰器的通用性，我们可以用不定长位置参数 *args 和关键字参数 **kwargs

使用不定长参数

def limit(func):
    def addlimit(*args, **kwargs):
        print("use limit")
        func(*args, **kwargs)
    return addlimit


@limit
def test(a, b):
    print("I tell you : %s" % a)
    print("I tell you : %s" % b)


@limit
def test1(a, b, c):
    print("I tell you : %s" % a)
    print("I tell you : %s" % b)
    print("I tell you : %s" % c)


a = "hello"
b = "hi"

test(a, b)
print()
test1(a, b, c = "hello world")

运行结果:

use limit
I tell you : hello
I tell you : hi

use limit
I tell you : hello
I tell you : hi
I tell you : hello world

被装饰函数带有返回值

def limit(func):
    def addlimit():
        print("use limit")
        return func()
    return addlimit


@limit
def test():
    print("this is a function")
    return "I tell you: hello"


print(test())

直接在闭包内部函数返回原函数的调用结果即可。

既有参数又有返回值的通用装饰器

def limit(func):
    def addlimit(*args, **kwargs):
        print("use limit")
        return func(*args, **kwargs)
    return addlimit

三层装饰器

三层装饰器可以在原有装饰器的基础上，设置额外的外部变量。

def limit_arg(arg):
    def limit(func):
        def addlimit():
            print("use limit--%s" % arg)
            func()
        return addlimit
    return limit


@limit_arg("hello")
def test():
    print("this is a function")


test()

运行结果：

use limit--hello
this is a function

test() 相当于：

limit_arg("hello")(test)()

类装饰器

装饰器不仅是一个函数，还可以是一个类。

class Limit(object):
    def __init__(self, func):
        self.func = func

    def __call__(self):
        print("use limit")
        self.func()


@Limit
def test():
    print("this is a function")


test()

• 魔术方法 __call__ 方法可以让类的实例对象像函数一样被调用。

• 类装饰器对比函数装饰器具有灵活度大、高内聚、封装性等优点。

多个装饰器

def add_a(func):
    def a():
        return "<a href=‘mxuanli.cn‘>" + func() + "</a>" 
    return a


def add_h1(func):
    def h1():
        return "<h1>" + func() + "</h1>"
    return h1


@add_a
@add_h1
def test():
    return "hello world"


print(test())

运行结果：

<a href=‘mxuanli.cn‘><h1>hello world</h1></a>

• 多个装饰器的时候，执行顺序是从里到外，会先从最内层的开始执行。