• 转载
  • 后端开发
  • 初学python,我给你总结了几个常见的错误

    2020.04.17 14:06发布

    6166人阅读

    0人评论



    python技巧


    坚强的del


    class SomeClass:
    def __del__(self):
    print("Deleted!")
    x = SomeClass()
    y = x
    del x
    del y

    # 输出:Deleted!

    你发现了几个问题?第一、一个变量删除了两次竟然没有报错。第二、执行了两次删除只有一次打印了删除操作。修改一下上面的代码


    x = SomeClass()
    y = x
    print(dir())
    # 输出:['SomeClass', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'x', 'y']
    del x
    print(y)
    # 输出:<__main__.SomeClass object at 0x108f55890>
    print(dir())

    # 输出:
    del y
    print(dir())



    Deleted!
    ['SomeClass', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

    可以看到x、y是两个变量,但是他们指向了同一个对象,Python使用引用计数进行内存管理,所以当x=SomeClass()的时候,对象上的指针引用计数从0变1,y=x的时候,引用计数加1变成2.



    • del x 并不会立刻调用 x.__del__().

    • 每当遇到 del x, Python 会将对象的引用数减1, 当对象的引用计数减到0时才会真正的删除对象,因此调用x.__del__().


    迭代列表时删除元素


    list_1 = [1, 2, 3, 4]
    list_2 = [1, 2, 3, 4]
    list_3 = [1, 2, 3, 4]
    list_4 = [1, 2, 3, 4]

    for idx, item in enumerate(list_1):
    del item

    for idx, item in enumerate(list_2):
    list_2.remove(item)

    for idx, item in enumerate(list_3[:]):
    list_3.remove(item)

    for idx, item in enumerate(list_4):
    list_4.pop(idx)

    print(list_1)
    # 输出:[1, 2, 3, 4]
    print(list_2)
    # 输出:[2, 4]
    print(list_3)
    # 输出:[]
    print(list_4)
    # 输出:[2, 4]

    我们先看一下del, remove和pop的不同:



    • del var_name 只是从本地或全局命名空间中删除了var_name (这就是为什么 list_1 没有受到影响).

    • remove 会删除第一个匹配到的指定值, 而不是特定的索引, 如果找不到值则抛出ValueError 异常.

    • pop 则会删除指定索引处的元素并返回它, 如果指定了无效的索引则抛出 IndexError 异常.


    list_2/list_4为什么输出[2, 4]


    列表迭代是按索引进行的, 所以当我们从list_2或list_4中删除1时, 列表的内容就变成了 [2, 3, 4]. 剩余元素会依次位移, 也就是说, 2 的索引会变为 0, 3 会变为 1. 由于下一次迭代将获取索引为 1 的元素 (即 3), 因此 2 将被彻底的跳过. 类似的情况会交替发生在列表中的每个元素上.


    list_3为什么会输出[]


    这个好像比较符合我们的预期值,这里写法有些不一样,我们看一看下面代码


    a = [1, 2, 3, 4]
    print(id(a))
    # 输出:4523069920
    print(id(a[:]))
    # 输出:4523072480

    看出来问题了吗?切片操作会创建一个新对象,所以不存在上面的问题


    循环变量泄漏!


    for x in range(7):
    if x == 6:
    print(x, ': for x inside loop')
    print(x, ': x in global')
    # 输出:6 : for x inside loop
    # 输出:6 : x in global

    在 Python 中, for 循环使用所在作用域并在结束后保留定义的循环变量. 如果我们曾在全局命名空间中定义过循环变量. 在这种情况下, 它会重新绑定现有变量。但是要注意列表推导式里的局部变量是不能在外部使用的。


    print([x for x in range(5)])
    # 输出:[0, 1, 2, 3, 4]
    print(x, ': x in global')
    # 输出:
    # Traceback (most recent call last):
    # NameError: name 'x' is not defined

    当心默认的可变参数!


    def some_func(default_arg=[]):
    default_arg.append("some_string")
    return default_arg

    print(some_func())
    # 输出:['some_string']
    print(some_func())
    # 输出:['some_string', 'some_string']
    print(some_func())
    # 输出:['some_string', 'some_string', 'some_string']
    print(some_func())
    # 输出:['some_string', 'some_string', 'some_string', 'some_string']

    这里必须要敲黑板、敲黑板、敲黑板,在很多编程语言中函数都有默认参数,但是Python中默认参数不一样,因为python中默认参数是存储在一个独立的区域,当函数被定义的时候,默认参数被创建,直到程序终止。当我们默认参数为不可变对象时,与其他语言类似。但是如果默认参数为不可变对象时,每一次的变化就会被记住,这种问题非常严重,经常发生问题的时候我们找不到问题点。所以我们建议大家一定不要把可变对象设置为默认参数,可以使用如下方式进行修改:


    def some_func(default_arg=None):
    if not default_arg:
    default_arg = []
    default_arg.append("some_string")
    return default_arg
    print(some_func())
    # 输出:['some_string']
    print(some_func())
    # 输出:['some_string']

    同人不同命!


    a = [1, 2, 3, 4]
    b = a
    a = a + [5, 6, 7, 8]
    print(a)
    # 输出:[1, 2, 3, 4, 5, 6, 7, 8]
    print(b)
    # 输出:[1, 2, 3, 4]

    这里牵扯到python中赋值运算符的本质问题,后面直播或者出视频来解释一下,一定要记住:赋值运算符等同于创建新对象。这一点也很重要,主要是针对定位问题。



    • a += b 并不总是与 a = a + b 表现相同. 类实现 op= 运算符的方式 也许 是不同的, 列表就是这样做的.

    • 表达式 a = a + [5,6,7,8] 会生成一个新列表, 并让 a 引用这个新列表, 同时保持 b 不变.

    • 表达式 a += [5,6,7,8] 实际上是使用的是 "extend" 函数, 所以 a 和 b 仍然指向已被修改的同一列表.


    外部作用域变量


    a = 1
    def some_func():
    return a

    def another_func():
    a += 1
    return a
    print(some_func())
    # 输出:1
    print(another_func())
    # 输出:
    # Traceback (most recent call last):
    # another_func()
    # a += 1
    # UnboundLocalError: local variable 'a' referenced before assignment


    • 当你在作用域中对变量进行赋值时, 变量会变成该作用域内的局部变量. 因此 a 会变成 another_func 函数作用域中的局部变量, 但它在函数作用域中并没有被初始化, 所以会引发错误.

    • 可以阅读这个简短却很棒的指南, 了解更多关于 Python 中命名空间和作用域的工作原理.

    • 想要在 another_func 中修改外部作用域变量 a 的话, 可以使用 global 关键字


    def anothre_func():
    global a
    a += 1
    return a



    文章来源于网络,版权归原作者所有,内容为作者个人观点,文章仅供学习,如有侵权请联系客服删除,本站拥有对此声明的最终解释权。



  • python技巧
  • 后端开发
  • 举报文章

  • 收藏博客:

  • 分享至:
  • 添加评论

    请先登录再评论...

    登录

    评论列表(条评论)

    没有更多评论了