避免劣化的python代码

劣化代码:

s = []
for i in seq:
  s.append(foo(i))

 

推荐代码:

s = map(foo, seq)
更高效的代码
for i in itertools.imap(foo, seq):
  bar(i)

 劣化代码:

for i in xrange(len(seq1)):
  foo(seq1[i], seq2[i])

 推荐代码:

for i, j in zip(seq1, seq2)
  foo(i, j)
更高效：
for i, j in itertools.izip(seq1, seq2): 
  foo(i, j)

 劣化代码:

for i in xrange(len(seq)):
  foo(seq[i], i）

 推荐代码：

for i, item in enumerate(seq):
  foo(item, i)

 

 劣化代码:

s = seq[:]
s.reverse()
for i in s:
  foo(i)

推荐代码：

for i in reversed(s):
  foo(i)

 劣化代码:

def foo(seq, bgn, end): 
  i=0
  while(bgn < end): bar(seq[bgn], i )
    bgn += 1
    i += 1 
def foo(seq, bgn, end):
   tmp_seq = seq[bgn:end] 
   for i, item in enumerate(tmp_seq):
     bar(item, i)

 推荐代码：

def foo(seq, bgn, end):
  for begin, i in itertools.izip(xrange(bgn, end), itertools.counter()):
    bar(seq[begin], i)

  劣化代码:

for i in seq:
  if pred(i): 
    foo(i)

 推荐代码：

for i in itertools.ifilter(pred, seq):
  foo(i)

如果你又更好的方案，请继续补吧。

评论

21 楼 tterry 2011-03-28  

没看出来怎么个劣法，莫非你说劣就劣？

20 楼 marlonyao 2011-01-19  

举的不过是函数式编程的例子罢了，缺少对匿名函数的支持，python的函数式支持比ruby差远了。

19 楼 wizardyhnr 2010-12-15  

盖茨他爹 写道

edison0951 写道

盖茨他爹 写道

第一个用列表解析更高效

另，如果想少敲字，itertools.izip，itertools.imap，itertools.ifilter换成zip、map、filter能少敲很多，迭代器又不比列表高效多少

没有吧，迭代器的好处是不一下全取出来，而是在你需要的时候才去取。列表不可同日而语

import itertools
import time

l = range(1000000)

def test1():
    time1 = time.clock()
    l2 = [str(i) for i in l]
    time2 = time.clock()
    print time2-time1
    
def test2():
    time1 = time.clock()
    l2 = map(str, l)
    time2 = time.clock()
    print time2-time1
    
def test3():
    time1 = time.clock()
    for i in itertools.imap(str, l):
        pass
    time2 = time.clock()
    print time2-time1

test1()
test2()
test3()

测试结果：
1.38556706794
0.642326404896
1.74044392476

map最快，列表解析次之，itertools.imap最慢

迭代器的好处貌似是内存占用小，因为是一个一个执行输出的，而不是一下输出一个完整的列表。文档中还是比较提倡这种写法的。
楼主的写法也可以算作FP编程风格的优点。

函数映射，类似于多态

lst=['a', 'b', 'c']
func={1:prt1, 2:prt2}

def prt1(l):
    [print(t) for t in l]
#这种写法在这不一定合适，只是与map是等效的，语法上更简洁一些。

def prt2(l):
    [print(ord(t)) for t in l]

def prt(l, para):
    func[para](l)

prt(lst, 1)
prt(lst, 2)

18 楼 aninfeel 2010-12-11  

java程序员飘过，一直使用大众看得懂的所谓“劣化代码”中，而且以后还会继续用。

17 楼 盖茨他爹 2010-12-08  

edison0951 写道

盖茨他爹 写道

第一个用列表解析更高效

另，如果想少敲字，itertools.izip，itertools.imap，itertools.ifilter换成zip、map、filter能少敲很多，迭代器又不比列表高效多少

没有吧，迭代器的好处是不一下全取出来，而是在你需要的时候才去取。列表不可同日而语

import itertools
import time

l = range(1000000)

def test1():
    time1 = time.clock()
    l2 = [str(i) for i in l]
    time2 = time.clock()
    print time2-time1
    
def test2():
    time1 = time.clock()
    l2 = map(str, l)
    time2 = time.clock()
    print time2-time1
    
def test3():
    time1 = time.clock()
    for i in itertools.imap(str, l):
        pass
    time2 = time.clock()
    print time2-time1

test1()
test2()
test3()

测试结果：
1.38556706794
0.642326404896
1.74044392476

map最快，列表解析次之，itertools.imap最慢

16 楼 edison0951 2010-12-08  

盖茨他爹 写道

第一个用列表解析更高效

另，如果想少敲字，itertools.izip，itertools.imap，itertools.ifilter换成zip、map、filter能少敲很多，迭代器又不比列表高效多少

没有吧，迭代器的好处是不一下全取出来，而是在你需要的时候才去取。列表不可同日而语

15 楼 伊落丹 2010-12-06  

duka 写道

劣：

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

优：

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

可能found标志位在后续代码还用得上。

路过，我主业是用C或C++，只是觉得python不用编译比较方便，比C总是更简洁的。所以我既不想学另一套思维方式（怕走火入魔~~），又想利用python的便利。一直在使用劣化python中……

14 楼 duka 2010-12-04  

>>> names = ['Bob', 'Marie', 'Alice']
>>> ages = [23, 27, 36]
>>> dict(zip(names, ages))
{'Alice': 36, 'Bob': 23, 'Marie': 27}

13 楼 duka 2010-12-04  

排序的小技巧：

a = [(2, "b"), (1, "a"), (2, "a"), (3, "c")]
print sorted(a)
#[(1, 'a'), (2, 'a'), (2, 'b'), (3, 'c')]

a = [{2:"b"},{1:"a"}, {2:"a"}]
print sorted(a)
[{1: 'a'}, {2: 'a'}, {2: 'b'}]

12 楼 duka 2010-12-04  

小伎俩：

>>> str(round(1234.5678, -2))
'1200.0'
>>> str(round(1234.5678, 2))
'1234.57'

>>> dict(foo=1, bar=2)
{'foo': 1, 'bar': 2}

11 楼 duka 2010-12-04  

超级技巧，可用于列表对比：

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

10 楼 duka 2010-12-04  

劣：

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

优：

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

9 楼 duka 2010-12-04  

劣化代码:

>>> a = ['a','b','c']
>>> for x in a:
...     print a.index(x),x
...
0 a
1 b
2 c
>>>

推荐代码:

>>> a = ['a', 'b', 'c']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
>>>

8 楼 yeaha 2010-12-04  

没明白到底好在哪里，就是好在python口音比较地道？
我只懂得丁点python，期待解惑

7 楼 kjj 2010-12-03  

正在学python ，收藏一下，以后尽量先用官方库写

6 楼 盖茨他爹 2010-12-03  

第一个用列表解析更高效

另，如果想少敲字，itertools.izip，itertools.imap，itertools.ifilter换成zip、map、filter能少敲很多，迭代器又不比列表高效多少

5 楼 魔力猫咪 2010-12-03  

动态语言之所以效率高，很大程度上就是因为有很多节约敲字的语法糖。合适的语法糖可以大大提高效率和代码可读性。

4 楼 盖茨他爹 2010-12-03  

从另一个角度看，推荐代码好多语法糖

3 楼 edison0951 2010-12-03  

魔力猫咪 写道

我觉得出现这种所谓的劣化代码，很大程度上是对Python的函数库和类库的不熟悉，还有就是自己以前其他语言的思考方式的影响。

对呀,判断一个pythoner的程度，就看这些实例，以及对很多函数库的理解

2 楼 魔力猫咪 2010-12-03  

我觉得出现这种所谓的劣化代码，很大程度上是对Python的函数库和类库的不熟悉，还有就是自己以前其他语言的思考方式的影响。