手摸手教你如何在 Python 编码中做到小细节大优化

手摸手教你如何在 Python 编码中做到小细节大优化

在列表里计数

"""
在列表里计数，使用 Python 原生函数计数要快很多，所以尽量使用原生函数来计算。
"""
elements = list(range(1, 1000001))

# 常见写法
num = 0
for n in elements:
    num += 1

# 建议写法
len(elements)

过滤一个列表

"""
过滤一个列表，推导列表的方式最快。
"""
elements = list(range(1, 1000001))

# 第一种，常见写法
l = []
for e in elements:
    if e % 2:
        l.append(e)

# 第二种，常见写法。filter 增加了复杂度，返回一个迭代对象再用 list 转成一个列表，这样会增加开销。
list(filter(lambda e : e % 2, elements))

# 建议写法，推导的方式性能最佳
[e for e in elements if e % 2]

使用异常检查属性

"""
灵活使用异常检查属性
"""
class User(object):
    name = 'Python'

# 常见写法，通过内置函数 hasattr 检查，查找内部类的属性增加了开销。
user = User()
if hasattr(user, 'name'):
    user.name

# 建议写法，通过异常捕获
start = timeit.default_timer()
try:
    user.name
except AttributeError:
    pass

检查列表元素

"""
检查列表元素
"""
elements = list(range(1, 1000001))

# 常见写法，使用循环的方式检查
def check_number(n):
    for e in elements:
        if e == n:
            return True
    return False
check_number(10000)

# 建议写法，直接使用 in 检查列表
10000 in elements

列表去重

"""
列表去重
"""
elements = list(range(1, 10001))

# 常见写法，使用循环的去重列表
u = []
for e in elements:
    if e not in u:
        u.append(e)

# 建议写法，使用 set 对列表去重
set(elements)

列表排序

"""
列表排序
"""
elements = list(range(1, 100001))

# 常见写法，sorted 函数会把原来的列表进行排序后，再返回一个新的列表。
sorted(elements)

# 建议写法，sort 函数直接在原来的列表上排序。
start = timeit.default_timer()
elements.sort()

将迭代循环放入函数

"""
将迭代循环放入函数
"""
# 常见写法，循环调用 1000 函数。
def cube(n):
    return n**3
cubes = [cube(e) for e in range(1000)]

# 建议写法，把重复的循环一次性塞入函数。
def compute_cubes():
    return [e**3 for e in range(1000)]
compute_cubes()

检查是否为 True

"""
检查是否为 True
"""
var = True
# 第一种，常见写法。== 会调用魔术函数 __eq__ 来比较左右两边的类型。
if var == True:
    pass

# 第二种，常见写法。使用 is 来判断。
if var is True:
    pass

# 建议写法，直接使用这种方式来判断，是否为空、是否为 None、是否为空 list、是否为空 dict 会比较快。
if var:
    pass

检查列表是否为空

"""
检查列表是否为空
"""
l = []
# 第一种，常见写法。
if len(l) == 0:
    pass

# 第二种，常见写法。
if l == []:
    pass

# 建议写法，这种方式最快。
if not l:
    pass

生成一个 list 或 dict

"""
生成一个 list or dict
"""
# 常见写法，使用 list 生成一个对象，会产生开销。
list()

# 建议写法，[] 直接返回一个 list，开销较小。
[]

# 第三种方式，{} 直接返回一个 dict，开销较小。
{}

链式比较

# 常见写法
a = 5
if a > 1 and a < 7:
    pass

# 建议写法
if 1 < a < 7:
    pass

变量交换

# 常见写法
x = 10
y = 5
tmp = x
x = y
y = tmp

# 建议写法
x = 10
y = 5
x, y = y, x

三目运算符

# 常见写法
a = 10
b = 5
if a > b:
    c = a
else:
    c = b

# 建议写法
c = a if a > b else b

拼接字符列表

# 常见写法
l = ['a', 'b', 'c', 'd']
str = ''
for e in l:
    str = str + e

# 建议写法
str = ''.join(l)

格式化字符

# 常见写法
name = "tony"
age = 100
str = "myname : " + name + " my age : " + str(age)
str = "myname : %s my age : %d" % (name, age)

# 建议写法
str = "myname : {} my age {}".format(name, age)

过滤列表

# 常见写法
mylist = range(20)
odd_list = []
for e in mylist:
    if e % 2 == 1:
        odd_list.append(e)

# 建议写法
odd_list = [e for e in mylist if e % 2 == 1]

过滤字典

# 常见写法
user_list = [{'name': 'lucy', 'email': 'lucy@g.com'}, {'name': 'lily', 'email': 'lily@g.com'}]
user_email = {}
for user in user_list:
    if 'email' in user:
        user_email[user['name']] = user['email']

# 建议写法
{user['name']: user['email'] for user in user_list if 'email' in user}

条件判断

# 常见写法
if l = []:
    pass

# 建议写法
if l:
    pass

# 常见写法
if something == None:
    pass

# 建议写法
if something is None:
    pass

emumerate 代替 for 循环中的对 index 变量的访问

# 常见写法
my_container = ['lily', 'lucy', 'tom']
index = 0
for element in my_container:
    print('{} {}'.format(index, element))
    index += 1

# 建议写法
for index, element in enumerate(my_container):
    print('{} {}'.format(index, element))

避免使用可变（mutable）变量作为函数参数的默认初始化值

# 常见写法
def function(l = []):
    l.append(1)
    return l

print function()
print function()
print function()

# print
[1]
[1, 1]
[1, 1, 1]

# 建议写法，使用 None 作为可变对象占位符
def function(l=None):
    if l is None:
      l = []
    l.append(1)
    return l

用字典对象完成 switch case 的功能

# 常见写法
def apply_operation(left_operand, right_operand, operator):
    if operator == '+':
        return left_operand + right_operand
    elif operator == '-':
        return left_operand - right_operand
    elif operator == '*':
        return left_operand * right_operand
    elif operator == '/':
        return left_operand / right_operand

# 建议写法
def apply_operation(left_operand, right_operand, operator):
    import operator as op
    operator_mapper = {'+': op.add, '-': op.sub, '*': op.mul, '/': op.truediv}
    return operator_mapper[operator](left_operand, right_operand)

一切皆对象

# 常见写法
def get_size(some_object):
    try:
        return len(some_object)
    except TypeError:
        if some_object in (True, False, None):
        return 1
    else:
        return int(some_object)

print(get_size('hello'))
print(get_size([1, 2, 3, 4, 5]))
print(get_size(10.0))

# 建议写法
def get_size(some_object):
    if isinstance(some_object, (list, dict, str, tuple)):
        return len(some_object)
    elif isinstance(some_object, (bool, type(None))):
        return 1
    elif isinstance(some_object, (int, float)):
        return int(some_object)