Quelles sont les techniques efficaces pour programmer en Python ?

Inverser une liste

Il existe généralement deux façons d'inverser une liste en Python : le découpage ou l'appel de fonction reverse(). Les deux méthodes peuvent inverser une liste, mais sachez que la fonction intégrée reverse() modifie la liste d'origine, tandis que la méthode de découpage crée une nouvelle liste. reverse() 函数调用。这两种方法都可以反转列表，但需要注意的是内置函数 reverse() 会更改原始列表，而切片方法会创建一个新列表。

但是他们的表现呢？哪种方式更有效？让我们看一下下面的例子：

使用切片：

$ python -m timeit -n 1000000 -s 'import numpy as np' 'mylist=list(np.arange(0, 200))' 'mylist[::-1]'
1000000 loops, best of 5: 15.6 usec per loop

使用 reverse()：

$ python -m timeit -n 1000000 -s 'import numpy as np' 'mylist=list(np.arange(0, 200))' 'mylist.reverse()'
1000000 loops, best of 5: 10.7 usec per loop

这两种方法都可以反转列表，但需要注意的是内置函数 reverse() 会更改原始列表，而切片方法会创建一个新列表。

显然，内置函数 reverse() 比列表切片方法更快！

交换两个值

用一行代码交换两个变量值是一种更具有 Python 风格的方法。

与其他编程语言不同，Python 不需要使用临时变量来交换两个数字或值。举个简单的例子：

variable_1 = 100 
variable_2 = 500

要交换 variable_1 和 variable_2 的值，只需要一行代码。

variable_1, variable_2 = variable_2, variable_1

您也可以对字典使用相同的技巧：

md[key_2], md[key_1] = md[key_1], md[key_2]

该技巧可以避免多次迭代和复杂的数据转换，从而减少执行时间。

在函数内部循环

我们都喜欢创建自定义函数来执行我们自己的特定任务。然后使用 for 循环遍历这些函数，多次重复该任务。

但是，在 for 循环中使用函数需要更长的执行时间，因为每次迭代都会调用该函数。

相反，如果在函数内部实现了 for 循环，则该函数只会被调用一次。

为了更清楚地解释，让我们举个例子！

首先创建一个简单的字符串列表：

list_of_strings = ['apple','orange','banana','pineapple','grape']

创建两个函数，函数内部和外部都有 for 循环，从简单的开始。

def only_function(x):
    new_string = x.capitalize()
    out_putstring = x + " " + new_string
    print(output_string)

和一个带有循环的 for 函数：

def for_in_function(listofstrings):
    for x in list_of_strings:
        new_string = x.capitalize()
        output_string = x + " " + new_string
        print(output_string)

显然，这两个函数的输出是一样的。

然后，让我们比较一下，哪个更快？

如您所见，在函数内使用 for 循环会稍微快一些。

减少函数调用次数

判断对象的类型时，使用 isinstance() 最好，其次是对象类型标识 id()，对象值 type() 最后。

# Check if num an int type
type(num) == type(0) # Three function calls
type(num) is type(0) # Two function calls
isinstance(num,(int)) # One function call

不要将重复操作的内容作为参数放在循环条件中，避免重复操作。

# Each loop the len(a) will be called
while i < len(a):
    statement
# Only execute len(a) once
m = len(a)
while i < m:
    statement

要在模块 X 中使用函数或对象 Y，请直接使用 from X import Y 而不是 import X; then X.Y

Mais qu’en est-il de leur performance ? Quelle méthode est la plus efficace ? Jetons un coup d'œil à l'exemple suivant : 🎜🎜Utilisation de slices :🎜rrreee🎜Utilisation de reverse() :🎜rrreee🎜Les deux méthodes peuvent inverser la liste mais nécessitent de noter que le la fonction intégrée reverse() modifie la liste d'origine, tandis que la méthode de découpage crée une nouvelle liste. 🎜🎜Apparemment, la fonction intégrée reverse() est plus rapide que la méthode de découpage de liste ! 🎜🎜Échanger deux valeurs🎜🎜Échanger deux valeurs de variable avec une seule ligne de code est une approche plus pythonique. 🎜🎜Contrairement à d'autres langages de programmation, Python ne nécessite pas l'utilisation de variables temporaires pour échanger deux nombres ou valeurs. Un exemple simple : 🎜rrreee🎜 Pour échanger les valeurs de variable_1 et variable_2, une seule ligne de code est nécessaire. 🎜rrreee🎜 Vous pouvez également utiliser la même astuce avec les dictionnaires : 🎜rrreee🎜 Cette astuce évite les itérations multiples et les transformations de données complexes, réduisant ainsi le temps d'exécution. 🎜🎜Boucle à l'intérieur d'une fonction🎜🎜Nous aimons tous créer des fonctions personnalisées pour effectuer nos propres tâches spécifiques. Utilisez ensuite une boucle for pour parcourir ces fonctions, en répétant la tâche plusieurs fois. 🎜🎜Cependant, l'utilisation d'une fonction dans une boucle for prend plus de temps d'exécution car la fonction est appelée à chaque itération. 🎜🎜En revanche, si une boucle for est implémentée dans une fonction, la fonction ne sera appelée qu'une seule fois. 🎜🎜Pour expliquer plus clairement, donnons un exemple ! 🎜🎜Commencez par créer une simple liste de chaînes : 🎜rrreee🎜Créez deux fonctions avec des boucles for à l'intérieur et à l'extérieur de la fonction, commencez simplement. 🎜rrreee🎜 et une fonction for avec une boucle : 🎜rrreee🎜Évidemment, le résultat des deux fonctions est le même. 🎜🎜Alors, comparons, lequel est le plus rapide ? 🎜🎜🎜🎜Comme vous pouvez le voir, utilisez dans la fonction Une boucle for est légèrement plus rapide. 🎜🎜Réduisez le nombre d'appels de fonction🎜🎜Pour juger du type d'un objet, il est préférable d'utiliser isinstance(), suivi de l'identifiant du type d'objet id() , et la valeur de l'objet type () Enfin. 🎜rrreee🎜Ne mettez pas le contenu des opérations répétées comme paramètres dans des conditions de boucle pour éviter les opérations répétées. 🎜rrreee🎜Pour utiliser une fonction ou un objet Y dans le module X, utilisez directement from X import Y au lieu de import X puis X.Y ; Cela réduit une recherche lors de l'utilisation de Y (l'interpréteur n'a pas besoin de rechercher d'abord le module X, puis de rechercher Y dans le dictionnaire du module X). 🎜

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!