记录遇到的Python陷阱和注意点

来源：http://www.cnblogs.com/wilber2013/p/5178620.html

最近使用Python的过程中遇到了一些坑，例如用datetime.datetime.now()这个可变对象作为函数的默认参数，模块循环依赖等等。

在此记录一下，方便以后查询和补充。

避免可变对象作为默认参数

在使用函数的过程中，经常会涉及默认参数。在Python中，当使用可变对象作为默认参数的时候，就可能产生非预期的结果。

下面看一个例子：

def append_item(a = 1, b = []):b.append(a)print bappend_item(a=1)
append_item(a=3)
append_item(a=5)

结果为：

[1]
[1, 3]
[1, 3, 5]

从结果中可以看到，当后面两次调用append_item函数的时候，函数参数b并没有被初始化为[]，而是保持了前面函数调用的值。

之所以得到这个结果，是因为在Python中，一个函数参数的默认值，仅仅在该函数定义的时候，被初始化一次。

下面看一个例子证明Python的这个特性：

class Test(object):  def __init__(self):  print("Init Test")  def arg_init(a, b = Test()):  print(a)  arg_init(1)  
arg_init(3)  
arg_init(5)

结果为：

Init Test
1
3
5

从这个例子的结果就可以看到，Test类仅仅被实例化了一次，也就是说默认参数跟函数调用次数无关，仅仅在函数定义的时候被初始化一次。

可变默认参数的正确使用

对于可变的默认参数，我们可以使用下面的模式来避免上面的非预期结果：

def append_item(a = 1, b = None):if b is None:b = []b.append(a)print bappend_item(a=1)
append_item(a=3)
append_item(a=5)

结果为：

[1]
[3]
[5]

Python中的作用域

Python的作用域解析顺序为Local、Enclosing、Global、Built-in，也就是说Python解释器会根据这个顺序解析变量。

看一个简单的例子：

global_var = 0def outer_func():outer_var = 1def inner_func():inner_var = 2print "global_var is :", global_varprint "outer_var is :", outer_varprint "inner_var is :", inner_varinner_func()outer_func()

结果为：

global_var is : 0
outer_var is : 1
inner_var is : 2

在Python中，关于作用域有一点需要注意的是，在一个作用域里面给一个变量赋值的时候，Python会认为这个变量是当前作用域的本地变量。

对于这一点也是比较容易理解的，对于下面代码var_func中给num变量进行了赋值，所以此处的num就是var_func作用域的本地变量。

num = 0def var_func():num = 1print "num is :", numvar_func()

问题一

但是，当我们通过下面的方式使用变量的时候，就会产生问题了：

num = 0def var_func():print "num is :", numnum = 1var_func()

结果如下，之所以产生这个错误，就是因为我们在var_func中给num变量进行了赋值，所以Python解释器会认为num是var_func作用域的本地变量，但是当代码执行到print "num is :", num语句的时候，num还是未定义。

UnboundLocalError: local variable 'num' referenced before assignment

问题二

上面的错误还是比较明显的，还有一种比较隐蔽的错误形式如下：

li = [1, 2, 3]def foo():li.append(4)print lifoo()def bar():li +=[5]print libar()

代码的结果为：

[1, 2, 3, 4]
UnboundLocalError: local variable 'li' referenced before assignment

在foo函数中，根据Python的作用域解析顺序，该函数中使用了全局的li变量；但是在bar函数中，对li变量进行了赋值，所以li会被当作bar作用域中的变量。

对于bar函数的这个问题，可以通过global关键字。

li = [1, 2, 3]def foo():li.append(4)print lifoo()def bar():global lili +=[5]print libar()

类属性隐藏

在Python中，有类属性和实例属性。类属性是属于类本身的，被所有的类实例共享。

类属性可以通过类名访问和修改，也可以通过类实例进行访问和修改。但是，当实例定义了跟类同名的属性后，类属性就被隐藏了。

看下面这个例子：

class Student(object):books = ["Python", "JavaScript", "CSS"]def __init__(self, name, age):self.name = nameself.age = agepasswilber = Student("Wilber", 27)
print "%s is %d years old" %(wilber.name, wilber.age)print Student.books
print wilber.bookswilber.books = ["HTML", "AngularJS"]print Student.books
print wilber.booksdel wilber.booksprint Student.books
print wilber.books

代码的结果如下，起初wilber实例可以直接访问类的books属性，但是当实例wilber定义了名称为books的实例属性之后，wilber实例的books属性就“隐藏”了类的books属性；当删除了wilber实例的books属性之后，wilber.books就又对应类的books属性了。

Wilber is 27 years old
['Python', 'JavaScript', 'CSS']
['Python', 'JavaScript', 'CSS']
['Python', 'JavaScript', 'CSS']
['HTML', 'AngularJS']
['Python', 'JavaScript', 'CSS']
['Python', 'JavaScript', 'CSS']

当在Python值使用继承的时候，也要注意类属性的隐藏。对于一个类，可以通过类的__dict__属性来查看所有的类属性。

当通过类名来访问一个类属性的时候，会首先查找类的__dict__属性，如果没有找到类属性，就会继续查找父类。但是，如果子类定义了跟父类同名的类属性后，子类的类属性就会隐藏父类的类属性。

看一个例子：

class A(object):count = 1    
class B(A):pass        
class C(A):pass            
print A.count, B.count, C.count      
B.count = 2
print A.count, B.count, C.count      
A.count = 3
print A.count, B.count, C.count     
print B.__dict__
print C.__dict__

结果如下，当类B定义了count这个类属性之后，就会隐藏父类的count属性：

1 1 1
1 2 1
3 2 3
{'count': 2, '__module__': '__main__', '__doc__': None}
{'__module__': '__main__', '__doc__': None}

一般来说，在Python中，类实例属性的访问规则算是比较直观的。

      但是，仍然存在一些不是很直观的地方，特别是对C++和Java程序员来说，更是如此。

      在这里，我们需要明白以下几个地方：

      1.Python是一门动态语言，任何实体都可以动态地添加或删除属性。

      2.一个类定义了一个作用域。

      3.类实例也引入了一个作用域，这与相应类定义的作用域不同。

      4.在类实例中查找属性的时候，首先在实例自己的作用域中查找，如果没有找到，则再在类定义的作用域中查找。

      5.在对类实例属性进行赋值的时候，实际上会在类实例定义的作用域中添加一个属性（如果还不存在的话），并不会影响到相应类中定义的同名属性。

      下面看一个例子，加深对上述几点的理解：

class A:cls_i = 0cls_j = {}def __init__(self):self.instance_i = 0self.instance_j = {}
在这里，我们先定义类A的一个实例a，然后再看看类A的作用域和实例a的作用域中分别有什么： 
>>> a = A()
>>> a.__dict__
{'instance_j': {}, 'instance_i': 0}
>>> A.__dict__
{'__init__': , '__module__': '__main__', 'cls_i': 0, 'cls_j': {}, '__doc__': None}

我们看到，a的作用域中有instance_i和instance_j，A的作用域中有cls_i和cls_j。

      我们再来看看名字查找是如何发生的：

>>> a.cls_i
0
>>> a.instance_i
0
在查找cls_i的时候，实例a的作用域中是没有它的，却在A的作用域中找到了它；在查找instance_i的时候，直接可在a的作用域中找到它。如果我们企图通过实例a来修改cls_i的值，那会怎样呢：
>>> a.cls_i = 1
>>> a.__dict__
{'instance_j': {}, 'cls_i': 1, 'instance_i': 0}
>>> A.__dict__
{'__init__': , '__module__': '__main__', 'cls_i': 0, 'cls_j': {}, '__doc__': None}

我们可以看到，a的作用域中多了一个cls_i属性，其值为1；同时，我们也注意到A作用域中的cls_i属性的值仍然为0；在这里，我们其实是增加了一个实例属性，并没有修改到类属性。

       如果我们通过实例a操纵cls_j中的数据（注意不是cls_j本身），又会怎么样呢：

>>> a.cls_j['a'] = 'a'
>>> a.__dict__
{'instance_j': {}, 'cls_i': 1, 'instance_i': 0}
>>> A.__dict__
{'__init__': , '__module__': '__main__', 'cls_i': 0, 'cls_j': {'a': 'a'}, '__doc__': None}

我们可以看到a的作用域没有发生什么变化，但是A的作用域发生了一些变化，cls_j中的数据发生了变化。

      实例的作用域发生变化，并不会影响到该类的其它实例，但是类的作用域发生变化，则会影响到该类的所有实例，包括在这之前创建的实例：

>>> A.cls_k = 0
>>> i.cls_k
0
http://www.cnblogs.com/frydsh/p/3194710.html

tuple是“可变的”

在Python中，tuple是不可变对象，但是这里的不可变指的是tuple这个容器总的元素不可变（确切的说是元素的id），但是元素的值是可以改变的。

tpl = (1, 2, 3, [4, 5, 6])
print id(tpl)
print id(tpl[3])
tpl[3].extend([7, 8])
print tpl
print id(tpl)
print id(tpl[3])

代码结果如下，对于tpl对象，它的每个元素都是不可变的，但是tpl[3]是一个list对象。也就是说，对于这个tpl对象，id(tpl[3])是不可变的，但是tpl[3]确是可变的。

36764576
38639896
(1, 2, 3, [4, 5, 6, 7, 8])
36764576
38639896

Python的深浅拷贝

在对Python对象进行赋值的操作中，一定要注意对象的深浅拷贝，一不小心就可能踩坑了。

当使用下面的操作的时候，会产生浅拷贝的效果：

  • 使用切片[:]操作
  • 使用工厂函数（如list/dir/set）
  • 使用copy模块中的copy()函数

使用copy模块里面的浅拷贝函数copy()：

import copywill = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.copy(will)print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

使用copy模块里面的深拷贝函数deepcopy()：

import copywill = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.deepcopy(will)print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

模块循环依赖

在Python中使用import导入模块的时候，有的时候会产生模块循环依赖，例如下面的例子，module_x模块和module_y模块相互依赖，运行module_y.py的时候就会产生错误。

# module_x.py
import module_ydef inc_count():module_y.count += 1print module_y.count# module_y.py
import module_xcount = 10def run():module_x.inc_count()run()

其实，在编码的过程中就应当避免循环依赖的情况，或者代码重构的过程中消除循环依赖。

当然，上面的问题也是可以解决的，常用的解决办法就是把引用关系搞清楚，让某个模块在真正需要的时候再导入（一般放到函数里面）。

对于上面的例子，就可以把module_x.py修改为如下形式，在函数内部导入module_y：

# module_x.py
def inc_count():import module_ymodule_y.count += 1print module_y.count


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/497091.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

归并排序(c++)

归并排序(c++)

归并排序 归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列&#x…
阅读更多...
js 操作 iframe

js 操作 iframe

//页面内有两个iframe<table width"100%"> <tr width"100%"> <td width"100%"> <iframe id"iframeNum1" src"a.aspx" style"display:block;" width"100%"…
阅读更多...
五大风口产业全景手绘图（新能源汽车、人工智能等）

五大风口产业全景手绘图（新能源汽车、人工智能等）

来源&#xff1a;一览众车概要&#xff1a;五大风口产业全景手绘图&#xff08;新能源汽车、人工智能等&#xff09;一、新能源汽车二、人工智能三、住房租赁住房租赁产业蕴含着哪些发展机会&#xff1f;各参与方的竞争格局如何&#xff1f;未来人们租房会更便利吗&#xff1f;…
阅读更多...
Python进阶之“属性（property）”详解

Python进阶之“属性（property）”详解

来源&#xff1a;http://python.jobbole.com/80955/ 参考&#xff1a;廖雪峰的官方网站 使用__slots__ 参考&#xff1a;廖雪峰的官方网站 使用 property Python中有一个被称为属性函数(property)的小概念&#xff0c;它可以做一些有用的事情。在这篇文章中&#xff0c;我们…
阅读更多...
冒泡排序(c++)

冒泡排序(c++)

冒泡排序&#xff08;Bubble Sort&#xff09; 是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列&#xff0c;依次比较两个相邻的元素&#xff0c;如果顺序&#xff08;如从大到小、首字母从Z到A&#xff09;错误就把他们交换过来。走访元素的工作是重复…
阅读更多...
微软研发致胜策略读书笔记（转）

微软研发致胜策略读书笔记（转）

创建人&#xff1a;X公司程序员 yunshichen 这篇是我读《微软研发致胜策略》后整理的笔记。身为一个软件开发部门的主管&#xff0c;你的职责是什么&#xff1f;单单完成项目是不足够的&#xff0c;如果你的目标是这样&#xff0c;那么你会做错很多事。我认为准确的表述应该是…
阅读更多...
原型模式详解

原型模式详解

PrototypeClass.java public class PrototypeClass implements Cloneable {Overridepublic PrototypeClass clone() {try {final PrototypeClass instance (PrototypeClass) super.clone();return instance;} catch (CloneNotSupportedException e) {return null;}} } 1、构…
阅读更多...
python 结巴分词(jieba)学习

python 结巴分词(jieba)学习

来源&#xff1a;http://www.gowhich.com/blog/147?utm_sourcetuicool&utm_mediumreferral 源码下载的地址&#xff1a;https://github.com/fxsjy/jieba 演示地址&#xff1a;http://jiebademo.ap01.aws.af.cm/ 特点 1&#xff0c;支持三种分词模式&#xff1a; a,精确模式…
阅读更多...
选择排序(c++)

选择排序(c++)

选择排序 选择排序&#xff08;Selection sort&#xff09;是一种简单直观的排序算法。它的工作原理是&#xff1a;第一次从待排序的数据元素中选出最小&#xff08;或最大&#xff09;的一个元素&#xff0c;存放在序列的起始位置&#xff0c;然后再从剩余的未排序元素中寻找…
阅读更多...
隐藏系统用户

隐藏系统用户

/Files/chinhr/HideAdmin0.rar转载于:https://www.cnblogs.com/chinhr/archive/2007/07/11/814743.html
阅读更多...
人机交互与智能的思考

人机交互与智能的思考

来源&#xff1a; 人机与认知实验室概要&#xff1a;在过去的20年里&#xff0c;人工智能一直专注于围绕建设智能体所产生的问题&#xff0c;即在特定的情境下&#xff0c;可以感知并行动的各种系统,在这种情况下&#xff0c;智能是一个与统计学,和经济学相关的理性概念。1.智能…
阅读更多...
享元模式详解

享元模式详解

SignInfo.java public class SignInfo {/*** 报名人员ID.*/private String id;/*** 考试地点.*/private String location;/*** 考试科目.*/private String subject;/*** 邮寄地址.*/private String postAddress;/*** 获取id.* return the id*/public String getId() {return i…
阅读更多...
Python 多进程 multiprocessing 使用示例

Python 多进程 multiprocessing 使用示例

multiprocessing 文档&#xff1a;https://docs.python.org/zh-cn/3.10/library/multiprocessing.html Process、Lock、Semaphore、Queue、Pipe、Pool&#xff1a;https://cuiqingcai.com/3335.html 把一个多线程改成多进程&#xff0c;主要有下面几种方法&#xff1a; subpro…
阅读更多...
IDC：2018年中国制造业十大预测

IDC：2018年中国制造业十大预测

来源&#xff1a;先进制造业概要&#xff1a;2017年&#xff0c;中国制造业的竞争日趋激烈。生产成本压力增大以及经济下行趋势迫使中国制造企业的两极分化更加严重。日前&#xff0c;IDC发布了《IDC FutureScape&#xff1a;全球制造业2018预测——中国启示》&#xff0c;报告…
阅读更多...
插入排序(c++)

插入排序(c++)

插入排序 插入排序的工作方式像许多人排序一手扑克牌。开始时&#xff0c;我们的左手为空并且桌子上的牌面向下。然后&#xff0c;我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置&#xff0c;我们从右到左将它与已在手中的每张牌进行比较。拿…
阅读更多...
Python 操作 redis

Python 操作 redis

官网命令&#xff08;英文&#xff09;列表&#xff1a;http://redis.io/commands Redis 教程&#xff1a;http://www.redis.net.cn/tutorial/3501.html Redis 命令参考&#xff1a;http://redisdoc.com/index.html Windows 中 redis 的下载及安装、设置&#xff1a;https://…
阅读更多...
使用wxWidgets编程——第一步

使用wxWidgets编程——第一步

使用wxWidgets编程——第一步 转载于:https://www.cnblogs.com/zhangyang/archive/2007/07/17/821537.html
阅读更多...
redis调优 -- 内存碎片

redis调优 -- 内存碎片

最近查看了一下redis运行状况&#xff0c;发现公司测试服务器的redis内存不太够用&#xff0c;但是实际占用内存的数据量其实不大&#xff0c;以前也没有这种情况&#xff0c;之前在cache层新增了一个防刷积分任务的逻辑才会这样&#xff0c;搜索一下原因&#xff0c;发现原来是…
阅读更多...
2018 物联网产业分布展望：基础设施将到位

2018 物联网产业分布展望：基础设施将到位

来源&#xff1a;36氪概要&#xff1a;在过去一年多的时间里&#xff0c;关于初创企业失败以及安全问题令人担忧等报道内容一直笼罩着物联网行业。在过去一年多的时间里&#xff0c;关于初创企业失败以及安全问题令人担忧等报道内容一直笼罩着物联网行业。但其实&#xff0c;物…
阅读更多...
深入理解C# 3.x的新特性（2）：Extension Method[下篇]

深入理解C# 3.x的新特性（2）：Extension Method[下篇]

四、Extension Method的本质 通过上面一节的介绍&#xff0c;我们知道了在C#中如何去定义一个Extension Method&#xff1a;它是定义在一个Static class中的、第一个Parameter标记为this关键字的Static Method。在这一节中&#xff0c;我们来进一步认识Extension Method。 和C#…
阅读更多...
最新文章

Copyright @ 2022~2023