python 反模式

不使用 pythonic 的循环:

l = [1,2,3]

#Bad
for i in range(0,len(list)):
    le = l[i]
    print(i,le)

#Good
for i,le in enumerate(l):
    print(i,le)

函数调用返回一个以上的变量类型

#Bad

def filter_for_foo(l):
    r = [e for e in l if e.find("foo") != -1]
    if not check_some_critical_condition(r):
        return None
    return r

res = filter_for_foo(["bar","foo","faz"])

if res is not None:
    #continue processing
    pass

#Good

def filter_for_foo(l):
    r = [e for e in l if e.find("foo") != -1]
    if not check_some_critical_condition(r):
        raise SomeException("critical condition unmet!")
    return r

try:
    res = filter_for_foo(["bar","foo","faz"])
    #continue processing
except SomeException:
    #handle exception

循环永不终止

#example:
i = 0
while i < 10:
    do_something()
    #we forget to increment i

不使用 .iteritems() 遍历 dict 的键/值对.

#Bad

d = {'foo' : 1,'bar' : 2}

for key in d:
    value = d[key]
    print("%s = %d" % (key,value))

#Good

for key,value in d.iteritems():
    print("%s = %d" % (key,value))

不使用 zip() 遍历一对列表

#Bad

l1 = [1,2,3]
l2 = [4,5,6]

for i in range(l1):
    l1v = l1[i]
    l2v = l2[i]
    print(l1v,l2v)

#Good

for l1v,l2v in zip(l1,l2):
    print(l1v,l2v)

Using "key in list" to check if a key is contained in a list.

This is not an error but inefficient, since the list search is O(n). If possible, a set or dictionary

should be used instead.

Note: Since the conversion of the list to a set is an O(n) operation, it should ideally be done only once when generating the list.

#Bad:

l = [1,2,3,4]

if 3 in l:
    pass

#Good

s = set(l)

if 3 in s:
    pass

在循环之后，不使用 'else'.

#Bad

found = False

l = [1,2,3]

for i in l:
    if i == 4:
        found = True
        break

if not found:
    #not found...
    pass

#Good

for i in l:
    if i == 4:
        break
else:
    #not found...

对于dict，不使用.setdefault()设置初始值

#Bad

d = {}

if not 'foo' in d:
    d['foo'] = []

d['foo'].append('bar')

#Good

d = {}

foo = d.setdefault('foo',[])
foo.append(bar)

对于dict，不使用.get()返回缺省值

#Bad

d = {'foo' : 'bar'}

foo = 'default'
if 'foo' in d:
    foo = d['foo']

#Good

foo = d.get('foo','default')

使用map/filter而不是列表解析

#Bad:

values = [1,2,3]

doubled_values = map(lambda x:x*2,values)

#Good

doubled_values = [x*2 for x in values]

#Bad

filtered_values = filter(lambda x:True if x < 2 else False,values)

#Good

filtered_values = [x for x in values if x < 2]

不使用defaultdict

#Bad

d = {}

if not 'count' in d:
    d['count'] = 0

d['count']+=1

#Good

from collections import defaultdict

d = defaultdict(lambda :0)

d['count']+=1

从一个函数中返回多个值时，不使用命名元组（namedtuple）

命名元组可以用于任何正常元组使用的地方，但可以通过name访问value，而不是索引。这使得代码更详细、更容易阅读。

#Bad

def foo():
    #....
    return -1,"not found"

status_code,message = foo()

print(status_code,message)

#Good

from collections import namedtuple

def foo():
    #...
    return_args = namedtuple('return_args',['status_code','message'])
    return return_args(-1,"not found")

ra = foo()

print(ra.status_code,ra.message)

不使用序列的显式解包

支持解包的序列有：list, tuple, dict

#Bad

l = [1,"foo","bar"]

l0 = l[0]
l1 = l[1]
l2 = l[2]

#Good

l0,l1,l2 = l

不使用解包一次更新多个值

#Bad

x = 1
y = 2

_t = x

x = y+2
y = x-4

#Good

x = 1
y = 2

x,y = y+2,x-4

不使用'with'打开文件

#Bad

f = open("file.txt","r")
content = f.read()
f.close()

#Good

with open("file.txt","r") as input_file:
    content = f.read()

要求许可而不是宽恕

#Bad

import os

if os.path.exists("file.txt"):
    os.unlink("file.txt")

#Good

import os

try:
    os.unlink("file.txt")
except OSError:
    pass

不使用字典解析

#Bad

l = [1,2,3]

d = dict([(n,n*2) for n in l])

#Good

d = {n : n*2 for n in l}

使用字符串连接,而不是格式化

#Bad

n_errors = 10

s = "there were "+str(n_errors)+" errors."

#Good

s = "there were %d errors." % n_errors

变量名包含类型信息(匈牙利命名)

#Bad

intN = 4
strFoo = "bar"

#Good

n = 4
foo = "bar"

实现java风格的getter和setter方法,而不是使用属性。

#Bad

class Foo(object):

    def __init__(a):
        self._a = a

    def get_a(self):
        return a

    def set_a(self,value):
        self._a = value

#Good

class Foo(object):

    def __init__(a):
        self._a = a

    @property
    def a(self):
        return self._a

    @a.setter
    def a(self,value):
        self._a = value

#Bad

def calculate_with_operator(operator, a, b):

    if operator == '+':
        return a+b
    elif operator == '-':
        return a-b
    elif operator == '/':
        return a/b
    elif operator == '*':
        return a*b

#Good

def calculate_with_operator(operator, a, b):

    possible_operators = {
        '+': lambda a,b: a+b,
        '-': lambda a,b: a-b,
        '*': lambda a,b: a*b,
        '/': lambda a,b: a/b
    }

    return possible_operators[operator](a,b)

#Bad

class DateUtil:
    @staticmethod
    def from_weekday_to_string(weekday):
        nameds_weekdays = {
            0: 'Monday',
            5: 'Friday'
        }

        return nameds_weekdays[weekday]

#Good

def from_weekday_to_string(weekday):
    nameds_weekdays = {
        0: 'Monday',
        5: 'Friday'
    }

    return nameds_weekdays[weekday]