Pythonic Code

目录

• 1、字符串拼接
• 2、条件判断
• 3、使用内置函数内置库——map代替for
• 4、使用内置函数内置库——defaultdict(list)代替自定义和冗余附加判断
• 5、使用内置函数内置库——map(fun, dict(zip()))快速构建字典（用于表格展示的json）
• 6、循环内减少计算
• 7、全局与局部变量
• 8、特殊函数exec、dir

1、字符串拼接

×低效：每一步都需要建立新变量。

msg = 'line1\n'
msg += 'line2\n'
msg += 'line3\n'

√高效：放进一个list，利用join连接

msg = ['line1', 'line2', 'line3']
'\n'.join(msg)

注意：避免使用+连接字符串
×低效：

# slow
msg = 'hello ' + my_var + ' world'

×低效：

# faster
msg = 'hello %s world' % my_var

√高效：

# or better:
msg = 'hello {} world'.format(my_var)

2、条件判断

可读性+快
‘if variable:’ is faster than the un-idiomatic ‘if variable == True:’

×低效：

if variable == True:
    ...

√高效：

if variable:
    ...

3、使用内置函数内置库——map代替for

内置函数利用C编译，都十分高效。
Guido’s Python Patterns - An Optimization Anecdote is a great read:

    If you feel the need for speed, go for built-in functions - you can't beat a loop written in C.
Check the library manual for a built-in function that does what you want. 

例1，将list中每个元素字符串大写

×低效（Example borrowed from this great wiki）：

newlist = []
for word in oldlist:
    newlist.append(word.upper())

√高效（Better）：

newlist = map(str.upper, oldlist)  # wiki cites map as a for loop moved into C code

4、使用内置函数内置库——defaultdict(list)代替自定义和冗余附加判断

例2，将由元组组成的list进行dict，相同key的value放入同一list

×低效：

>>> d = {}
>>> s_keys = []
>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> for k, v in s:
...      if k in s_keys:
...          temp_v = d[k]
...          temp_v.append(v)
...          d[k] = temp_v
...      else:
...          d[k]=v
...          s_keys.append(k)
>>> d
{'blue': [2, 4], 'red': [1], 'yellow': [1, 3]}

√高效：

>>> from collections import defaultdict
>>> d = defaultdict(list)
>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> for k, v in s:
...      d[k].append(v)
... 
>>> d
defaultdict(<type 'list'>, {'blue': [2, 4], 'red': [1], 'yellow': [1, 3]})

十分特别的例子：Python对MySQL中读取的数据进行多层字典嵌套json化

5、使用内置函数内置库——map(fun, dict(zip()))快速构建字典（用于表格展示的json）

>>> keys = ("id", "operator", "ts")
>>> result = ((1, "asco", "ts1"),
...     (2, "tonal", "ts2"),
...     (3, "celion", "ts3"),
...     (4, "conbul", "ts4"))

×低效：

# 好一些
>>> data = []
>>> for task in result:
...     data.append(dict(zip(keys, task)))
... 
>>> data
[{'operator': 'asco', 'id': 1, 'ts': 'ts1'}, {'operator': 'tonal', 'id': 2, 'ts': 'ts2'}, {'operator': 'celion', 'id': 3, 'ts': 'ts3'}, {'operator': 'conbul', 'id': 4, 'ts': 'ts4'}]

√高效：

# 更快一些
>>> data2 = map(lambda x: dict(zip(keys, x)), result) 
>>> data2
[{'operator': 'asco', 'id': 1, 'ts': 'ts1'}, {'operator': 'tonal', 'id': 2, 'ts': 'ts2'}, {'operator': 'celion', 'id': 3, 'ts': 'ts3'}, {'operator': 'conbul', 'id': 4, 'ts': 'ts4'}]

6、循环内减少计算

如果您有一个大的迭代器，并且需要进行一些regex匹配，例如匹配一个日期：
×低效做法：

for i in big_it:
    m = re.search(r'\d{2}-\d{2}-\d{4}', i)
    if m:
        ...

最好编译一次regex并在循环中使用“缓存”版本：
√高效：

date_regex = re.compile(r'\d{2}-\d{2}-\d{4}')

for i in big_it:
    m = date_regex.search(i)
    if m:
        ...

7、全局与局部变量

另一个技巧是将函数（计算）指定为局部变量：
"Python accesses local variables much more efficiently than global variables. "

myfunc = myObj.func
fcor i in range(n):
    myfunc(i) # faster than myObj.func(i)

在缓存方面，对于memoization（一种优化技术，主要用于存储昂贵函数调用的结果并在再次发生相同输入时返回缓存的结果，从而加快计算机程序的速度），您可以使用functools.lru缓存装饰器。lru=最近使用最少，一个好的用例是从Web获取数据（docs页面有一个静态Web内容的lru缓存示例）。python – 为什么程序在放入函数时要快得多？

8、特殊函数exec、dir

原始数据来自数据库[(),(),(),…]，需数据提取，
一部分按os计算天级别量total；
一部分按os、field、detail计算天级别hit。
可以最终的数据转为DF进行连接，然而这里并没有，直接利用

exec('='.join('ANDROID', str(total_android)))
exec('='.join('IOS', str(total_ios)))

最终的结果是[[date, os, field, detail, …], [], [], …]，将其写入MySQL库，遍历找到对应的数据将其追加到对应的list。

for i in result:
    if i[1] == 'android' and "ANDROID" in dir():
        加Android的总量total追加到i中
    elif:
        ...