Résumé des techniques classiques pour utiliser Python aussi facilement que la soie

Cet article vous apporte des connaissances pertinentes sur python Il résume et présente principalement quelques conseils pour améliorer les performances de Python, notamment l'utilisation de map pour le mappage de fonctions, l'utilisation de set pour trouver une intersection, etc. aide.

Apprentissage recommandé : Tutoriel d'apprentissage Python

Comment mesurer le temps d'exécution d'un programme

À propos de Python, comment mesurer avec précision le temps d'exécution d'un programme Cette question semble simple mais est en réalité très compliquée, car le temps d'exécution du programme est affecté par de nombreux facteurs, tels que le système d'exploitation, la version de Python et le matériel associé (performances du processeur, vitesse de lecture et d'écriture de la mémoire), etc. Lors de l'exécution de la même version du langage sur le même ordinateur, les facteurs ci-dessus sont certains, mais le temps de veille du programme change toujours et d'autres programmes exécutés sur l'ordinateur interféreront également avec l'expérience, il s'agit donc à proprement parler de "Expériences". ne peut pas être répété. »

Les deux bibliothèques les plus représentatives que j'ai apprises sur le timing sont time et timeit.

Parmi elles, la bibliothèque time a trois fonctions : time(), perf_counter() et process_time() qui peuvent être utilisées pour le timing (en secondes). L'ajout du suffixe _ns signifie un timing en nanosecondes (depuis Python3.7). Il y avait une fonction clock() avant cela, mais elle a été supprimée après Python 3.3. Les différences entre les trois ci-dessus sont les suivantes :

• time() n'est relativement pas très précis et est affecté par le système. Il convient pour représenter la date et l'heure ou le timing de grands programmes.
• perf_counter() convient pour tester des programmes plus petits et calculera le temps de sleep().
• process_time() convient pour tester des programmes plus petits et ne compte pas le temps de sleep().

timeit présente deux avantages par rapport à la bibliothèque time :

• timeit choisira le meilleur timer en fonction de votre système d'exploitation et de votre version de Python.
• timeit désactive temporairement la collecte des déchets pendant le délai d'attente.

timeit.timeit(stmt='pass', setup='pass', timer=, number=1000000, globals=None) Description du paramètre :

• stmt='pass' : instruction ou fonction qui nécessite un timing.
• setup='pass' : Code à exécuter avant d'exécuter stmt. Habituellement, il est utilisé pour importer certains modules ou déclarer certaines variables nécessaires.
• timer= : fonction de minuterie, la valeur par défaut est time.perf_counter().
• number=1000000 : Le nombre de fois où exécuter les instructions de timing, la valeur par défaut est d'un million de fois.
• globals=Aucun : Spécifiez l'espace de noms du code exécuté.

Tous les timings de cet article utilisent la méthode timeit et le nombre d'exécutions par défaut est d'un million de fois.

Pourquoi devons-nous l'exécuter un million de fois ? Parce que notre programme de test est très court, si nous ne l’exécutons pas autant de fois, nous ne pourrons pas voir la différence du tout.

1. Utilisez map() pour le mappage de fonctions

Exp1 : convertissez les lettres minuscules du tableau de chaînes en lettres majuscules.

测试数组为 oldlist = ['life', 'is', 'short', 'i', 'choose', 'python']。

• Méthode un

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

• Méthode deux

list(map(str.upper, oldlist))

La première méthode prend 0,5267724000000005s, la deuxième méthode prend 0,41462569999999843s, les performances sont améliorées de 2 1,29%

2. Utilisez set() pour trouver l'intersection

Exp2 : Trouvez l'intersection de deux listes.

测试数组：a = [1,2,3,4,5]，b = [2,4,6,8,10]。

• Méthode un

overlaps = []for x in a:
    for y in b:
        if x == y:
            overlaps.append(x)

• Méthode deux

list(set(a) & set(b))

La première méthode prend 0,9507264000000006s, la deuxième méthode prend 0,6148200999999993s, les performances sont améliorées de 35 .33%

À propos de la syntaxe de set() : |, &, -Représente respectivement l'union, l'intersection et la différence.

3. Utilisez sort() ou sorted() pour trier

Nous pouvons trier la séquence de plusieurs façons, mais en fait, écrire vous-même l'algorithme de tri n'en vaut pas la peine. Parce que la méthode intégrée sort() ou sorted() est assez bonne et que la clé de paramètre peut être utilisée pour implémenter différentes fonctions, ce qui est très flexible. La différence entre les deux est que la méthode sort() est uniquement définie dans la liste, tandis que sorted() est une méthode globale valable pour toutes les séquences itérables.

Exp3 : utilisez les méthodes de tri rapide et sort() pour trier la même liste.

测试数组：lists = [2,1,4,3,0]。

• Méthode un

def quick_sort(lists,i,j):
    if i >= j:
        return list
    pivot = lists[i]
    low = i
    high = j    while i = pivot:
            j -= 1
        lists[i]=lists[j]
        while i 

• Méthode deux

lists.sort()

La première méthode prend 2,4796975000000003s, la deuxième méthode prend 0,05551999999999424s, les performances sont améliorées de 9 7,76%

Au fait, la méthode sorted() est prend du temps 0,1339823999987857s.

On peut voir que sort() est toujours très puissant en tant que méthode de tri spécifique à une liste. Bien que sorted() soit un peu plus lent que le premier, il est meilleur car il n'est "pas pointilleux" et il est efficace pour tous. séquences itérables.

Extension : Comment définir la clé de la méthode sort() ou sorted()

1 Définir via lambda

#学生：（姓名，成绩，年龄）
students = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)]students.sort(key = lambda student: student[0]) #根据姓名排序sorted(students, key = lambda student: student[0])

2 Définir via l'opérateur

import operator

students = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)]students.sort(key=operator.itemgetter(0))sorted(students, key = operator.itemgetter(1, 0)) #先对成绩排序，再对姓名排序

le itemgetter() de l'opérateur convient au tri de tableau ordinaire, attrgetter( ) convient au tri de tableaux d'objets

3. Définissez via cmp_to_key(), le plus flexible

import functools

def cmp(a,b):
    if a[1] != b[1]:
        return -1 if a[1]  b[2] else 1 #成绩姓名都相同，按照年龄降序排序 

students = [('john', 'A', 15),('john', 'A', 14),('jane', 'B', 12),('dave', 'B', 10)]sorted(students, key = functools.cmp_to_key(cmp))

4 Utilisez collections.Counter() pour compter

Exp4 : Comptez le nombre de fois où chaque caractère apparaît dans un. chaîne.

Test array : sentence='la vie est courte, je choisis python'.

• 方法一

counts = {}for char in sentence:
    counts[char] = counts.get(char, 0) + 1

• 方法二

from collections import CounterCounter(sentence)

方法一耗时 2.8105250000000055s，方法二耗时 1.6317423000000062s，性能提升 41.94% 

5.使用列表推导

列表推导（list comprehension）短小精悍。在小代码片段中，可能没有太大的区别。但是在大型开发中，它可以节省一些时间。

 Exp5：对列表中的奇数求平方，偶数不变。

测试数组：oldlist = range(10)。

• 方法一

newlist = []for x in oldlist:
    if x % 2 == 1:
        newlist.append(x**2)

• 方法二

[x**2 for x in oldlist if x%2 == 1]

方法一耗时 1.5342976000000021s，方法二耗时 1.4181957999999923s，性能提升 7.57% 

6.使用 join() 连接字符串

大多数人都习惯使用+来连接字符串。但其实，这种方法非常低效。因为，+操作在每一步中都会创建一个新字符串并复制旧字符串。更好的方法是用 join() 来连接字符串。关于字符串的其他操作，也尽量使用内置函数，如isalpha()、isdigit()、startswith()、endswith()等。

 Exp6：将字符串列表中的元素连接起来。

测试数组：oldlist = [‘life’, ‘is’, ‘short’, ‘i’, ‘choose’, ‘python’]。

• 方法一

sentence = ""for word in oldlist:
    sentence += word

• 方法二

"".join(oldlist)

方法一耗时 0.27489080000000854s，方法二耗时 0.08166570000000206s，性能提升 70.29% 

join还有一个非常舒服的点，就是它可以指定连接的分隔符，举个例子

oldlist = ['life', 'is', 'short', 'i', 'choose', 'python']sentence = "//".join(oldlist)print(sentence)

life//is//short//i//choose//python

7.使用x, y = y, x交换变量

 Exp6：交换x，y的值。

测试数据：x, y = 100, 200。

• 方法一

temp = x
x = y
y = temp

• 方法二

x, y = y, x

方法一耗时 0.027853900000010867s，方法二耗时 0.02398730000000171s，性能提升 13.88% 

8.使用while 1取代while True

在不知道确切的循环次数时，常规方法是使用while True进行无限循环，在代码块中判断是否满足循环终止条件。虽然这样做没有任何问题，但while 1的执行速度比while True更快。因为它是一种数值转换，可以更快地生成输出。

 Exp8：分别用while 1和while True循环 100 次。

• 方法一

i = 0while True:
    i += 1
    if i > 100:
        break

• 方法二

i = 0while 1:
    i += 1
    if i > 100:
        break

方法一耗时 3.679268300000004s，方法二耗时 3.607847499999991s，性能提升1.94% 

9.使用装饰器缓存

将文件存储在高速缓存中有助于快速恢复功能。Python 支持装饰器缓存，该缓存在内存中维护特定类型的缓存，以实现最佳软件驱动速度。我们使用lru_cache装饰器来为斐波那契函数提供缓存功能，在使用fibonacci递归函数时，存在大量的重复计算，例如fibonacci(1)、fibonacci(2)就运行了很多次。而在使用了lru_cache后，所有的重复计算只会执行一次，从而大大提高程序的执行效率。

 Exp9：求斐波那契数列。

测试数据：fibonacci(7)。

• 方法一

def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n-2)

• 方法二

import functools

@functools.lru_cache(maxsize=128)def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n-2)

方法一耗时 3.955014900000009s，方法二耗时 0.05077979999998661s，性能提升 98.72% 

注意事项：

• 缓存是按照参数作为键，也就说在参数不变时，被lru_cache装饰的函数只会执行一次。
• 所有参数必须可哈希，例如list不能作为被lru_cache装饰的函数的参数。

import functools
 
@functools.lru_cache(maxsize=100)def demo(a, b):
    print('我被执行了')
    return a + bif __name__ == '__main__':
    demo(1, 2)
    demo(1, 2)

我被执行了（执行了两次demo(1, 2)，却只输出一次）

from functools import lru_cache
 
@lru_cache(maxsize=100)def list_sum(nums: list):
    return sum(nums)if __name__ == '__main__':
    list_sum([1, 2, 3, 4, 5])

TypeError: unhashable type: ‘list’

functools.lru_cache(maxsize=128, typed=False)的两个可选参数：

• maxsize代表缓存的内存占用值，超过这个值之后，就的结果就会被释放，然后将新的计算结果进行缓存，其值应当设为 2 的幂。

• typed若为True，则会把不同的参数类型得到的结果分开保存。

10.减少点运算符(.)的使用

点运算符(.)用来访问对象的属性或方法，这会引起程序使用__getattribute__()和__getattr__()进行字典查找，从而带来不必要的开销。尤其注意，在循环当中，更要减少点运算符的使用，应该将它移到循环外处理。

这启发我们应该尽量使用from … import …这种方式来导包，而不是在需要使用某方法时通过点运算符来获取。其实不光是点运算符，其他很多不必要的运算我们都尽量移到循环外处理。

 Exp10：将字符串数组中的小写字母转为大写字母。

测试数组为 oldlist = [‘life’, ‘is’, ‘short’, ‘i’, ‘choose’, ‘python’]。

• 方法一

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

• 方法二

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

方法一耗时 0.7235491999999795s，方法二耗时 0.5475435999999831s，性能提升 24.33% 

11.使用for循环取代while循环

当我们知道具体要循环多少次时，使用for循环比使用while循环更好。

 Exp12：使用for和while分别循环 100 次。

• 方法一

i = 0while i 

• 方法二

for _ in range(100):
    pass

方法一耗时 3.894683299999997s，方法二耗时 1.0198077999999953s，性能提升73.82% 

12.使用Numba.jit加速计算

Numba 可以将 Python 函数编译码为机器码执行，大大提高代码执行速度，甚至可以接近 C 或 FORTRAN 的速度。它能和 Numpy 配合使用，在 for 循环中或存在大量计算时能显著地提高执行效率。

Exp12：求从 1 加到 100 的和。

• 方法一

def my_sum(n):
    x = 0
    for i in range(1, n+1):
        x += i    return x

• 方法二

from numba import jit

@jit(nopython=True) def numba_sum(n):
    x = 0
    for i in range(1, n+1):
        x += i    return x

方法一耗时 3.7199997000000167s，方法二耗时 0.23769430000001535s，性能提升 93.61% 

13.使用Numpy矢量化数组

矢量化是 NumPy 中的一种强大功能，可以将操作表达为在整个数组上而不是在各个元素上发生。这种用数组表达式替换显式循环的做法通常称为矢量化。

在 Python 中循环数组或任何数据结构时，会涉及很多开销。NumPy 中的向量化操作将内部循环委托给高度优化的 C 和 Fortran 函数，从而使 Python 代码更加快速。

 Exp13：两个长度相同的序列逐元素相乘。

测试数组：a = [1,2,3,4,5], b = [2,4,6,8,10]

• 方法一

[a[i]*b[i] for i in range(len(a))]

• 方法二

import numpy as np
a = np.array([1,2,3,4,5])b = np.array([2,4,6,8,10])a*b

方法一耗时 0.6706845000000214s，方法二耗时 0.3070132000000001s，性能提升 54.22% 

14.使用in检查列表成员

若要检查列表中是否包含某成员，通常使用in关键字更快。

 Exp14：检查列表中是否包含某成员。

测试数组：lists = [‘life’, ‘is’, ‘short’, ‘i’, ‘choose’, ‘python’]

• 方法一

def check_member(target, lists):
    for member in lists:
        if member == target:
            return True    return False

• 方法二

if target in lists:
    pass

方法一耗时 0.16038449999999216s，方法二耗时 0.04139250000000061s，性能提升 74.19% 

15.使用itertools库迭代

itertools是用来操作迭代器的一个模块，其函数主要可以分为三类：无限迭代器、有限迭代器、组合迭代器。

Exp15：返回列表的全排列。

测试数组：[“Alice”, “Bob”, “Carol”]

• 方法一

def permutations(lst):
    if len(lst) == 1 or len(lst) == 0:
        return [lst]
    result = []
    for i in lst:
        temp_lst = lst[:]
        temp_lst.remove(i)
        temp = permutations(temp_lst)
        for j in temp:
            j.insert(0, i)
            result.append(j)
    return result

• 方法二

import itertools
itertools.permutations(["Alice", "Bob", "Carol"])

方法一耗时 3.867292899999484s，方法二耗时 0.3875405000007959s，性能提升 89.98% 

结语

根据上面的测试数据，我绘制了下面这张实验结果图，可以更加直观的看出不同方法带来的性能差异。

从图中可以看出，大部分的技巧所带来的性能增幅还是比较可观的，但也有少部分技巧的增幅较小（例如编号5、7、8，其中，第 8 条的两种方法几乎没有差异）。

总结下来，我觉得其实就是下面这两条原则：

1.尽量使用内置库函数

内置库函数由专业的开发人员编写并经过了多次测试，很多库函数的底层是用C语言开发的。因此，这些函数总体来说是非常高效的（比如sort()、join()等），自己编写的方法很难超越它们，还不如省省功夫，不要重复造轮子了，何况你造的轮子可能更差。所以，如果函数库中已经存在该函数，就直接拿来用。

2.尽量使用优秀的第三方库

有很多优秀的第三方库，它们的底层可能是用 C 和 Fortran 来实现的，像这样的库用起来绝对不会吃亏，比如前文提到的 Numpy 和 Numba，它们带来的提升都是非常惊人的。类似这样的库还有很多，比如Cython、PyPy等，这里我只是抛砖引玉。

其实加快 Python 代码执行速度的方法还有很多，比如避免使用全局变量、使用最新版本、使用合适的数据结构、利用if条件的惰性等等，我这里就不一一例举了。这些方法都需要我们亲身去实践才会有深刻的感受和理解，但最根本的方法就是保持我们对编程的热情和对最佳实践的追求，这才是我们能不断突破自我、勇攀高峰的不竭动力源泉！

Apprentissage recommandé : Tutoriel d'apprentissage du python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!