La valeur de retour oubliée: cas d'utilisation pratiques pour «imprimer» dans les expressions

Vous pourriez ne jamais penser à utiliser print() dans une expression - après tout, c'est une fonction qui ne publie pas de texte et n'en renvoie None . Mais malgré sa valeur de retour apparemment inutile, il existe quelques façons pratiques (et au moins une intelligence) de tirer parti print() à l'intérieur des expressions, en particulier pendant le débogage ou l'exploration des données.

Voyons quand et pourquoi vous voudrez peut-être réellement utiliser print() où vous attendez normalement une valeur - non seulement pour les effets secondaires, mais dans le cadre du flux logique.

1. Débogage dans les compréhensions de la liste et les générateurs

Les compréhensions de la liste sont concises, mais difficiles à déboguer avec des appels print() car vous ne pouvez pas insérer des déclarations à l'intérieur. C'est là que l'intégration print() dans une expression est utile.

 données = [1, -2, 3, -4, 5]
squares = [x ** 2 pour x dans les données si x> 0]

Vous voulez voir quelles valeurs transmettent le filtre? Insérez simplement print() :

 squares = [x ** 2 pour x dans les données si x> 0 et imprimer (f "Traitement {x}") ou true]

Attendez - comment cela fonctionne-t-il?

• print() n'en revient None , qui est fausse.
• Ainsi x > 0 and print(...) or True garantit que la condition est toujours True après l'impression.
• Le or True fait passer le filtre quel que soit le retour de print() .

Oui, c'est un hack - mais un rapide pour le débogage sans casser la compréhension.

⚠️ Ne laissez pas cela dans le code de production. C'est purement pour l'inspection temporaire.

2. Valeurs de journalisation dans les fonctions lambda

Les fonctions lambda ne peuvent contenir des expressions, pas des instructions - vous ne pouvez donc pas écrire:

 lambda x: imprimer (x); x * 2 # syntaxerror

Mais vous pouvez vous faufiler dans print() car c'est un appel de fonction (une expression):

 debug_double = lambda x: print (f "entrée: {x}") ou x * 2

Encore une fois, print() n'en renvoie None , donc None or x * 2 évalue à x * 2 . L'effet secondaire est l'exploitation forestière.

Utile pour:

• Pipelines map() ou filter()
• Inspecter les valeurs intermédiaires dans les chaînes fonctionnelles

Exemple:

 Liste (map (Lambda x: print (f "Mapping {x}") ou x ** 2, [1, 2, 3]))
# Sortir:
# Mappage 1
# Mappage 2
# Mappage 3
# Résultat: [1, 4, 9]

3. Arguments par défaut pour le débogage

Parfois, vous voulez savoir quand un argument par défaut est utilisé. Vous pouvez utiliser print() dans l'expression par défaut:

 def saluer (nom, debug = print ("Utilisation du nom par défaut"))):
    Si ce n'est pas le nom:
        name = "anonymous"
    return f "Hello, {name}"

Maintenant, chaque fois que la fonction est définie (ou la valeur par défaut est évaluée), elle imprime. Remarque: Cela ne s'imprime qu'une seule fois à l'heure de définition, pas l'heure d'appel - il est donc limité.

Une meilleure version en utilisant None et vérification à l'intérieur:

 Def Greet (name = aucun):
    Si le nom n'est aucun:
        name = "anonymous"
        print ("Avertissement: en utilisant le nom par défaut")
    return f "Hello, {name}"

Pourtant, la version basée sur l'expression montre comment print() peut être intégré où seules les expressions sont autorisées.

4. Impression de l'opérateur de morse: Inspecter sans casser le flux

Avec l'opérateur de morse ( := ), vous pouvez attribuer et imprimer dans une expression - idéal pour déboguer les expressions complexes:

 if (Response: = input ("Entrée 'quit' pour quitter:")) == 'QUIT':
    imprimer ("Au revoir!")

Ajouter la journalisation sans lignes supplémentaires:

 if (réponse: = print (f "Debug: l'entrée était {entrée ('Entrée:')}") ou entrée ('Entrée:')) == 'QUIT':
    # Attendez - non, cela demanderait deux fois!
    passer

Oups - c'est dangereux. Au lieu de cela, capturez d'abord, puis imprimez:

 while (user_input: = input ("Entrée:"))! = "Quit":
    user_input = print (f "got: {user_input}") ou user_input # non, maintenant il n'en est pas!

Également cassé - parce que print() n'en revient None .

Manière correcte:

 Bien que vrai:
    if (user_input: = input ("Entrée:")) == "Quit":
        casser
    _ = print (f "Traitement: {user_input}") # juste pour le débogage
    # Continuer le traitement

Ou mieux - enveloppez-vous dans une aide:

 def debug (valeur, label = "valeur"):
    print (f "{label}: {valeur}")
    valeur de retour

# Utilisez maintenant en toute sécurité dans les expressions
data = [debug (x ** 2, "carré") pour x dans la plage (5)]

Ceci est plus propre que de compter sur print() de None () - mais montre pourquoi print() seul est risqué.

Fin de compte

print() n'en revient None - toujours. Mais dans des contextes où vous avez besoin d'une expression (compréhension, lambdas, par défaut), vous pouvez exploiter ce fait:

• Utilisez print(...) or value pour enregistrer et retourner value
• Intégrer dans lambda pour une sortie de débogage rapide
• Combiner avec or / and pour contrôler le flux sans modifier la logique
• Préférez les fonctions de wrapper pour plus de clarté

Il ne s'agit pas de conception propre - il s'agit d'outils pratiques et temporaires lorsque vous explorez le code.

Fondamentalement: oui, print() None revient, mais parfois None ne suffit - tant que quelque chose est imprimé.

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!