8
votes

opérateurs logiques remplaçant si des déclarations

sont les utilisations suivantes d'expressions logiques pythoniques / pep8 conformes?

ceci: p>
```
if not x:
    x = y
```
ceci: p>
```
if not a:
    x = a
else:
    x = b
```
(la courbe-ballon?) Ceci: P>
```
if not a:
    x = b
else:
    x = a
```

python pep8 logical-operators

11 commentaires

Je ne pense pas que pep8 spécifie ce genre de chose. Mon avis: Les deuxième versions sont beaucoup plus lisibles et donc préférables. Ne me fais pas penser.

1 et 3 sont simples et couramment utilisés (bien que je ne suis pas sûr d'environ 3), mais 2 m'a pris quelques secondes pour lire, alors je ne l'utiliserais probablement pas.

Même s'ils sont corrects, ils sont très difficiles à comprendre l'OMHO. Aussi, quelle est la fréquence exacte pas un vraiment ce que vous voulez (plutôt que, par exemple, A est Aucun )?


                                        
                                                                            "Compte de la lisibilité". Il est irrégulier de la facilité d'entre eux de lire des programmeurs de python relativement expérimentés, je pense qu'ils pourraient confondre quelqu'un d'une langue dans laquelle les opérateurs logiques retiennent des booléens.
                                        
                                                                            # 1 et # 3 sont identiques et utilisés un peu utilisés. Je n'ai jamais vu # 2 utilisé. La nécessité pour ceux-ci est diminuée depuis l'introduction du ternaire  .. si ... sinon .. .

                                        
                                                                            Si 1 et 2 étaient incimthoniques,  et  et  ou  auraient des résultats booléens, car il s'agit de la seule application de leur comportement actuel

                                        
                                                                            @Pavelanossov for # 2 Considérez un attribut XML booléen:  attr = nœud.hasattr ('y') et nœud.getattr ('y') == 'vrai' 

                                        
                                                                            @SCruffy: D'accord, tout le monde que je sais écrirait comme  attr = faux; Si node.hasattr ('y'): attr = node.getattr ('y') . Mais il se sent bizarre pour  faux  pour signifier l'absence. Donc, ce serait  attr = aucun .

                                        
                                                                            @SCruffy:  node.get ('y', false)  est beaucoup plus simple.

                                        
                                                                            @Blender j'utilise le natif xml.dom et je ne pense pas qu'il supporte que le type dict get ... S'il vous plaît corrigez-moi si je me trompe.
                                        
                                                                            @SCruffy: lxml et  xml.etree  les utilisent. Je ne suis pas trop sûr d'autres analyseurs.



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                      PEP 8  n'a rien à voir avec la façon dont vous utilisez votre logique opérateurs. 

 Assumer la motivation pour utiliser les opérateurs logiques au lieu des conditionnels, c'est une brièveté, il est mieux accompli avec l'opérateur ternaire: 


   x = a si a d'autre b  au lieu de  x = a ou b      
   x = b Si un autre a el / code> au lieu de  x = a et b    
   x = x si x elez y  ou juste  si non x: x = y  au lieu de  x = x ou y   


 Mais personne ne vous interdit d'utiliser aussi les autres versions. Tout est un mètre d'opinion personnelle. La motivation de l'introduction de l'opérateur ternaire consistait à éviter les tentatives d'erreur visant à obtenir le même effet en utilisant les opérateurs  et  et  (voir  PEP 308 ). Ils permettent également des trucs de fantaisie dans les compréhensions de la liste et quelques autres choses. 

 Ils ne sont pas introduits pour remplacer complexes si des déclarations, mais comme un  Pythonic  opérateur ternaire:  x si condition y .                                 


                                                                    
                                    
                                    
                                        12 commentaires
                                        
                                                                                            
                                                    En fait, je vais contester que ces formes courtes sont meilleures que les blocs explicites  si  blocs.                                                

                                                
                                                                                            
                                                    Je pense vraiment que 3. devrait être  x = x ou y  au lieu du triction.                                                

                                                
                                                                                            
                                                    Pour moi,  x = x si x else y  est plus difficile à lire qu'une instruction IF.                                                

                                                
                                                                                            
                                                    @viktorkerkerkez  si non x: x = y  découragé par pep8.                                                

                                                
                                                                                            
                                                    @SCruffy je suis d'accord. Je viens de l'écrire dans une ligne depuis l'énumération avec un frein de syntaxe de markdown si j'ajoute des blocs de code multilignes :)                                                
                                                
                                                                                            
                                                    Ok, je suis convaincu que dans tous les cas, même x = x ou y, le ternaire est le meilleur parce que: 1) c'est explicite. Vous savez ce que vous revenez, et ce n'est pas nécessairement un booléen, et 2) c'est concis.                                                
                                                
                                                                                            
                                                    @SCruffy:  vraiment  dépend du contexte. L'opérateur ternaire ne peut pas gérer des cas comme  x = a () ou b () , comme vous devez appeler  a  deux fois ou stocker le résultat dans une variable. Il suffit d'utiliser le bon sens et ne vous efforcez pas d'écrire la doublure la plus compliquée possible.                                                

                                                
                                                                                            
                                                    Je suis respectueusement en désaccord que l'utilisation des opérateurs logiques de cette manière n'est pas pythonique. Pourquoi continueraient-ils à se comporter de cette façon si les personnes travaillant sur la langue pensaient qu'ils n'étaient pas pythoniques? C'est aussi comment Lisp se comporte et cela fonctionne assez bien.                                                
                                                
                                                                                            
                                                    @Viktorkerkerkez: L'opérateur ternaire a été introduit pour résoudre l'abus d'une doublure qui a essayé de l'imiter.  A ou B  n'agit pas comme un opérateur ternaire. Les opérateurs logiques à court-circuit font partie de la langue, alors pourquoi  A et B  renvoie autre chose qu'un booléen si le résultat n'était pas destiné à être utilisé?                                                

                                                
                                                                                            
                                                    Hmm. La question concerne les opérateurs logiques et non les opérateurs ternaires. Peut-être que je vais vous mal comprendre. Notez que je  a fait  avez-vous vu que vous avez mentionné les opérateurs ternaires, mais vous avez également mentionné des opérateurs logiques. Tout simplement pas sûr pourquoi Ternary a été introduit dans le mélange.                                                

                                                
                                                                                            
                                                    Cela commence à devenir un débat religieux, dont la place n'est pas alors, alors je supprime tous mes commentaires dans ce fil :) Dans ma réponse, je n'ai expliqué que pour ne pas être utilisée comme remplaçant pour l'opérateur ternaire et c'est tout J'ai dit. La question a été clairement indiquée:  Les opérateurs logiques remplacent si des déclarations , il n'était pas mentionné sur le court-circuit ni "si ces opérateurs doivent être évités".                                                

                                                
                                                                                            
                                                    @PhillipCloud: Je pense que Viktor a lu entre les lignes et il avait raison. La motivation pour l'utilisation des opérateurs logiques au lieu des déclarations de si est la brièveté. Dans ce cas, il est mieux accompli avec le ternaire. J'ai édité la réponse pour rendre cette explicite.                                                
                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Je ne pense pas que Pep8 couvre cela, mais pour moi, dans vos exemples, le  si  Les déclarations sont plus lisibles (surtout aux personnes nouvelles de Python (et donc plus pythoniques en raison de "compte de lisibilité" ") que les opérateurs logiques, qui ont toujours l'air plus pythonique que les opérateurs ternaires. 

 Cependant, les opérateurs ternaires sont définitivement meilleurs que  condition et true_value ou faux_value ,  (faux_value, true_value) [condition]  etc. due à être plus lisible et moins susceptible de pause.                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Contrairement aux opérateurs logiques de C et Java, les opérateurs logiques de Python ne retourne pas booléens. Je ne peux pas imaginer un autre cas d'utilisation pour cette caractéristique de la langue en plus de celui de votre question, alors à moins que les concepteurs de langue ajoutent des fonctionnalités irréfléchi, c'est Pythonic (à l'exception du n ° 3). 
 Il y a beaucoup de cas où le court-circuit logique ou peut être utilisé à votre avantage. Voici un simple du code source de  Demandes :  P> 
d.get('key', 'fallback')

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    J'ai changé ma réponse acceptée à celle-ci parce que la question était de savoir si elle est "pythonique".

Articles qui pourrait vous intéresser : Python: ConnectionError: HTTPSConnectionPool (hôte = 'api.foursquare-com', port = 443) L'exécution de Flask sous Windows n'exécute pas la commande d'exécution de flask Chatbot installé mais obtention d'une erreur lors de l'importation de ChatBot Administrateur Django: __str__ a renvoyé une non-chaîne (type int)