程序员必知的 Python 陷阱与缺陷列表


我个人对陷阱的定义是这样的:代码看起来可以工作,但不是以你“想当然“”的方式。如果一段代码直接出错,抛出了异常,我不认为这是陷阱。比如,Python程序员应该都遇到过的“UnboundLocalError”, 示例:


>>> a=1

>>> def func():

...     a+=1

...     print a

...

>>> func()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

File "<stdin>", line 2, in func

UnboundLocalErrorlocal variable 'a' referenced before assignment


对于“UnboundLocalError”,还有更高级的版本:


import random

 

def func(ok):

    if ok:

        a = random.random()

    else:

        import random

        a = random.randint(1, 10)

    return a

 

func(True)# UnboundLocalError: local variable 'random' referenced before assignment


可能对于很多python新手来说,这个Error让人摸不着头脑。但我认为这不算陷阱,因为这段代码一定会报错,而不是默默的以错误的方式运行。不怕真小人,就怕伪君子。我认为缺陷就好比伪君子。


那么Python中哪些真正算得上陷阱呢?



第一:以mutable对象作为默认参数


这个估计是最广为人知的了,Python和其他很多语言一样,提供了默认参数,默认参数确实是个好东西,可以让函数调用者忽略一些细节(比如GUI编程,Tkinter,QT),对于lambda表达式也非常有用。但是如果使用了可变对象作为默认参数,那么事情就不那么愉快了。


>>> def f(lst = []):

...     lst.append(1)

...     return lst

...

>>> f()

[1]

>>> f()

[1, 1]


惊喜不惊喜?!究其原因,python中一切都是对象,函数也不列外,默认参数只是函数的一个属性。而默认参数在函数定义的时候已经求值了。


  Default parameter values are evaluated when the function definition is executed.


stackoverflow上有一个更适当的例子来说明默认参数是在定义的时候求值,而不是调用的时候。

 

>>> import time

>>> def report(when=time.time()):

... return when

...

>>> report()

1500113234.487932

>>> report()

1500113234.487932


python docoment 给出了标准的解决办法:


  A way around this is to use None as the default, and explicitly test for it in the body of the function


>>> def report(when=None):

...  if when is None:

...  when = time.time()

... return when

...

>>> report()

1500113446.746997

>>> report()

1500113448.552873



第二: x += y vs x = x + y


一般来说,二者是等价的,至少看起来是等价的(这也是陷阱的定义 — 看起来都OK,但不一定正确)。


>>> x=1;x += 1;print x

2 

>>> x=1;x = x+1;print x

2

>>> x=[1];x+=[2];print x

[1, 2]

>>> x=[1];x=x+[2];print x

[1, 2]


呃,被光速打脸了?


>>> x=[1];print id(x);x=x+[2];print id(x) 

4357132800

4357132728

>>> x=[1];print id(x);x+=[2];print id(x)

4357132800

4357132800


前者x指向一个新的对象,后者x在原来的对象是修改,当然,那种效果是正确的取决于应用场景。至少,得知道,二者有时候并不一样



 第三,神奇的小括号–()


小括号(parenthese)在各种编程语言中都有广泛的应用,python中,小括号还能表示元组(tuple)这一数据类型, 元组是immutable的序列。


>>> a = (1, 2)

>>> type(a)

<type 'tuple'>

>>> type(())

<type 'tuple'>


但如果只有一个元素呢


>>> a=(1)

>>> type(a)

<type 'int'>


神奇不神奇,如果要表示只有一个元素的元组,正确的姿势是:


>>> a=(1)

>>> type(a)

<type 'int'>



第四:生成一个元素是列表的列表


这个有点像二维数组,当然生成一个元素是字典的列表也是可以的,更通俗的说,生成一个元素是可变对象的序列


很简单嘛:


>>> a[[]] * 10

>>> a

[[], [], [], [], [], [], [], [], [], []]

>>> a[0].append(10)

>>> a[0] 

[10]


看起来很不错,简单明了,but


>>> a[1]

[10]

>>> a

[[10], [10], [10], [10], [10], [10], [10], [10], [10], [10]]


我猜,这应该不是你预期的结果吧,究其原因,还是因为python中list是可变对象,上述的写法大家都指向的同一个可变对象,正确的姿势


>>> a = [[] for _ in xrange(10)]

>>> a[0].append(10)

>>> a

[[10], [], [], [], [], [], [], [], [], []]



第五,在访问列表的时候,修改列表


列表(list)在python中使用非常广泛,当然经常会在访问列表的时候增加或者删除一些元素。比如,下面这个函数,试图删掉列表中为3的倍数的元素:


>>> def modify_lst(lst):

... for idx, elem in enumerate(lst):

... if elem % 3 == 0:

... del lst[idx]


测试一下,


>>> lst = [1,2,3,4,5,6]

>>> modify_lst(lst)

>>> lst

[1, 2, 4, 5]


好像没什么错,不过这只是运气好


>>> lst = [1,2,3,6,5,4]

>>> modify_lst(lst)

>>> lst

[1, 2, 6, 5, 4]


上面的例子中,6这个元素就没有被删除。如果在modify_lst函数中print idx, item就可以发现端倪:lst在变短,但idx是递增的,所以在上面出错的例子中,当3被删除之后,6变成了lst的第2个元素(从0开始)。在C++中,如果遍历容器的时候用迭代器删除元素,也会有同样的问题。


如果逻辑比较简单,使用list comprehension是不错的注意



 第六,闭包与lambda


这个也是老生长谈的例子,在其他语言也有类似的情况。先看一个例子:


>>> def create_multipliers():

...  return [lambda x:i*x for i in range(5)]

...

>>> for multiplier in create_multipliers():

... print multiplier(2)

...


create_multipliers函数的返回值时一个列表,列表的每一个元素都是一个函数 -- 将输入参数x乘以一个倍数i的函数。预期的结果时0,2,4,6,8. 但结果是5个8,意外不意外。


由于出现这个陷阱的时候经常使用了lambda,所以可能会认为是lambda的问题,但lambda表示不愿意背这个锅。问题的本质在与python中的属性查找规则,LEGB(local,enclousing,global,bulitin),在上面的例子中,i就是在闭包作用域(enclousing),而Python的闭包是 迟绑定 , 这意味着闭包中用到的变量的值,是在内部函数被调用时查询得到的。


 解决办法也很简单,那就是变闭包作用域为局部作用域。


>>> def create_multipliers():

... return [lambda x, i = i:i*x for i in range(5)]

...



第七,定义__del__


大多数计算机专业的同学可能都是先学的C、C++,构造、析构函数的概念应该都非常熟。于是,当切换到python的时候,自然也想知道有没有相应的函数。比如,在C++中非常有名的RAII,即通过构造、析构来管理资源(如内存、文件描述符)的声明周期。那在python中要达到同样的效果怎么做呢,即需要找到一个对象在销毁的时候一定会调用的函数,于是发现了__init__, __del__函数,可能简单写了两个例子发现确实也能工作。但事实上可能掉进了一个陷阱,在python documnet是有描述的:


  Circular references which are garbage are detected when the option cycle detector is enabled (it’s on by default), but can only be cleaned up if there are no Python-level __del__() methods involved.


简单来说,如果在循环引用中的对象定义了__del__,那么python gc不能进行回收,因此,存在内存泄漏的风险



第八,不同的姿势import同一个module


示例在stackoverflow的例子上稍作修改,假设现在有一个package叫mypackage,里面包含三个python文件:mymodule.py, main.py, __init__.py。mymodule.py代码如下:


l = []

class A(object):

    pass


main.py代码如下:


def add(x):

    from mypackage import mymodule

    mymodule.l.append(x)

    print "updated list",mymodule.l, id(mymodule)

 

def get():

    import mymodule

    print 'module in get', id(mymodule)

    return mymodule.l

 

if __name__ == '__main__':

    import sys

    sys.path.append('../')

    add(1)

    

    ret = get()

    print "lets check", ret


运行python main.py,结果如下:


updated list [1] 4406700752

module in get 4406700920

lets check []


 从运行结果可以看到,在add 和 get函数中import的mymodule不是同一个module,ID不同。当然,在python2.7.10中,需要main.py的第13行才能出现这样的效果。你可能会问,谁会写出第13行这样的代码呢?事实上,在很多项目中,为了import的时候方便,会往sys.path加入一堆路径。那么在项目中,大家同意一种import方式就非常有必要了



第九,python升级


python3.x并不向后兼容,所以如果从2.x升级到3.x的时候得小心了,下面列举两点:


在python2.7中,range的返回值是一个列表;而在python3.x中,返回的是一个range对象。


map()、filter()、 dict.items()在python2.7返回列表,而在3.x中返回迭代器。当然迭代器大多数都是比较好的选择,更加pythonic,但是也有缺点,就是只能遍历一次。在instagram的分享中,也提到因为这个导致的一个坑爹的bug。



 第十,gil


以GIL结尾,因为gil是Python中大家公认的缺陷!


从其他语言过来的同学可能看到python用threading模块,拿过来就用,结果发现效果不对啊,然后就会喷,什么鬼。



总结:


毫无疑问的说,python是非常容易上手,也非常强大的一门语言。python非常灵活,可定制化很强。同时,也存在一些陷阱,搞清楚这些陷阱能够更好的掌握、使用这么语言。本文列举了一些python中的一些缺陷,这是一份不完全列表,欢迎大家补充。


来源:xybaby

www.cnblogs.com/xybaby/p/7183854.html


  • 0
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 《程序员必知的硬核知识大全》是一本面向程序员的综合性知识手册,涵盖了各个领域的关键知识点,旨在帮助程序员提升技术水平和解决实际问题。该书以PDF格式出版,便于读者在电脑、手机等设备上随时查阅。 该书内容包括以下几个方面的硬核知识: 1. 编程语言知识:介绍了主流的编程语言,如Java、C++、Python等,包括语法、数据结构、算法等方面的内容。 2. 操作系统和计算机原理:详细介绍了操作系统的基本原理和常见问题解决方法,以及计算机组成原理和计算机网络等相关知识。 3. 数据库和存储知识:讲解了数据库设计和管理的基本原理,介绍了关系型数据库如MySQL和非关系型数据库如MongoDB等的使用方法和优化技巧。 4. 网站和网络开发知识:包括Web开发的基本原理、前后端开发技术、网络安全和性能优化等方面的内容。 5. 软件工程和开发方法论:介绍了软件工程的基本概念和常用开发方法,包括敏捷开发、测试驱动开发和持续集成等。 6. 设计模式和架构知识:详细介绍了常用的设计模式和软件架构,帮助程序员设计可维护、可扩展和高效的软件系统。 除了以上几个方面的内容,该书还涵盖了其他与程序员工作密切相关的技术和知识,如版本控制、软件部署、性能调优等。《程序员必知的硬核知识大全》适合本科或者有一定编程经验的程序员阅读,对于提高技术实力和职业发展都有很大帮助。 ### 回答2: "程序员必知的硬核知识大全 pdf"是一份提供程序员必备知识的电子书,PDF格式可以方便地在各种设备上阅读。这本书包含了各个方面的硬核知识,帮助程序员提高技术能力和解决问题的能力。 这本电子书的内容包括了数据结构和算法,编程语言,操作系统,网络通信,数据库管理等各方面的知识。对于程序员而言,这些都是非常重要的基础知识,能够帮助他们理解和设计高效的程序。 在数据结构和算法部分,程序员将学习到各种基础的数据结构,如数组、链表、栈和队列,以及常见的算法,如排序和搜索算法。这些知识对于程序的效率和性能优化至关重要。 编程语言部分将介绍多种编程语言,如C、C++、Java和Python等。这些语言在不同的领域有各自的优点和适用范围,程序员需要了解它们的特点和使用方法,以便在开发项目时选择合适的语言。 操作系统部分将深入讲解操作系统的原理和设计。程序员将了解到进程管理、内存管理、文件系统等重要概念,这些对于编写具有高可靠性和高性能的程序至关重要。 网络通信部分将介绍计算机网络的基本原理和常见的协议,如TCP/IP和HTTP等。程序员需要理解网络通信的基础知识,以便与其他系统进行数据交换和通信。 数据库管理部分将详细介绍关系型数据库和非关系型数据库的原理和使用方法。程序员需要了解数据库的设计和优化,以提高数据的存储和检索效率。 总之,这本电子书涵盖了程序员必备的硬核知识,对于提高他们的技术能力和解决问题的能力非常有帮助。 ### 回答3: 《程序员必知的硬核知识大全》是一本汇集了程序员必备的核心知识的书籍,可以帮助程序员提升自己的技术水平。这本书涵盖了计算机科学的各个领域和重要概念,包括数据结构与算法、操作系统、编程语言、网络通信、数据库、Web开发、软件工程等。 在数据结构与算法部分,书中介绍了常用的数据结构如链表、栈、队列以及各种排序和搜索算法,帮助程序员理解和应用这些经典的算法。在操作系统方面,书中讲解了进程、线程、内存管理、文件系统等重要概念,帮助程序员深入了解计算机系统的工作原理。 在编程语言方面,书中列举了多种编程语言的特性和应用场景,如C++、Java、Python等,有助于程序员选择适合自己的编程语言并掌握其特性。在网络通信部分,书中介绍了TCP/IP协议、HTTP协议等重要的网络通信协议和技术,帮助程序员理解网络通信的基本原理。 此外,书中还介绍了数据库的相关知识,包括关系数据库、SQL语言、数据备份与恢复等内容,有助于程序员设计和管理数据库。在Web开发方面,书中介绍了前端开发、后端开发、服务器部署等关键技术,帮助程序员构建高效、安全的Web应用程序。 最后,在软件工程方面,书中讲解了软件开发的生命周期、需求分析、设计模式、测试和持续集成等内容,有助于程序员理解和掌握软件开发过程中的重要环节。 总的来说,这本《程序员必知的硬核知识大全》提供了一站式的学习资料,涵盖了程序员必备的核心知识,可以帮助程序员系统地学习和应用这些知识,提升自己的技术能力。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值