python程序编写应注意哪些问题_Python程序员鲜为人知但你应该知道的17个问题
一、不要使用可变对象作为函数默认值
In [1]: def append_to_list(value, def_list=[]):
...: def_list.append(value)
...: return def_list
...:
In [2]: my_list = append_to_list(1)
In [3]: my_list
Out[3]: [1]
In [4]: my_other_list = append_to_list(2)
In [5]: my_other_list
Out[5]: [1, 2] # 看到了吧,其实我们本来只想生成[2] 但是却把第一次运行的效果页带了进来
In [6]: import time
In [7]: def report_arg(my_default=time.time()):
...: print(my_default)
...:
In [8]: report_arg() # 第一次执行
1399562371.32
In [9]: time.sleep(2) # 隔了2秒
In [10]: report_arg()
1399562371.32 # 时间竟然没有变
这2个例子说明了什么? 字典,集合,列表等等对象是不适合作为函数默认值的. 因为这个默认值实在函数建立的时候就生成了, 每次调用都是用了这个对象的”缓存”. 我在上段时间的分享python高级编程也说到了这个问题,这个是实际开发遇到的问题,好好检查你学过的代码, 也许只是问题没有暴露
可以这样改:
def append_to_list(element, to=None):
if to is None:
to = []
to.append(element)
return to
二、生成器不保留迭代过后的结果
In [12]: gen = (i for i in range(5))
In [13]: 2 in gen
Out[13]: True
In [14]: 3 in gen
Out[14]: True
In [15]: 1 in gen
Out[15]: False # 1为什么不在gen里面了? 因为调用1->2,这个时候1已经不在迭代器里面了,被按需生成过了
In [20]: gen = (i for i in range(5))
In [21]: a_list = list(gen) # 可以转化成列表,当然a_tuple = tuple(gen) 也可以
In [22]: 2 in a_list
Out[22]: True
In [23]: 3 in a_list
Out[23]: True
In [24]: 1 in a_list # 就算循环过,值还在
Out[24]: True
三、lambda在闭包中会保存局部变量
In [29]: my_list = [lambda: i for i in range(5)]
In [30]: for l in my_list:
....: print(l())
....:
4
4
4
4
4
这个问题还是上面说的python高级编程中说过具体原因. 其实就是当我赋值给my_list的时候,lambda表达式就执行了i会循环,直到 i =4,i会保留
但是可以用生成器
In [31]: my_gen = (lambda: n for n in range(5))
In [32]: for l in my_gen:
....: print(l())
....:
0
1
2
3
4
也可以坚持用list:
In [33]: my_list = [lambda x=i: x for i in range(5)] # 看我给每个lambda表达式赋了默认值
In [34]: for l in my_list:
....: print(l())
....:
0
1
2
3
4
有点不好懂是吧,在看看python的另外一个魔法:
In [35]: def groupby(items, size):
....: return zip(*[iter(items)]*size)
....:
In [36]: groupby(range(9), 3)
Out[36]: [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
一个分组的函数,看起来很不好懂,对吧? 我们来解析下这里
In [39]: [iter(items)]*3
Out[39]:
[,
,
] # 看到了吧, 其实就是把items变成可迭代的, 重复三回(同一个对象哦), 但是别忘了,每次都.next(), 所以起到了分组的作用
In [40]: [lambda x=i: x for i in range(5)]
Out[40]:
[>,
>,
>,
>,
>] # 看懂了吗?
四、在循环中修改列表项
In [44]: a = [1, 2, 3, 4, 5]
In [45]: for i in a:
....: if not i % 2:
....: a.remove(i)
....:
In [46]: a
Out[46]: [1, 3, 5] # 没有问题
In [50]: b = [2, 4, 5, 6]
In [51]: for i in b:
....: if not i % 2:
....: b.remove(i)
....:
In [52]: b
Out[52]: [4, 5] # 本来我想要的结果应该是去除偶数的列表
思考一下,为什么 – 是因为你对列表的remove,影响了它的index
In [53]: b = [2, 4, 5, 6]
In [54]: for index, item in enumerate(b):
....: print(index, item)
....: if not item % 2:
....: b.remove(item)
....:
(0, 2) # 这里没有问题 2被删除了
(1, 5) # 因为2被删除目前的列表是[4, 5, 6], 所以索引list[1]直接去找5, 忽略了4
(2, 6)
五、IndexError - 列表取值超出了他的索引数
In [55]: my_list = [1, 2, 3, 4, 5]
In [56]: my_list[5] # 根本没有这个元素
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
in ()
----> 1 my_list[5]
IndexError: list index out of range # 抛异常了
In [57]: my_list[5:] # 但是可以这样, 一定要注意, 用好了是trick,用错了就是坑啊
Out[57]: []
六、重用全局变量
In [58]: def my_func():
....: print(var) # 我可以先调用一个未定义的变量
....:
In [59]: var = 'global' # 后赋值
In [60]: my_func() # 反正只要调用函数时候变量被定义了就可以了
global
In [61]: def my_func():
....: var = 'locally changed'
....:
In [62]: var = 'global'
In [63]: my_func()
In [64]: print(var)
global # 局部变量没有影响到全局变量
In [65]: def my_func():
....: print(var) # 虽然你全局设置这个变量, 但是局部变量有同名的, python以为你忘了定义本地变量了
....: var = 'locally changed'
....:
In [66]: var = 'global'
In [67]: my_func()
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
in ()
----> 1 my_func()
in my_func()
1 def my_func():
----> 2 print(var)
3 var = 'locally changed'
4
UnboundLocalError: local variable 'var' referenced before assignment
In [68]: def my_func():
....: global var # 这个时候得加全局了
....: print(var) # 这样就能正常使用
....: var = 'locally changed'
....:
In [69]: var = 'global'
In [70]:
In [70]: my_func()
global
In [71]: print(var)
locally changed # 但是使用了global就改变了全局变量
七、拷贝可变对象
In [72]: my_list1 = [[1, 2, 3]] * 2
In [73]: my_list1
Out[73]: [[1, 2, 3], [1, 2, 3]]
In [74]: my_list1[1][0] = 'a' # 我只修改子列表中的一项
In [75]: my_list1
Out[75]: [['a', 2, 3], ['a', 2, 3]] # 但是都影响到了
In [76]: my_list2 = [[1, 2, 3] for i in range(2)] # 用这种循环生成不同对象的方法就不影响了
In [77]: my_list2[1][0] = 'a'
In [78]: my_list2
Out[78]: [[1, 2, 3], ['a', 2, 3]]
八、python多继承(C3)
In [1]: class A(object):
...: def foo(self):
...: print("class A")
...:
In [2]: class B(object):
...: def foo(self):
...: print("class B")
...:
In [3]: class C(A, B):
...: pass
...:
In [4]: C().foo()
class A # 例子很好懂, C继承了A和B,从左到右,发现A有foo方法,返回了
看起来都是很简单, 有次序的从底向上,从前向后找,找到就返回. 再看例子:
In [5]: class A(object):
...: def foo(self):
...: print("class A")
...:
In [6]: class B(A):
...: pass
...:
In [7]: class C(A):
...: def foo(self):
...: print("class C")
...:
In [8]: class D(B,C):
...: pass
...:
In [9]: D().foo()
class C # ? 按道理, 顺序是 D->B->A,为什么找到了C哪去了
这也就涉及了MRO(Method Resolution Order):
In [10]: D.__mro__
Out[10]: (__main__.D, __main__.B, __main__.C, __main__.A, object)
简单的理解其实就是新式类是广度优先了, D->B, 但是发现C也是继承A,就先找C,最后再去找A
九、列表的+和+=, append和extend
In [17]: print('ID:', id(a_list))
('ID:', 4481323592)
In [18]: a_list += [1]
In [19]: print('ID (+=):', id(a_list))
('ID (+=):', 4481323592) # 使用+= 还是在原来的列表上操作
In [20]: a_list = a_list + [2]
In [21]: print('ID (list = list + ...):', id(a_list))
('ID (list = list + ...):', 4481293056) # 简单的+其实已经改变了原有列表
In [28]: a_list = []
In [29]: id(a_list)
Out[29]: 4481326976
In [30]: a_list.append(1)
In [31]: id(a_list)
Out[31]: 4481326976 # append 是在原有列表添加
In [32]: a_list.extend([2])
In [33]: id(a_list)
Out[33]: 4481326976 # extend 也是在原有列表上添加
十、datetime也有布尔值这是一个坑
In [34]: import datetime
In [35]: print('"datetime.time(0,0,0)" (Midnight) ->', bool(datetime.time(0,0,0)))
('"datetime.time(0,0,0)" (Midnight) ->', False)
In [36]: print('"datetime.time(1,0,0)" (1 am) ->', bool(datetime.time(1,0,0)))
('"datetime.time(1,0,0)" (1 am) ->', True)
十一、'==' 和 is 的区别我的理解是”is”是判断2个对象的身份, ==是判断2个对象的值
In [37]: a = 1
In [38]: b = 1
In [39]: print('a is b', bool(a is b))
('a is b', True)
In [40]: c = 999
In [41]: d = 999
In [42]: print('c is d', bool(c is d))
('c is d', False) # 原因是python的内存管理,缓存了-5 - 256的对象
In [43]: print('256 is 257-1', 256 is 257-1)
('256 is 257-1', True)
In [44]: print('257 is 258-1', 257 is 258 - 1)
('257 is 258-1', False)
In [45]: print('-5 is -6+1', -5 is -6+1)
('-5 is -6+1', True)
In [46]: print('-7 is -6-1', -7 is -6-1)
('-7 is -6-1', False)
In [47]: a = 'hello world!'
In [48]: b = 'hello world!'
In [49]: print('a is b,', a is b)
('a is b,', False) # 很明显 他们没有被缓存,这是2个字段串的对象
In [50]: print('a == b,', a == b)
('a == b,', True) # 但他们的值相同
# But, 有个特例
In [51]: a = float('nan')
In [52]: print('a is a,', a is a)
('a is a,', True)
In [53]: print('a == a,', a == a)
('a == a,', False) # 亮瞎我眼睛了~
十二、浅拷贝和深拷贝我们在实际开发中都可以向对某列表的对象做修改,但是可能不希望改动原来的列表. 浅拷贝只拷贝父对象,深拷贝还会拷贝对象的内部的子对象
In [65]: list1 = [1, 2]
In [66]: list2 = list1 # 就是个引用, 你操作list2,其实list1的结果也会变
In [67]: list3 = list1[:]
In [69]: import copy
In [70]: list4 = copy.copy(list1) # 他和list3一样 都是浅拷贝
In [71]: id(list1), id(list2), id(list3), id(list4)
Out[71]: (4480620232, 4480620232, 4479667880, 4494894720)
In [72]: list2[0] = 3
In [73]: print('list1:', list1)
('list1:', [3, 2])
In [74]: list3[0] = 4
In [75]: list4[1] = 4
In [76]: print('list1:', list1)
('list1:', [3, 2]) # 对list3和list4操作都没有对list1有影响
# 再看看深拷贝和浅拷贝的区别
In [88]: from copy import copy, deepcopy
In [89]: list1 = [[1], [2]]
In [90]: list2 = copy(list1) # 还是浅拷贝
In [91]: list3 = deepcopy(list1) # 深拷贝
In [92]: id(list1), id(list2), id(list3)
Out[92]: (4494896592, 4495349160, 4494896088)
In [93]: list2[0][0] = 3
In [94]: print('list1:', list1)
('list1:', [[3], [2]]) # 看到了吧 假如你操作其子对象 还是和引用一样 影响了源
In [95]: list3[0][0] = 5
In [96]: print('list1:', list1)
('list1:', [[3], [2]]) # 深拷贝就不会影响
十三、bool其实是int的子类
In [97]: isinstance(True, int)
Out[97]: True
In [98]: True + True
Out[98]: 2
In [99]: 3 * True + True
Out[99]: 4
In [100]: 3 * True - False
Out[100]: 3
In [104]: True << 10
Out[104]: 1024
十五、元组是不是真的不可变?
In [111]: tup = ([],)
In [112]: tup[0] += [1]
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
----> 1 tup[0] += [1]
TypeError: 'tuple' object does not support item assignment
In [113]: tup
Out[113]: ([1],) # 我靠 又是亮瞎我眼睛,明明抛了异常 还能修改?
In [114]: tup = ([],)
In [115]: tup[0].extend([1])
In [116]: tup[0]
Out[116]: [1] # 好吧,我有点看明白了, 虽然我不能直接操作元组,但是不能阻止我操作元组中可变的子对象(list)
这里有个不错的解释Python's += Is Weird, Part II :
In [117]: my_tup = (1,)
In [118]: my_tup += (4,)
In [119]: my_tup = my_tup + (5,)
In [120]: my_tup
Out[120]: (1, 4, 5) # ? 嗯 不是不能操作元组嘛?
In [121]: my_tup = (1,)
In [122]: print(id(my_tup))
4481317904
In [123]: my_tup += (4,)
In [124]: print(id(my_tup))
4480606864 # 操作的不是原来的元组 所以可以
In [125]: my_tup = my_tup + (5,)
In [126]: print(id(my_tup))
4474234912
十六、python没有私有方法/变量? 但是可以有”伪”的
In [127]: class my_class(object^E):
.....: def public_method(self):
.....: print('Hello public world!')
.....: def __private_method(self): # 私有以双下划线开头
.....: print('Hello private world!')
.....: def call_private_method_in_class(self):
.....: self.__private_method()
In [132]: my_instance = my_class()
In [133]: my_instance.public_method()
Hello public world! # 普通方法
In [134]: my_instance._my_class__private_method()
Hello private world! # 私有的可以加"_ + 类名字 + 私有方法名字”
In [135]: my_instance.call_private_method_in_class()
Hello private world! # 还可以通过类提供的公有接口内部访问
In [136]: my_instance._my_class__private_variable
Out[136]: 1
十七、异常处理加else
In [150]: try:
.....: print('third element:', a_list[2])
.....: except IndexError:
.....: print('raised IndexError')
.....: else:
.....: print('no error in try-block') # 只有在try里面没有异常的时候才会执行else里面的表达式
.....:
raised IndexError # 抛异常了 没完全完成
In [153]: i = 0
In [154]: while i < 2:
.....: print(i)
.....: i += 1
.....: else:
.....: print('in else')
.....:
0
1
in else # while也支持哦~
In [155]: i = 0
In [156]: while i < 2:
.....: print(i)
.....: i += 1
.....: break
.....: else:
.....: print('completed while-loop')
.....:
0 # 被break了 没有完全执行完 就不执行else里面的了
In [158]: for i in range(2):
.....: print(i)
.....: else:
.....: print('completed for-loop')
.....:
0
1
completed for-loop
In [159]: for i in range(2):
.....: print(i)
.....: break
.....: else:
.....: print('completed for-loop')
.....:
0 # 也是因为break了
python程序编写应注意哪些问题_Python程序员鲜为人知但你应该知道的17个问题相关推荐
- python程序员又叫什么-Python程序员鲜为人知但你应该知道的17个问题
Python 程序员应该具备怎样的基本能力即使不见面,不说话,不发信息,小编也会在心里留一个位置,安安稳稳的放着一个人. 1. 熟悉Python语言的语法和一些高级特性,合适的时下使用适合的语言特性. ...
- 一个python程序员需要掌握的知识-Python程序员鲜为人知但你应该知道的17个问题...
一.不要使用可变对象作为函数默认值 In [1]: def append_to_list(value, def_list=[]): ...: def_list.append(value) ...: r ...
- 从入门到入土:[linux实践]-pam|编写基于libpam的用户认证程序|编写基于PAM认证的应用程序|详细说明|实验步骤|实验截图
写在前面: 此博客仅用于记录个人学习进度,学识浅薄,若有错误观点欢迎评论区指出.欢迎各位前来交流.(部分材料来源网络,若有侵权,立即删除) 编写基于libpam的用户认证程序|编写基于PAM认证的应用 ...
- python程序设计基础教程骆焦煌_Python程序设计基础教程
本书依据全国计算机等级考试二级Python语言程序设计考试大纲撰写,同时根据实际需要增加图形用户界面和网络爬虫与数据分析内容.本书以Python 3.6和Anaconda3版本为背景,介绍Python ...
- python程序设计基础第二版pdf下载_Python程序设计基础董付国课后答案-Python程序设计基础第二版清华大学出版社PDF电子版完整高清版-精品下载...
Python程序设计基础(第2版)完全面向Python 3.x,全部案例代码使用Python 3.5.x和Python 3.6.x编写,大部分内容也同样适用于Python 3.4.x.本书对Pytho ...
- python编程新手常犯的错误_Python程序员常犯的10个错误
BY- SENIOR SOFTWARE ENGINEER @TOPTAL About Python 关于Python Python is an interpreted, object-oriented ...
- python程序编写应注意哪些问题_用 Python 写爬虫时应该注意哪些坑?
Watch Price: $66.68 Discounted price: $46.68 Watch2 Price: $56.68
- python语言的特点强制可读_python程序语言设计第二讲(笔记)
Python语言程序设计第二讲 1.复习回顾 1.1保留字 1.2温度转换 #宋宇婕宝贝开始编写的第一个程序,温度转换,我来了 TempStr=input("一阵给老子输入带有符号的温度值, ...
- python第五章课后题答案_python程序设计基础(嵩天)第五章课后习题部分答案
原博文 2019-10-13 13:50 − 第五章p1515.2:实现isodd()函数,参数为整数,如果参数为奇数,返回true,否则返回false.def isodd(s): x=eval(s) ...
- 无法支持python程序的编辑运行和调试_python程序的调试方法
本文讨论在没有方便的IDE工具可用的情况下,使用pdb调试python程序 源码例子 例如,有模拟税收计算的程序: #!/usr/bin/python def debug_demo(val): if ...
最新文章
- 【跟着我们学Golang】之异常处理
- C++ 加载Live2D官方Cubism SDK for Native
- DM368开发 --IPNC 设置过程
- JavaScript实现longestCommonSubsequence最长公共子序列算法(附完整源码)
- Spark SQL来读取现有Hive中的数据
- 2/2 常用函数:标准库函数
- 成为诺奖热门人选,培养三名院士,他25岁才读研一!
- 张建锋:一两年内,阿里巴巴100%的业务都会上公共云
- python boolean_如何在Python中使用boolean’和’
- 用php人工使网页过期
- 中国人工智能学会通讯——电子商务中的个性化推荐技术剖析 1. 基于人生阶段建模的商品推荐...
- 本地更新github项目_【图文说明】将本地项目上传到github上
- spring Bean的初始化和销毁 (使用注解)
- php 脚本会超时吗,PHP脚本执行超时的解决办法
- 长话无需短说 讯飞输入法超长语音输入不限时
- 图像处理程序,在状态栏显示图像尺寸
- jpg图片批量压缩的简单方法
- 闹闹天宫一直显示服务器错误,闹闹天宫常见问题FAQ
- APP(IOS)蒲公英上传成功但下载页报错
- java DTO对象与PO对象的相互转换
热门文章
- Atitit 数据存储实现方案总结 提升开发效率 不要一股脑把数据塞到远程关系型数据库,会造成开发效率的降低。。根据不同的要求,选择最简化快速的方案 目录 1. 选择存储原则	2 1.1. 简单快
- Atitit 个人信息数据文档知识分类
- Atitit 网络爬虫与数据采集器的原理与实践attilax著 v2
- Atitit.跨语言数据库db api兼容性 jdbc odbc ado oledb 增强方案
- atitit.团队建设总结fx O622
- paip.提升性能----SQL优化总结
- 从心理学角度看,如何提高招聘面试的准确率?
- 云计算摆摊的可行性分析 | 凌云时刻
- 5G时代下的移动边缘计算(MEC)探索系列之二
- 百度谭中意:我和开源20年