手摸手教你如何在 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)