Python实用技巧-成为Pythoner必经之路

标签: python 技巧 pythoner | 发表时间:2011-06-16 01:30 | 作者:(author unknown) shuangxi
出处:http://www.iteye.com
前言
    本文主要记录 Python 中一些常用技巧,本文重点描述的是告诉你怎么写才是更好?  如果你并不熟悉Python语法,希望你能在下面代码片段中看到Python的简单、优雅; 如果你象我这样,对 Python 有兴趣或并正在学习,我相信下面的技巧并不会让你失望; 如果你已经是一名 Pythoner ,那么很乐于你分享你的经验和技巧。

目录
  • Python 禅道
  • 代码风格: 提高可读性
  • PEP 8: Python 代码风格指南
  • 空格(行)使用 (1)
  • 空格(行)使用 (2)
  • 命名
  • 较长代码行
  • 较长字符串
  • 复合语句
  • 字符串文档 & 注释
  • 交换变量
  • 更多关于 Tuples
  • 关于 "_"
  • 创建String: 从列表中创建
  • 尽可能的使用
  • 字典中的 get 函数
  • 字典中的 setdefault 函数 (1)
  • 字典中的 setdefault 函数 (2)
  • defaultdict
  • 创建 & 分割字典
  • 判断 True 值
  • True 值
  • 索引 & 项 (1)
  • 索引 & 项 (2): enumerate
  • 默认参数值
  • 列表理解
  • 生成器表达式 (1)
  • 生成器表达式 (2)
  • 排序
  • 使用 DSU *排序
  • 使用 Key 排序
  • 生成器
  • 生成器示例
  • 从文件中读取数据行
  • try/except 示例
  • 导入(Importing)
  • 模块 & 脚本
  • 模块结构
  • 命令行处理
  • 简单比复杂好
  • 不要重新发明轮子


章节

Python 禅道
这是Python的指导原则,但有不同诠释。

如果您使用的一种编程语言是以小品喜剧艺术团命名的,你最好有幽默感。

美丽优于丑陋。
明确优于含蓄。
简单比复杂好。
平倘优于嵌套。
稀疏比密集更好。
特殊情况不能特殊到打破规则。
错误不应该默默传递。
......


代码风格: 提高可读性
Programs must be written for people to read, and only incidentally for machines to execute.
     —Abelson & Sussman, Structure and Interpretation of Computer Programs


PEP 8: Python 代码风格指南
值得阅读:
http://www.python.org/dev/peps/pep-0008/


空格(行)使用 (1)
  • 使用 4 个空格缩进。
  • 不要使用制表符。
  • 不要将制表符和空格混合使用。
  • IDEL和Emacs的Python的都支持 spaces模式。
  • 每个函数之间应该有一个空行。
  • 每一个 Class 之间应该有两个空行。


空格(行)使用 (2)
  • 在使用 字典(dict), 列表(list), 元组(tuple), 参数(argument)列表时, 应在 "," 前添加一个空格, 并且使用字典(dict)时,在 ":" 号后添加空格,而不是在前面添加。
  • 在括号之前或参数之前不添加空格。
  • 在文档注释中前后应该没有空格。

def make_squares(key, value=0):
    """Return a dictionary and a list..."""
    d = {key: value}
    l = [key, value]
    return d, l


命名
  • joined_lower 可以是 函数名, 方法名, 属性名
  • joined_lower or ALL_CAPS 是常量
  • StudlyCaps 类名
  • camelCase 只有在预先制定好的命名规范使用
  • 属性: interface, _internal, __private
  • 但尽量避免__private形式。下面两个链接解释了 为什么python中没有 private声明?
      http://stackoverflow.com/questions/70528/why-are-pythons-private-methods-not-actually-private
      http://stackoverflow.com/questions/1641219/does-python-have-private-variables-in-classes


较长代码行
保持一行代码在 80 个字符长度。
在括号内使用隐含的行延续:
 def __init__(self, first, second, third,
             fourth, fifth, sixth):
    output = (first + second + third
              + fourth + fifth + sixth)

或者在需要换行的位置使用 \ 来延续行:
VeryLong.left_hand_side \
    = even_longer.right_hand_side()
另外,使用反斜杠是有风险的,如果你添加一个空格在反斜杠后面,它就出错了。此外,它使代码难看。


较长字符串
将相邻的字符串进行连接的做法:
>>> print 'o' 'n' "e"
one

虽然字符之间的空格不是必需的,但是这样有助于可读性。
>>> print 't' r'\/\/' """o"""
t\/\/o

用一个 “r“ 开头的字符串是一个“raw“的字符串(类似java中的转义符)。上面的反斜杠就会当成普通字符串处理。他们对正则表达式和Windows文件系统路径非常有用。
注意:使用字符串变量名无法通过以上方式进行连接。
>>> a = 'three'
>>> b = 'four'
>>> a b
  File "<stdin>", line 1
    a b
      ^
SyntaxError: invalid syntax

这是因为自动连接是由Python解析器/编译器来处理的,因为其无法在编译时对变量值进行"翻译",所以就这种必须在运行时使用“+“运算符来连接变量。


复合语句
Good:
if foo == 'blah':
    do_something()
do_one()
do_two()
do_three()

Bad:
if foo == 'blah': do_something()
do_one(); do_two(); do_three()


文档注释(Docstrings) & 注释
文档注释 = 用于解释如何使用代码
      文档注释公约:http://www.python.org/dev/peps/pep-0257/
注释 = 为什么 (理由) & 代码如何工作的如:
# !!! BUG: ...
# !!! FIX: This is a hack
# ??? Why is this here?
注释对于任何语言开发者来说已经最基本的东西了,这里就不详细说了.


交换变量
在其它语言的交换变量的做法一般是:
temp = a
a = b
b = temp

Python的做法:
b, a = a, b

也许你见到过这样的情况,但是你知道它是如何工作的吗?
  • 首先,逗号是元组构造语法。
  • 等号的右边是定义一个元组 (tuple packing).
  • 其左边为一个目标元组 (tuple unpacking)).
右边的元组根据名称被 unpacked 到左边的无组。
更多关于 unpacked例子:
>>> info =['David', 'Pythonista', '+1250']
>>> name, title, phone = info
>>> name
'Davids'
>>> title
'Pythonista'
>>> phone
'+1250'

在结构化的数据上使用循环:
info 是在上面定义的一个 list . 所以下面的 people 有两个项,  两个项都是分别都拥有三个项的 list.
>>> people = [info, ['Guido', 'BDFL', 'unlisted']]
>>> for (name, title, phone) in people:
...     print name, phone
...
David +1250
Guido unlisted

以上循环中,people中的两个项(list item),都已经被 unpacked 到 (name, title, phone) 无组中。
可以任意嵌套(只要左右两边的结构一定要能够匹配得上):
>>> david, (gname, gtitle, gphone) = people
>>> gname
'Guido'
>>> gtitle
'BDFL'
>>> gphone
'unlisted'
>>> david
['David', 'Pythonista', '+1250']


更多关于 Tuples
我们看到的是元组通过逗号构造,而不是括号。例如:
>>> 1,
(1,)

Python的解释器会为你显示括号,所以建议你使用括号:
>>> (1,)
(1,)

千万不要忘记逗号!
>>> (1)
1

在只有一个元素的元组,尾随逗号是必须的,在2 + 元素的元组,尾随逗号是可选的。 如果创建一个 0或空元组,一对括号是快捷的语法:
>>> ()
()
>>> tuple()
()

一个常见的​​错误当你并不想要一个无组,却无意的添加了一个逗号,很容易造成你在代码中的错误,如:
>>> value = 1,
>>> value # is a tuple, not a int
(1,)

所以,当你发现一个元组时,赶紧去找一下那个,号吧。


关于 "_"
是一个非常有用的功能,但是却很少有人知道。
当你在交互式模式下(如 IDEL)计算一个表达式或调用一个函数后,其结果必然是一个临时名称,_(下划线):
>>> 1 + 1
2
>>> _
2

在 _ 中存储最后输出的值。
当输出的结果是 None 或没有任何输出时,而 _ 的值并不会改变,仍然保存上一次的值。这就是方便所在。
当然,这只能交互式的模式中使用,在模块中不能支持。
这在交互式模式中是非常有用的,当你在过程中没有保存计算结果 或 你想看最后一步的执行的输出结果:
>>> import math
>>> math.pi / 3
1.0471975511965976
>>> angle = _
>>> math.cos(angle)
0.50000000000000011
>>> _
0.50000000000000011


创建String: 从列表中创建
开始定义一个 string  列表:
colors = ['red', 'blue', 'green', 'yellow']
当我们需要将上面的列表连接成一个字符串。尤其当 list 是一个很大的列表时....
不要这样做:
result = ''
for s in colors:
    result += s
这种方式效率非常低下的,它有可怕的内存使用问题,至于为什么,如果你是 javaer 的话,其中的 string 连接,我想你并不陌生。
相反,你应该这样做:
 result = ''.join(colors)

当你只有几十或几百个string项连接时,它们效率上并不会太大的差别。但你要在养成写高效代码的习惯,因为当字符串数千时,join 比起 for 连接性能会能有所提升。

如果你需要使用一个函数来生成一个字符串列表,同样可以使用:
result = ''.join(fn(i) for i in items)



尽可能的使用
Good:
for key in d:
    print key

  • 使用 in 一般情况下是非常快的。
  • 这种方式也适用于其它的容器对象(如 list,tuple 和 set)。
  • in 是操作符(正如上面所看到的)。

Bad:
for key in d.keys():
    print key

保持与上面的一致性,使用 use key in dict 方式,而不是 dict.has_key():
 # do this:
if key in d:
    ...do something with d[key]

# not this:
if d.has_key(key):
    ...do something with d[key]



字典中的 get 函数
我们经常需要在字典中初始化数据:
以下是不好的实现方法:
navs = {}
for (portfolio, equity, position) in data:
    if portfolio not in navs:
        navs[portfolio] = 0
    navs[portfolio] += position * prices[equity]

使用dict.get(key, default) 删除 if 判断代码:
navs = {}
for (portfolio, equity, position) in data:
    navs[portfolio] = (navs.get(portfolio, 0)
                       + position * prices[equity])
这种方式更为直接。


字典中的 setdefault 函数 (1)
当我们要初始化一个可变字典的值。每个字典的值将是一个列表。下面是不好的做法:
初始化可变字典的值:
equities = {}
for (portfolio, equity) in data:
    if portfolio in equities:
        equities[portfolio].append(equity)
    else:
        equities[portfolio] = [equity]

通过 dict.setdefault(key, default) 使这段代码工作的更好:
equities = {}
for (portfolio, equity) in data:
    equities.setdefault(portfolio, []).append(
                                         equity)

dict.setdefault()等同于“ get, or set & get“ 或"如果没有,就设置";  如果你的字典Key是复杂的计算或long类型,使用 setdefault 是特别有效的。


字典中的 setdefault 函数 (2)
在我们看到的setdefault字典方法也可以作为一个独立的语句使用:
avs = {}
for (portfolio, equity, position) in data:
    navs.setdefault(portfolio, 0)
    navs[portfolio] += position * prices[equity]

我们在这里忽略了字典的setdefault方法返回的默认值。我们正利用的setdefault中的作用,仅仅只是在dict中没有 key 的值的时候才会设置。


创建 & 分割字典
如果你有两份 list 对象,希望通过这两个对象构建一个 dict 对象。
given = ['John', 'Eric', 'Terry', 'Michael']
family = ['Cleese', 'Idle', 'Gilliam', 'Palin']
pythons = dict(zip(given, family))
>>> pprint.pprint(pythons)
{'John': 'Cleese',
 'Michael': 'Palin',
 'Eric': 'Idle',
 'Terry': 'Gilliam'}

同样,如果希望获取两份列表,也是非常简单:
>>> pythons.keys()
['John', 'Michael', 'Eric', 'Terry']
>>> pythons.values()
['Cleese', 'Palin', 'Idle', 'Gilliam']

需要注意的是,上面 list 虽然是有序的,但是 dict 中的  keys 和 values 是无序的,这正是因为 dict 本质就是无序存储的。


索引 & 项 (1)
如果你需要一个列表,这里有一个可爱的方式来节省你的输入:
>>> items = 'zero one two three'.split()
>>> print items
['zero', 'one', 'two', 'three']

如果我们需要遍历这个 list ,而且需要 index 和 item:
                  - or -
i = 0
for item in items:      for i in range(len(items)):
    print i, item               print i, items[i]
    i += 1


索引 & 项 (2): enumerate
通过 enumerate 可以返回 list 中的 (index, item)元组:
>>> print list(enumerate(items))
[(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]

于是,遍历list获取index 及 item 就更加简单了:
for (index, item) in enumerate(items):
    print index, item

# compare:              # compare:
index = 0               for i in range(len(items)):
for item in items:              print i, items[i]
    print index, item
    index += 1

不难看出,使用 enumerate 比起下面两种方式,更加简单,更加容易阅读,这正是我们想要的。
下面是例子是如何通过 enumerate 返回迭代器:
>>> enumerate(items)
<enumerate object at 0x011EA1C0>
>>> e = enumerate(items)
>>> e.next()
(0, 'zero')
>>> e.next()
(1, 'one')
>>> e.next()
(2, 'two')
>>> e.next()
(3, 'three')
>>> e.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
StopIteration



默认参数值
这是对于一个初学者常犯的错误,甚至于一些高级开发人员也会遇到,因为他们并不了解 Python 中的 names.
def bad_append(new_item, a_list=[]):
    a_list.append(new_item)
    return a_list

这里的问题是,a_list是一个空列表,默认值是在函数定义时进行初始化。因此,每次调用该函数,你会得到不相同的默认值。尝试了好几次:
>>> print bad_append('one')
['one']
>>> print bad_append('two')
['one', 'two']

列表是可变对象,你可以改变它们的内容。正确的方式是先获得一个默认的列表(或dict,或sets)并在运行时创建它。
def good_append(new_item, a_list=None):
    if a_list is None:
        a_list = []
    a_list.append(new_item)
    return a_list




判断 True 值
# do this:        # not this:
if x:             if x == True:
    pass              pass

它的优势在于效率和优雅。
判断一个list:
# do this:        # not this:
if items:         if len(items) != 0:
    pass              pass

                  # and definitely not this:
                  if items != []:
                      pass



True 值
True和False是内置的bool类型的布尔值的实例。谁都只有其中的一个实例。
FalseTrue
False (== 0)True (== 1)
"" (empty string)       any string but "" (" ", "anything")
0, 0.0      any number but 0 (1, 0.1, -1, 3.14)
[], (), {}, set()      any non-empty container ([0], (None,), [''])
None      almost any object that's not explicitly False


简单比复杂好
Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.
     —Brian W. Kernighan



不要重新发明轮子
在写任何代码之前,
➔ ➔ ➔ ➔

原文:[urlhttp://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html][url]


作者: denger 
声明: 本文系ITeye网站发布的原创文章,未经作者书面许可,严禁任何网站转载本文,否则必将追究法律责任!

已有 0 人发表回复,猛击->>这里<<-参与讨论


ITeye推荐



相关 [python 技巧 pythoner] 推荐:

Python实用技巧-成为Pythoner必经之路

- shuangxi - ITeye论坛最新讨论
    本文主要记录 Python 中一些常用技巧,本文重点描述的是告诉你怎么写才是更好.   如果你并不熟悉Python语法,希望你能在下面代码片段中看到Python的简单、优雅; 如果你象我这样,对 Python 有兴趣或并正在学习,我相信下面的技巧并不会让你失望; 如果你已经是一名 Pythoner ,那么很乐于你分享你的经验和技巧.

两个 Python 的冷技巧

- duyue - 赖勇浩的编程私伙局
记得刚开始工作的时候,老大给我们上 C++ 基础课,告诉我们字符串字面量可以换行(如下代码),感觉真是如梦如幻. 后来在写了很久的 Python 以后,才知道 Python 其实也可以的:. 这个特性很有用,能够把超长的代码优雅地分为几行. 记得以前在拼 SQL 语言、写日志条目的时候总为代码行长度超过 78 感到纠结(见我们的编程规范:http://blog.csdn.net/lanphaday/article/details/6601123),现在没有压力啦.

dropbox讲python

- chuang - Initiative
dropbox定制优化CPython虚拟机,自己搞了个malloc调度算法. 那个 !!!111cos(0). 期待这次PyCon China 2011.

Python调试

- - 企业架构 - ITeye博客
原文地址: http://blog.csdn.net/xuyuefei1988/article/details/19399137. 1、下面网上收罗的资料初学者应该够用了,但对比IBM的Python 代码调试技巧:. IBM:包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试:.

Python WSGI 初探

- - 坚实的幻想
在构建 Web 应用时,通常会有 Web Server 和 Application Server 两种角色. 其中 Web Server 主要负责接受来自用户的请求,解析 HTTP 协议,并将请求转发给 Application Server,Application Server 主要负责处理用户的请求,并将处理的结果返回给 Web Server,最终 Web Server 将结果返回给用户.

Python实现逻辑回归(Logistic Regression in Python)

- - 神刀安全网
Logistic Regression in Python ,作了中文翻译,并相应补充了一些内容. 本文并不研究逻辑回归具体算法实现,而是使用了一些算法库,旨在帮助需要用Python来做逻辑回归的训练和预测的读者快速上手. 逻辑回归是一项可用于预测二分类结果(binary outcome)的统计技术,广泛应用于金融、医学、犯罪学和其他社会科学中.

python 下载文件

- Eric - python相关的python 教程和python 下载你可以在老王python里寻觅
之前给大家分享的python 多线程抓取网页,我觉的大家看了以后,应该会对python 抓取网页有个很好的认识,不过这个只能用python 来抓取到网页的源代码,如果你想用做python 下载文件的话,上面的可能就不适合你了,最近我在用python 做文件下载的时候就遇到这个问题了,不过最终得以解决,为了让大家以后碰过这个问题有更好的解决办法,我把代码发出来:.

python代码调试

- - 阿里古古
【转自: http://blog.csdn.net/luckeryin/article/details/4477233】. 本文讨论在没有方便的IDE工具可用的情况下,使用pdb调试python程序. 例如,有模拟税收计算的程序:. debug_demo函数计算4500的入账所需的税收. 在需要插入断点的地方,加入红色部分代码:如果_DEBUG值为True,则在该处开始调试(加入_DEBUG的原因是为了方便打开/关闭调试).

python编程规范

- - 互联网 - ITeye博客
@FileName: @Author:xx@ic.net.cn @Create date: @description:用一行文字概述模块或脚本,用句号结尾. 不影响编码的效率,不与大众习惯冲突.. 使代码的逻辑更清晰,更易于理解..   *所有的 Python 脚本文件都应在文件头标上如下标识或其兼容格式的标识.

《Dive into Python 3》中文版

- hama - Wow! Ubuntu
Dive Into Python 是一份很知名的 Python 入门教程,由 Mark Pilgrim 编写,用户可以免费获取电子版本,而中文版则由啄木鸟社区翻译发布 [ 英文版 / 中文版 ]. 前阵子,Mark Pilgrim 又发布了 《Dive into Python 3》,此版本的内容涵盖了 Python 3 及其与 Python 2 的区别.