Sont une ligne de " si " / "pour" -déclarations de bonnes Python style?

Chaque tellement souvent ici je vois quelqu'un de code et ce qui semble être un "one-liner", que d'être un ligne d'instruction qui effectue de la façon standard d'un traditionnel déclaration " if " ou "pour" boucle fonctionne.

J'ai googlé autour et ne peut pas vraiment trouver ce type de celles que vous pouvez effectuer? Quelqu'un peut-il conseiller et de préférence, en donner quelques exemples?

Par exemple, pourrais-je le faire en une seule ligne:

example = "example"
if "exam" in example:
    print "yes!"

Ou:

for a in someList:
    list.append(splitColon.split(a))

Pas sûr de ce que vous cherchez ... pouvez-vous expliquer un peu plus?
Ne pas Python ont ces étranges lambda machines de nos jours et qui vous permettent de mettre un ensemble beaucoup plus sur une ligne? Non pas que je vais jamais les utiliser, bien sûr. Je préfère l'ancienne façon de faire les choses 🙂
je n'ai pas regardé dans les lambda encore. chaque fois que je vois ce mot dans une question ici, j'ai vite cliquez sur un signet!
Je pense qu'elle/il est en se référant à des interprétations de la liste.
au début, je pensais aussi OP demandait interprétations de la liste, mais sur une inspection plus minutieuse ils que signifiait "soit one-liner si-déclarations ou de déclarations"

InformationsquelleAutor Federer | 2009-11-13

53

Bien,
```
if "exam" in "example": print "yes!"
```
Est-ce une amélioration? Pas. Vous pouvez même ajouter des instructions du corps de la ifde la clause en les séparant par un point-virgule. Je recommande contre que, bien que.
- Sauf pour codegolf, bien sûr, puis les deux points sont essentiels 🙂
- ne serait pas seulement " imprimer "oui"' être mieux comme nous le savons '"examen" de la section "exemple"' est vrai
- Anurag: peut-être il ya une raison pourquoi Stephan utilisé le mot "exemple" dans ce segment de code.
- Pourquoi voudriez-vous éviter d'utiliser le point-virgule pour éviter de l'instructions? Juste pour éviter toute confusion pour quelqu'un de lire votre code?
- correct. Je pense que vous pouvez laisser de côté le mot "juste": la lisibilité est une ligne de conduite dans la programmation. Mettre plusieurs instructions sur une seule ligne, c'est mal vu dans la plupart des langues, mais encore plus en Python. Il est considéré comme unpythonic, au moins en partie parce qu'il n'est pas en ligne avec la philosophie sur laquelle la décision significative de l'espace est en fonction.
- Pas même pour "quelqu'un" à la lecture de votre code...pour vous-même! Vous seriez surpris de voir à quel point il peut être difficile à lire votre propre code si vous ne l'avez pas regardé, même dans un court laps de temps.
- Cette réponse semble aller à l'encontre de la PEP8 norme de codage.
- le extrait de code n', oui. La réponse dans son ensemble recommande à l'encontre de ce style, précisément en raison de la PEP-8. (Faut peut-être plus clair, il y a cinq ans.)
InformationsquelleAutor Stephan202
39

J'ai constaté que dans la majorité des cas, faire bloc clauses sur une ligne est une mauvaise idée.

Il sera, à nouveau comme une généralité, de réduire la qualité de la forme du code. De haute qualité forme de code est un élément clé pour le langage python.

Dans certains cas, python offrent des moyens todo choses sur une seule ligne qui sont certainement plus pythonic. Des choses telles que ce que Nick d'mentionné à la compréhension de liste:
```
newlist = [splitColon.split(a) for a in someList]
```
bien que, sauf si vous avez besoin d'une réutilisables liste plus précisément, vous pouvez envisager d'utiliser un générateur au lieu
```
listgen = (splitColon.split(a) for a in someList)
```
note la plus grande différence entre les deux est que vous ne pouvez pas réitérer sur un générateur, mais il est plus efficace à utiliser.

Il est également construit dans l'opérateur ternaire dans les versions modernes de python qui vous permettent de faire des choses comme
```
string_to_print = "yes!" if "exam" in "example" else ""
print string_to_print
```
ou
```
iterator = max_value if iterator > max_value else iterator
```
Certaines personnes peuvent trouver ces plus lisible et utilisable de la même if (condition): bloc.

Quand il descend à lui, c'est à propos de style de code et ce qui est la norme avec l'équipe, vous travaillez sur. C'est le plus important, mais en général, je déconseillerais d'une ligne de blocs que la forme du code en python est très important.
- J'ai trouvé l'opérateur ternaire utile pour les cas comme logging.info("Found %d %s", num_results, "result" if num_results == 1 else "results").
- J'ai vraiment comme le python est ternaire. Une fois que vous êtes habitué, c'est beaucoup plus lisible que la plupart des langues. Il fait l'historique <condition> ? <true value> : <false value> semblent assez archaïque.
- Merci , cela m'a vraiment aidé!
InformationsquelleAutor Bryan McLemore
18

Plus généralement, tous les éléments suivants sont valides du point de vue syntaxique:
```
if condition:
    do_something()


if condition: do_something()

if condition:
    do_something()
    do_something_else()

if condition: do_something(); do_something_else()
```
...etc.
- enfin, des points-virgules.. que j'ai été à la recherche pour les!
- Pour être clair, s'il vous plaît ne pas vraiment utiliser des points-virgules comme ça! J'essayais juste de répondre à la question complètement.
- une raison pour cela? ça simplifie ma vie si certains états, suivie par l'impression des déclarations, suivi par sys.exit()
- Il rend votre code impossible à lire par n'importe qui mais vous. Ce n'est pas élégant idiomatiques ou Python.
InformationsquelleAutor Cory Petosky
11

un exemple de langue, une fonctionnalité qui n'est pas seulement la suppression des sauts de ligne, bien que toujours pas convaincu que c'est plus clair que la version plus détaillée

a = 1 si x > 15 else 2

InformationsquelleAutor mbehan
7
```
for a in someList:
    list.append(splitColon.split(a))
```
Vous pouvez réécrire le ci-dessus que:
```
newlist = [splitColon.split(a) for a in someList]
```
- +1 pour la Compréhension de Liste
- Dans le premier cas, vous utilisez list et dans le deuxième vous utilisez newlist. Est-il une raison pour le changement?
- oh, en effet. L'OP utilisés "liste" dans son code. C'est pas une bonne pratique pour shadow fonction intégrée ou les noms de type, c'est à dire la "liste". C'est pourquoi j'ai utilisé "newlist" dans ma réponse.
- Ok, maintenant je le vois. Merci.
InformationsquelleAutor Nick Dandoulakis
6

Python vous permet de placer le retrait de la clause sur la même ligne si c'est une seule ligne:
```
if "exam" in example: print "yes!"

def squared(x): return x * x

class MyException(Exception): pass
```
- l'exemple n'est pas défini. Il a besoin de guillemets.
- Quelle partie de l'exemple ne comprenez-vous pas? Chaque fragment de code n'a pas besoin de déclarer l'ensemble de ses variables.
InformationsquelleAutor Ned Batchelder
4

Les anciennes versions de Python ne donnerait lieu qu'à une simple déclaration après for ...: if ...: ou similaire bloc des déclarations liminaires.

Je vois que l'on peut avoir de multiples déclarations simples sur la même ligne que l'un de ces. Cependant, il existe différentes combinaisons qui ne fonctionnent pas. Par exemple, nous pouvons:
```
for i in range(3): print "Here's i:"; print i
```
... mais, d'autre part, nous ne pouvons pas:
```
for i in range(3): if i % 2: print "That's odd!"
```
Nous pouvons:
```
x=10
while x > 0: print x; x-=1
```
... mais nous ne pouvons pas:
```
x=10; while x > 0: print x; x-=1
```
... et ainsi de suite.

En tout cas, tous ces éléments sont considérés comme extrêmement NON-pythonic. Si vous écrivez du code comme celui-ci l'expérience Pythoneux sera probablement prendre un peu de vos compétences.

C'est marginalement acceptable de combiner plusieurs instructions sur une ligne dans certains cas. Par exemple:
```
x=0; y=1
```
... ou encore:
```
if some_condition(): break
```
... pour la simple break continue et même return des déclarations ou des assignations.

En particulier si l'on a besoin d'utiliser une série de elif on peut utiliser quelque chose comme:
```
if     keystroke == 'q':   break
elif   keystroke == 'c':   action='continue'
elif   keystroke == 'd':   action='delete'
# ...
else:                      action='ask again'
```
... alors que vous pourriez ne pas irriter vos collègues de trop. (Cependant, les chaînes de elif comme ça hurler pour être reconstruit dans une dépêche de la table ... un dictionnaire qui pourrait ressembler à:
```
dispatch = {
    'q': foo.break,
    'c': foo.continue,
    'd': foo.delete
    }


# ...
while True:
    key = SomeGetKey()
    dispatch.get(key, foo.try_again)()
```
InformationsquelleAutor Jim Dennis
3

Vous pourriez faire tout cela en une seule ligne par l'omission de la example variable:
```
if "exam" in "example": print "yes!"
```
InformationsquelleAutor Dominic Rodger
0

Plonger dans python a un peu où il parle de ce qu'il appelle la et-ou de truc, ce qui semble être un moyen efficace pour se fourrer une logique complexe en une seule ligne.

Fondamentalement, il simule l'opérateur ternaire en c, en vous donnant un moyen de tester la vérité et de retourner une valeur basée sur le fait que. Par exemple:
```
>>> (1 and ["firstvalue"] or ["secondvalue"])[0]
"firstvalue"
>>> (0 and ["firstvalue"] or ["secondvalue"])[0]
"secondvalue"
```
- Attention: ce n' pas simuler le C de l'opérateur ternaire. 1 ? 0 : 2 est égal à 0, mais 1 and 0 or 2 est égal à 2. Il est beaucoup plus sûr d'utiliser une autre construction qui est faite précisément pour cette raison: 0 if 1 else 2 (qui est rendement 0).
- (Ici, le problème est que 0 évalue à False. La raison que votre code t travail, c'est parce que "firstvalue" évalue à True.)
- Cette astuce pré-dates de l'opérateur ternaire, et est une approximation, au mieux, compte tenu de ses problèmes avec les valeurs dont la valeur booléenne est Faux.
- Le lien que j'ai compris les couvre, et présente une solution de contournement. J'ai opté pour la version plus simple, mais compte tenu de la réponse, il semble que je devrait mettre en place de façon sécuritaire de le faire.
InformationsquelleAutor Dan Monego

Ceci est un exemple de "if else" avec des actions.

>>> def fun(num):
    print 'This is %d' % num
>>> fun(10) if 10 > 0 else fun(2)
this is 10
OR
>>> fun(10) if 10 < 0 else 1
1

InformationsquelleAutor Arindam Roychowdhury

Vous devez vous connecter pour publier un commentaire.