Explication détaillée des itertools, functools et modules de fonctions d'opérateur en python

module itertools

Dans le travail d’automatisation d’interface, nous devons souvent traiter de grandes quantités de données et effectuer diverses opérations itératives. Pour améliorer l'efficacité et simplifier le code, Python fournit le module itertools, qui contient des fonctions permettant de créer des itérateurs de boucle efficaces. Ensuite, comprenons et utilisons ensemble le module itertools, en donnant cinq exemples de codes dans le travail réel d'automatisation d'interface.

Exemple 1 : Comptage continu d'itérateurs

Lors des tests d’interface, nous devons parfois générer une série de nombres consécutifs. La fonction itertools.count() peut nous aider à créer un itérateur infini qui génère un entier croissant à chaque itération. Voici un exemple de code :

import itertools
for num in itertools.count(start=1, step=1):
    print(num)
    if num == 10:
        break

Dans le code ci-dessus, nous utilisons la fonction count() pour créer un itérateur commençant à 1 avec un pas de 1 et imprimons les 10 premiers nombres à travers la boucle.

Exemple 2 : répétitions de la boucle d'itérateur

Parfois, nous devons répéter le contenu d’une séquence ou d’un itérateur. La fonction itertools.cycle() peut nous aider à créer un itérateur de boucle infinie qui répète les éléments de la séquence à chaque itération. Voici un exemple de code :

import itertools
seq = [1, 2, 3]
for num in itertools.cycle(seq):
    print(num)
    if num == 3:
        break

Dans le code ci-dessus, nous utilisons la fonction cycle() pour créer un itérateur de boucle infinie qui répète les éléments de la séquence seq à chaque itération jusqu'à ce qu'il itère jusqu'au nombre 3.

Exemple 3 : arrangement de combinaison d'itérateurs

Parfois, nous devons combiner ou permuter des séquences pour générer toutes les combinaisons ou permutations possibles. Les fonctions itertools.combinations() et itertools.permutations() peuvent nous aider à atteindre cet objectif. Voici un exemple de code :

import itertools
seq = [1, 2, 3]
# 组合
for combination in itertools.combinations(seq, r=2):
    print(combination)
# 排列
for permutation in itertools.permutations(seq, r=2):
    print(permutation)

Dans le code ci-dessus, nous utilisons la fonction combinaisons() pour générer toutes les combinaisons de longueur 2 dans la séquence seq, et utilisons la fonction permutations() pour générer toutes les permutations de longueur 2 dans la séquence seq.

Exemple 4 : tranchage conditionnel de l'itérateur

Parfois, nous devons découper une séquence en fonction de conditions et conserver uniquement les éléments qui remplissent les conditions. La fonction itertools.takewhile() peut nous aider à atteindre cet objectif. Voici un exemple de code :

import itertools
seq = [1, 2, 3, 4, 5, 6]
# 保留小于等于3的元素
result = list(itertools.takewhile(lambda x: x <= 3, seq))
print(result)

Dans le code ci-dessus, nous utilisons la fonction takewhile() pour conserver les éléments inférieurs ou égaux à 3 dans la séquence seq, et stockons les résultats dans une liste.

Exemple 5 : filtres d'itérateur par condition

Parfois, nous devons filtrer les éléments qui remplissent les conditions de la séquence en fonction des conditions. La fonction itertools.filterfalse() peut nous aider à atteindre cet objectif. Voici un exemple de code :

importer des outils itertools

séquence = [1, 2, 3, 4, 5, 6]

# Filtrer les éléments non pairs

result = list(itertools.filterfalse(lambda x: x % 2 == 0, seq))

imprimer(résultat)

Dans le code ci-dessus, nous utilisons la fonction filterfalse() pour filtrer les éléments non pairs de la séquence seq et stocker les résultats dans une liste.

module outils fonctionnels

Dans le travail réel d'automatisation d'interface, nous avons souvent besoin de gérer des fonctions et des objets appelables, et le module functools de Python fournit des fonctions et des outils pratiques pour le fonctionnement de fonctions d'ordre élevé et d'objets appelables. Ensuite, comprenons et utilisons ensemble le module functools, en donnant cinq exemples de codes dans le travail réel d'automatisation d'interface.

Exemple 1 : Fonction partielle

Dans le travail d'automatisation d'interface, nous devons parfois créer une nouvelle fonction, qui est une version fixe de certains paramètres de la fonction d'origine. La fonction partial() du module functools peut nous aider à atteindre cet objectif. Voici un exemple de code :

import functools
# 原始函数
def add(a, b):
    return a + b
# 创建一个固定了第一个参数的新函数
add_5 = functools.partial(add, 5)
# 调用新函数
result = add_5(10)
print(result)

Dans le code ci-dessus, nous utilisons la fonction partial() pour créer une nouvelle fonction add_5, qui est une version à argument fixe de la fonction originale add(). Nous avons fixé le premier paramètre à 5 et en avons fait le paramètre par défaut de la nouvelle fonction, qui peut ensuite être utilisée pour les calculs.

Exemple 2 : mise en cache des fonctions

Dans le travail d'automatisation d'interface, certaines fonctions peuvent être appelées fréquemment et les résultats de calcul de ces fonctions sont les mêmes. Afin d'améliorer l'efficacité, nous pouvons utiliser la fonction lru_cache() du module functools pour mettre en cache la fonction afin d'éviter des calculs répétés. Voici un exemple de code :

import functools
# 需要进行缓存的函数
@functools.lru_cache()
def get_data(url):
    # 发送HTTP请求并获取数据
    # ...
    return data
# 第一次调用函数，会执行实际的计算
result1 = get_data("http://example.com")
# 第二次调用函数，会直接返回缓存的结果
result2 = get_data("http://example.com")

Dans le code ci-dessus, nous utilisons la fonction lru_cache() pour mettre en cache la fonction get_data(). Lorsque la fonction est appelée pour la première fois, le calcul réel est effectué et les résultats sont mis en cache, et les appels suivants renvoient directement les résultats mis en cache, améliorant ainsi l'efficacité d'exécution de la fonction.

Exemple 3 : décorateur de fonction

Lors du travail d'automatisation de l'interface, nous devrons peut-être effectuer des opérations supplémentaires ou ajouter des fonctionnalités à certaines fonctions. La fonction wraps() du module functools peut nous aider à créer des décorateurs de fonctions pour envelopper des fonctions sans modifier le code de la fonction d'origine. Voici un exemple de code :

import functools
# 自定义装饰器
def log_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("Calling function:", func.__name__)
        result = func(*args, **kwargs)
        print("Function", func.__name__, "finished")
        return result
    return wrapper
# 应用装饰器
@log_decorator
def calculate(a, b):
    return a + b
# 调用被装饰的函数
result = calculate(5, 10)
print(result)

Dans le code ci-dessus, nous définissons une fonction de décorateur log_decorator, qui utilise la fonction wraps() pour conserver les métadonnées de la fonction décorée, puis crée un nouveau wrapper de fonction pour envelopper la fonction d'origine. Dans la fonction wrapper, nous pouvons ajouter des opérations supplémentaires, telles que l'impression de journaux. Enfin, nous appliquons le décorateur à la fonction calculate en utilisant la syntaxe @log_decorator.

Exemple 4 : Comparateur de fonctions

Dans le travail d'automatisation d'interface, nous pouvons avoir besoin de trier un ensemble d'objets ou de trouver la valeur maximale/minimale. La fonction cmp_to_key() du module functools peut nous aider à convertir les fonctions de comparaison à l'ancienne en fonctions clés à utiliser dans les opérations de tri et de recherche. Voici un exemple de code :

import functools
# 旧式的比较函数
def compare(a, b):
    if a < b:
        return -1
    elif a > b:
        return 1
    else:
        return 0
# 将旧式的比较函数转换为键函数
key_func = functools.cmp_to_key(compare)
# 使用键函数进行排序
data = [4, 2, 6, 1, 3]
data.sort(key=key_func)
print(data)
# 使用键函数查找最大/最小值
max_value = max(data, key=key_func)
min_value = min(data, key=key_func)
print("Max:", max_value)
print("Min:", min_value)

Dans le code ci-dessus, nous définissons une fonction de comparaison à l'ancienne, puis utilisons la fonction cmp_to_key() pour la convertir en fonction clé key_func. En passant des fonctions clés aux fonctions sort(), max() et min(), nous pouvons utiliser des fonctions de comparaison à l'ancienne dans les opérations de tri et de recherche.

Exemple 5 : nouvelle tentative de fonction

Dans le travail d'automatisation d'interface, nous devons parfois réessayer certaines fonctions pour gérer d'éventuelles situations de panne. La fonction retry() du module functools peut nous aider à implémenter la logique de nouvelle tentative de la fonction. Voici un exemple de code :

import functools
# 需要重试的函数
@functools.retry()
def send_request(url):
    # 发送HTTP请求
    # ...
    # 如果请求失败，抛出异常
    raise Exception("Request failed")
# 调用带重试逻辑的函数
try:
    send_request("http://example.com")
except Exception as e:
    print("Error:", str(e))

Dans le code ci-dessus, nous utilisons la fonction retry() pour envelopper la logique de nouvelle tentative de la fonction send_request(). Si la fonction lève une exception, la fonction retry() réessayera automatiquement jusqu'à ce que le nombre de tentatives spécifié soit atteint. De cette façon, nous pouvons gérer d’éventuelles situations d’échec des appels de fonction.

module opérateur

Lorsque les gens programment en Python, ils utilisent souvent divers opérateurs pour effectuer des calculs numériques, des jugements logiques et d'autres opérations. Cependant, nous devons parfois traiter ces opérateurs sous forme de fonctions afin qu'ils puissent être appliqués de manière plus flexible dans différents scénarios. À l'heure actuelle, le module opérateur de Python est utile. Le module opérateur fournit une série de fonctions pour remplacer les opérateurs communs, nous permettant d'effectuer des opérations de manière fonctionnelle. Cet article présentera l'utilisation du module opérateur et fournira cinq exemples de codes pour le travail réel d'automatisation de l'interface.

Exemple 1 : Opérateurs de comparaison

Dans le travail d'automatisation d'interface, nous devons souvent comparer la taille ou l'égalité de deux valeurs. Les opérations de comparaison peuvent être facilement effectuées à l'aide des fonctions du module opérateur. Voici un exemple de code :

import operator
a = 10
b = 5
# 使用函数进行比较
result1 = operator.lt(a, b)  # a < b
result2 = operator.eq(a, b)  # a == b
result3 = operator.gt(a, b)  # a > b
print(result1)  # 输出False
print(result2)  # 输出False
print(result3)  # 输出True

Dans le code ci-dessus, nous utilisons les fonctions lt(), eq() et gt() pour comparer la relation de taille entre les variables a et b. En utilisant les fonctions du module opérateur, nous pouvons exprimer clairement les opérations de comparaison.

Exemple 2 : opérateurs arithmétiques

Dans le travail d'automatisation d'interface, nous devons parfois effectuer des opérations arithmétiques sur des nombres, telles que l'addition, la soustraction, la multiplication, etc. Le module opérateur fournit une série de fonctions pour remplacer ces opérateurs arithmétiques. Voici un exemple de code :

import operator
a = 10
b = 5
# 使用函数进行算术运算
result1 = operator.add(a, b)  # a + b
result2 = operator.sub(a, b)  # a - b
result3 = operator.mul(a, b)  # a * b
print(result1)  # 输出15
print(result2)  # 输出5
print(result3)  # 输出50

Dans le code ci-dessus, nous utilisons les fonctions add(), sub() et mul() pour effectuer des opérations d'addition, de soustraction et de multiplication. En utilisant les fonctions du module opérateur, nous pouvons éviter d'utiliser directement les opérateurs, rendant le code plus clair et plus facile à comprendre.

Exemple 3 : Opérateurs logiques

Dans le travail d'automatisation d'interface, nous devons souvent effectuer des opérations logiques, telles que AND, OR, NOT, etc. Le module opérateur fournit les fonctions correspondantes pour effectuer des opérations logiques. Voici un exemple de code :

import operator
a = True
b = False
# 使用函数进行逻辑运算
result1 = operator.and_(a, b)  # a and b
result2 = operator.or_(a, b)  # a or b
result3 = operator.not_(a)  # not a
print(result1)  # 输出False
print(result2)  # 输出True
print(result3)  # 输出False

Dans le code ci-dessus, nous utilisons les fonctions and_(), or_() et not_() pour effectuer des opérations logiques AND, OR et NOT. En utilisant les fonctions du module opérateur, nous pouvons gérer les opérations logiques de manière plus flexible.

Exemple 4 : Opérateur de séquence

Dans le travail d'automatisation d'interface, nous pouvons avoir besoin d'effectuer certaines opérations sur des séquences (telles que des listes et des tuples), telles que l'épissage, la répétition, etc. Le module opérateur fournit les fonctions correspondantes pour effectuer des opérations de séquence. Voici un exemple de code :

opérateur d'importation

feuille1 = [1, 2, 3]

liste2 = [4, 5, 6]

# Utiliser des fonctions pour les opérations de séquence

résultat1 = opérateur.concat(list1, liste2) # liste1 + liste2

résultat2 = opérateur.mul(list1, 3) # liste1 * 3

print(result1) # Sortie [1, 2, 3, 4, 5, 6]

print(result2) # Sortie [1, 2, 3, 1, 2, 3, 1, 2, 3]

Dans le code ci-dessus, nous utilisons la fonction concat() pour concaténer des listes et la fonction mul() pour effectuer des opérations répétées sur les listes. En utilisant les fonctions du module opérateur, nous pouvons opérer sur la séquence plus facilement.

Exemple 5 : Opérateurs d'indexation et de découpage

Dans le travail d'automatisation d'interface, nous devons souvent effectuer des opérations d'indexation et de découpage sur des listes, des chaînes, etc. Le module opérateur fournit les fonctions correspondantes pour les opérations d'indexation et de découpage. Voici un exemple de code :

import operator
list1 = [1, 2, 3, 4, 5]
# 使用函数进行索引和切片操作
result1 = operator.getitem(list1, 2)  # list1[2]
result2 = operator.setitem(list1, 1, 10)  # list1[1] = 10
result3 = operator.delitem(list1, 3)  # del list1[3]
print(result1)  # 输出3
print(result2)  # 输出None
print(result3)  # 输出None
print(list1)  # 输出[1, 10, 3, 5]

Dans le code ci-dessus, nous utilisons la fonction getitem() pour obtenir l'élément d'index spécifié de la liste, utilisons la fonction setitem() pour définir l'élément d'index spécifié de la liste et utilisons la fonction delitem() pour supprimer l'index spécifié. élément de la liste. En utilisant les fonctions du module opérateur, nous pouvons effectuer des opérations d'indexation et de découpage plus facilement.

Enfin : le didacticiel vidéo complet sur les tests de logiciels ci-dessous a été compilé et mis en ligne. Les amis qui en ont besoin peuvent l'obtenir eux-mêmes [garanti 100 % gratuit]

Document d'entretien sur les tests logiciels

"Nous devons étudier pour trouver un emploi bien rémunéré. Les questions d'entretien suivantes proviennent des derniers documents d'entretien de sociétés Internet de premier plan telles que Alibaba, Tencent, Byte, etc., et certains patrons de Byte ont donné des réponses faisant autorité. Après avoir terminé cela Je crois que tout le monde peut trouver un emploi satisfaisant sur la base des informations recueillies lors de l'entretien.