各位 Python 编程爱好者们！你们有没有过这样的经历，满心欢喜地写好代码，运行起来却发现速度慢得让人着急，心里别提多郁闷了。别担心，今天我就把珍藏已久的 9 个让 Python 代码效率飙升的技巧分享给大家，掌握了这些，你也能轻松写出又快又好的代码！

一、字符串拼接的最佳选择

咱们先来说说字符串拼接。在处理大量字符串时，选对拼接方法真的太重要了，以前我总是用+或者+=来拼接，图简单省事儿。就像这样：

mylist = ["Tan", "ChengYong", "is", "codeing"]
def concat_plus():
    result = ""
    for word in mylist:
        result += word + " "
    return result

可后来才发现，这在数据量大的时候简直是 “灾难”！因为字符串在 Python 里是不可变的，每次用+=，都得创建新字符串再复制旧字符串，太耗费资源了。直到我遇到了join()函数，从此打开了新世界的大门！

    def concat_join():
        return " ".join(mylist)

用它来拼接字符串，速度贼快，咱们用timeit模块测试一下。运行 10000 次，join()函数的速度明显快于+=的方式。而且，如果是连接固定的字符串，像"Tan" + "ChengYong" + "is" + "codeing"，Python 解释器在编译时就能优化，速度更快。所以，以后拼接一系列字符串，果断选join()；连接固定字符串，直接用+就好啦。

二、列表与字典的高效创建

创建列表也有讲究。以前我总爱用list()函数创建列表，后来发现，直接用[]才是 “真香” 选择！来看看测试：

    import timeit
    print(timeit.timeit('[]', number=10 ** 7))
    print(timeit.timeit(list, number=10 ** 7))

结果一目了然，[]作为字面量语法，比函数调用的list()快多了。创建字典也是同样道理，用{}比dict()快，这小小的改变，就能让代码效率提升，何乐而不为呢？

三、成员测试的数据结构最佳选择

成员测试这块，数据结构的选择至关重要。想象一下，要在一个超级大的数据集里找某个元素，用列表和集合的体验完全不同。在列表里查找，得一个一个挨着找，时间复杂度是 O (n)，数据量大的时候，等待的滋味可不好受。但集合就不一样，它基于哈希表实现，查找元素平均时间复杂度是 O (1),查找速度显著变快，我们先来看代码：

    import timeit
    large_dataset = range(100000)
    search_element = 2077
    large_list = list(large_dataset)
    large_set = set(large_dataset)
    def list_membership_test():
        return search_element in large_list
    def set_membership_test():
        return search_element in large_set
    print(timeit.timeit(list_membership_test, number=1000))
    print(timeit.timeit(set_membership_test, number=1000))

从测试结果可知以后做成员测试，还是得优先考虑集合。

四、数据生成利器：列表推导式

数据生成时，列表推导式绝对是个宝藏。以前我一直用 for 循环生成数据，后来尝试了列表推导式，瞬间被它折服！对比一下代码：

    import timeit
    def generate_squares_for_loop():
        squares = []
        for i in range(1000):
            squares.append(i * i)
        return squares
    def generate_squares_comprehension():
        return [i * i for i in range(1000)]
    print(timeit.timeit(generate_squares_for_loop, number=10000))
    print(timeit.timeit(generate_squares_comprehension, number=10000))

列表推导式不仅代码简洁优雅，速度还更快，因为它在 Python 的 C 语言底层做了优化。用它写代码，真的又快又爽！

五、提升循环效率的小秘诀

循环效率也有提升的小秘诀。在 Python 里，访问局部变量比访问全局变量或对象属性要快。看这个例子：

    import timeit
    class Example:
        def __init__(self):
            self.value = 0
    obj = Example()
    def test_dot_notation():
        for _ in range(1000):
            obj.value += 1
    def test_local_variable():
        value = obj.value
        for _ in range(1000):
            value += 1
        obj.value = value
    print(timeit.timeit(test_dot_notation, number=1000))
    print(timeit.timeit(test_local_variable, number=1000))

虽然差距看起来不大，但处理大量数据时，效果就很明显了。以后写循环，记得多利用局部变量。

六、善用内置模块和库

Python 的内置模块和库简直是编程的 “神器”！大多数内置模块和库都是用 C 语言编写的，速度非常快。就拿统计列表元素频率来说，自己写 for 循环去统计，又麻烦又慢。但用collections模块里的Counter类，一行代码就能搞定，还跑得飞快！代码如下：

    import timeit
    import random
    from collections import Counter
    def count_frequency_custom(lst):
        frequency = {}
        for item in lst:
            if item in frequency:
                frequency[item] += 1
            else:
                frequency[item] = 1
        return frequency
    def count_frequency_builtin(lst):
        return Counter(lst)
    large_list = [random.randint(0, 100) for _ in range(1000)]
    print(timeit.timeit(lambda: count_frequency_custom(large_list), number=100))
    print(timeit.timeit(lambda: count_frequency_builtin(large_list), number=100))

这对比结果太明显了，以后可别傻傻地自己写复杂代码了，内置模块它不香吗？

七、提升函数调用效率

@functools.cache这个装饰器超好用，并且能让函数调用效率大幅提升！，就拿斐波那契数列这种递归计算的函数来说，存在较多的重复计算，效率很低。但加上这个装饰器，就能缓存之前的计算结果，下次直接用，速度显著提升，看测试代码：

    import timeit
    import functools
    def fibonacci(n):
        if n in (0, 1):
            return n
        return fibonacci(n - 1) + fibonacci(n - 2)
    @functools.cache
    def fibonacci_cached(n):
        if n in (0, 1):
            return n
        return fibonacci_cached(n - 1) + fibonacci_cached(n - 2)
    print(timeit.timeit(lambda: fibonacci(30), number=1))
    print(timeit.timeit(lambda: fibonacci_cached(30), number=1))

由此测试结果可知，以后遇到可能存在重复计算的函数，记得用这个装饰器。

八、无限循环的细微差异

创建无限循环时，while 1比while True稍微快那么一点点，因为1是字面量，True是全局变量，查找时会多一点开销。不过在现代 Python 解释器里，这差距基本可以忽略不计。从代码可读性考虑，while True更直观，大家可以按需选择。

九、按需导入模块

最后，导入模块也有学问。以前我习惯在脚本顶部把所有模块都导入，后来发现，对于大模块，按需导入更好。比如这样：

    def my_function():
        import Heavy_module
        # 函数的其余部分

这就是延迟加载，只有函数被调用时才导入模块。要是这个函数一直没被调用，模块就不用加载，能节省资源，还能缩短脚本启动时间呢！

好啦，以上就是我分享的 9 个让 Python 代码效率更高的技巧。希望大家都能在编程中试试这些方法，让自己的代码跑得更快、更流畅！一起加油，成为更厉害的 Python 程序员！