L'exécution de multi-instructions de ligne dans la ligne la ligne de commande?

ce style peut être utilisé dans les makefiles trop (et en fait, il est utilisé assez souvent).

python - <<EOF
import sys
for r in range(3): print 'rob'
EOF

ou

python - <<-EOF
    import sys
    for r in range(3): print 'rob'
EOF

dans ce dernier cas, leader des caractères de tabulation sont supprimés (et certains structuré outlook peut être atteint)

au lieu des expressions du FOLKLORE peut supporter un marqueur de mots ne figurant pas dans le document ici au début d'une ligne (voir aussi ici des documents dans la page de manuel de bash ou ici).

OriginalL'auteur xorho

<sup>- Pour faire cette réponse travailler avec Python 3.x ainsi, print est appelé comme un fonction: en 3.x, seulement print('foo') œuvres, tandis que le 2.x accepte aussi print 'foo'.

- Une croix-plate-forme de perspective qui inclut Windows, voir kxr de réponse utile.</sup>

Dans bash, ksh, ou zsh:

Utiliser un C ANSI-chaîne entre guillemets ($'...'), qui permet d'utiliser \n pour représenter les retours à la ligne qui sont développés de réels retours à la ligne avant de la chaîne est passée à python:

python -c $'import sys\nfor r in range(10): print("rob")'

Note le \n entre les import et for déclarations à l'effet d'un saut de ligne.

À passer shell valeurs de la variable à une telle commande, il est plus sûr d'utiliser arguments et d'y accéder via sys.argv à l'intérieur du script Python:

name='rob' # value to pass to the Python script
python -c $'import sys\nfor r in range(10): print(sys.argv[1])' "$name"

^{Voir ci-dessous pour une discussion sur les avantages et les inconvénients de l'utilisation d'une séquence d'échappement-prétraitées) double-cité chaîne de commande avec intégré shell-les références à des variables.}

De travailler en toute sécurité avec $'...' chaînes:

• Double \ des instances de votre original code source.
  • \<char> des séquences telles que \n dans ce cas, mais aussi les suspects habituels comme \t, \r, \b - sont développées par $'...' (voir man printf pour les prises en charge s'échappe)
• Échapper ' instances \'.

---

Si vous devez rester conforme à POSIX:

Utilisation printf avec un la substitution de commande:

python -c "$(printf %b 'import sys\nfor r in range(10): print("rob")')"

De travailler en toute sécurité avec ce type de chaîne:

• Double \ des instances de votre original code source.
  • \<char> des séquences telles que \n dans ce cas, mais aussi les suspects habituels comme \t, \r, \b - sont développées par printf (voir man printf pour la pris en charge des séquences d'échappement).

• Passer un unique cité chaîne de printf %b et échapper incorporé des guillemets simples comme '\'' (sic).

  • D'utiliser des guillemets simples protège la chaîne du contenu à partir de l'interprétation par le shell.

    • Cela dit, pour court scripts Python (comme dans ce cas), vous pouvez utiliser une chaîne de caractères entre guillemets pour intégrer shell les valeurs de la variable dans vos scripts, aussi longtemps que vous êtes conscient des pièges associés (voir le point suivant); par exemple, le shell étend $HOME à l'utilisateur actuel de la maison dir. dans la commande suivante:

      • python -c "$(printf %b "import sys\nfor r in range(10): print('rob is $HOME')")"

    • Cependant, une approche privilégiée consiste à transmettre des valeurs à partir du shell via arguments, et d'y accéder via sys.argv en Python, et l'équivalent de la commande ci-dessus est:

      • python -c "$(printf %b 'import sys\nfor r in range(10): print("rob is " + sys.argv[1])')" "$HOME"

  • Tout en utilisant un double-cité chaîne est plus pratique - il vous permet d'utiliser embedded guillemets simples sans échappement et intégré des guillemets doubles comme \" - il rend également la chaîne soumis à l'interprétation par la shell, qui peut ou peut ne pas être l'intention; $ et ` caractères dans votre code source qui ne sont pas destinés à la coque peut entraîner une erreur de syntaxe ou de modifier la chaîne de façon inattendue.

    • En outre, la coque est propre \ de traitement en double-cité des chaînes peut obtenir de la manière; par exemple, pour obtenir Python pour produire littérale de sortie ro\b, vous devez passer ro\\b; avec un '...' shell chaîne et doublé \ cas, nous obtenons:
      
      python -c "$(printf %b 'import sys\nprint("ro\\\\bs")')" # ok: 'ro\bs'
      
      En revanche, cela ne pas fonctionner comme prévu avec un "..." shell chaîne:
      
      python -c "$(printf %b "import sys\nprint('ro\\\\bs')")" # !! INCORRECT: 'rs'
      
      Le shell interprète les deux "\b" et "\\b" littérale \b, nécessitant une vertigineuse du nombre de supplémentaires \ instances pour obtenir l'effet désiré:
      
      python -c "$(printf %b "import sys\nprint('ro\\\\\\\\bs')")"

---

À passer le code via stdin plutôt que -c:

^{Note: je me concentre sur les uniqueligne de solutions ici; xorho réponse montre comment utiliser un multi-ligne ici-document - assurez-vous de devis le délimiteur, cependant; par exemple, <<'EOF', à moins que vous ne souhaitiez la coquille d'étendre la chaîne à l'avant (qui est livré avec les mises en garde mentionnées ci-dessus).}

---

Dans bash, ksh, ou zsh:

Combiner un C ANSI-chaîne entre guillemets ($'...') avec un chaîne ici (<<<...):

python - <<<$'import sys\nfor r in range(10): print("rob")'

- dit python explicitement à lire à partir de stdin (ce qu'il fait par défaut).
- est facultatif dans ce cas, mais si vous aussi vous souhaitez passer arguments pour les scripts, vous n'avez besoin de lever l'ambiguïté de l'argument à partir d'un script nom de fichier:

python - 'rob' <<<$'import sys\nfor r in range(10): print(sys.argv[1])'

---

Si vous devez rester conforme à POSIX:

Utilisation printf comme ci-dessus, mais avec un pipeline de façon à passer sa production via stdin:

printf %b 'import sys\nfor r in range(10): print("rob")' | python

Avec un argument:

printf %b 'import sys\nfor r in range(10): print(sys.argv[1])' | python - 'rob'

OriginalL'auteur mklement0

l'utilisation juste de retour et le type sur la ligne suivante:

user@host:~$ python -c "import sys
> for r in range(10): print 'rob'"
rob
rob
...

OriginalL'auteur SilentGhost

Si votre système est Posix.2 conforme, il doit fournir à l' printf utilitaire:

$ printf "print 'zap'\nfor r in range(3): print 'rob'" | python
zap
rob
rob
rob

OriginalL'auteur Alex Martelli

^{(réponse Nov 23 '10 à 19:48)}
Je ne suis pas vraiment un grand Pythoner mais j'ai trouvé cette syntaxe une fois, j'ai oublié d'où, donc, j'ai pensé document:

si vous utilisez sys.stdout.write au lieu de print (la différence étant, sys.stdout.write prend les arguments de la fonction, dans la parenthèse - alors que print n'est pas), puis pour un one-liner, vous pouvez vous en sortir avec l'inversion de l'ordre de la commande et de la for, la suppression du point-virgule, et en joignant la commande entre crochets, c'est à dire:

python -c "import sys; [sys.stdout.write('rob\n') for r in range(10)]"

N'ai aucune idée de comment cette syntaxe serait appelé en Python 🙂

Espère que cette aide,

Cheers!

---

^{(EDIT Mar Avr 9 20:57:30 2013)} eh Bien, je pense que j'ai enfin trouvé ce que ces crochets en one-liners sont; ils sont des "interprétations de la liste" (apparemment); abord de noter ce en Python 2.7:

$ STR=abc
$ echo $STR | python -c "import sys,re; a=(sys.stdout.write(line) for line in sys.stdin); print a"
<generator object <genexpr> at 0xb771461c>

Donc la commande dans les parenthèses/parenthèse est vu comme un "générateur d'objet"; si nous "itérer" grâce à en appelant next() - la commande à l'intérieur de la parenthèse sera exécuté (notez le "abc" dans la sortie):

$ echo $STR | python -c "import sys,re; a=(sys.stdout.write(line) for line in sys.stdin); a.next() ; print a"
abc
<generator object <genexpr> at 0xb777b734>

Si nous avons maintenant utiliser les crochets de noter que nous n'avons pas besoin d'appeler next() avoir la commande exécuter, il s'exécute immédiatement lors de la cession; cependant, plus tard, l'inspection révèle que a est None:

$ echo $STR | python -c "import sys,re; a=[sys.stdout.write(line) for line in sys.stdin]; print a"
abc
[None]

Cela ne laisse pas beaucoup d'infos à rechercher, pour les crochets cas - mais je suis tombé sur cette page qui, je pense, explique:

Python Trucs Et Astuces – Première Édition - Python Tutoriels | Rêve.Dans.Code:

Si vous vous souvenez, le format standard d'un seul générateur de ligne est une sorte de une ligne "pour" boucle à l'intérieur des crochets. Ceci va produire un 'one-shot' objet itérable qui est un objet que vous pouvez parcourir dans une seule direction et que vous ne pouvez pas re-utiliser une fois que vous atteignez la fin.

Une "liste de compréhension" est presque le même comme régulière d'un générateur de ligne, sauf que les parenthèses - ( ) - sont remplacées par des crochets - [ ]. Les principaux advanatge accédez à la liste de compréhension est que le produit d'une "liste", plutôt que d'un "one-shot" objet itérable, de sorte que vous pouvez aller et venir à travers elle, d'ajouter des éléments, de tri, etc.

Et en effet c'est une liste - c'est juste son premier élément devient néant dès qu'elle est exécutée:

$ echo $STR | python -c "import sys,re; print [sys.stdout.write(line) for line in sys.stdin].__class__"
abc
<type 'list'>
$ echo $STR | python -c "import sys,re; print [sys.stdout.write(line) for line in sys.stdin][0]"
abc
None

Interprétations de la liste sont par ailleurs documenté dans 5. Structures De Données: 5.1.4. Interprétations de la liste — Python v2.7.4 documentation "interprétations de la Liste de fournir de manière concise pour créer des listes"; sans doute, c'est là où le "executability" des listes intervient dans des one-liners.

Bien, espérons que je ne suis pas terriblement trop large de la marque ici ...

EDIT2: et voici un one-liner ligne de commande avec deux non-imbriquées pour des boucles; les deux enfermés à l'intérieur de la liste des "compréhension" entre crochets:

$ echo $STR | python -c "import sys,re; a=[sys.stdout.write(line) for line in sys.stdin]; b=[sys.stdout.write(str(x)) for x in range(2)] ; print a ; print b"
abc
01[None]
[None, None]

Avis que la seconde "liste" b a maintenant deux éléments, depuis sa boucle explicitement couru deux fois; toutefois, le résultat de sys.stdout.write() dans les deux cas était (apparemment) None.

OriginalL'auteur sdaau

Cette variante est plus portable pour mettre multi-scripts de ligne sur la ligne de commande sur Windows et *nix, py2/3, sans tuyaux:

python -c "exec(\"import sys \nfor r in range(10): print('rob') \")"

(Aucun des autres exemples vus jusqu'ici l'a fait)

Soigné sous Windows est:

python -c exec"""import sys \nfor r in range(10): print 'rob' """
python -c exec("""import sys \nfor r in range(10): print('rob') """)

Soigné sur bash/*nix:

python -c $'import sys \nfor r in range(10): print("rob")'

---

Cette fonction transforme n'importe quel multi-script dans un portable de commande one-liner:

def py2cmdline(script):
    exs = 'exec(%r)' % re.sub('\r\n|\r', '\n', script.rstrip())
    print('python -c "%s"' % exs.replace('"', r'\"'))

Utilisation:

>>> py2cmdline(getcliptext())
python -c "exec('print \'AA\tA\'\ntry:\n for i in 1, 2, 3:\n  print i /0\nexcept:\n print \"\"\"longer\nmessage\"\"\"')"

Entrée a été:

print 'AA   A'
try:
 for i in 1, 2, 3:
  print i / 0
except:
 print """longer
message"""

OriginalL'auteur kxr

Je voulais une solution avec les propriétés suivantes:

1. Lisible
2. Lire stdin pour le traitement de sortie d'autres outils

Deux exigences n'ont pas été fournis dans les autres réponses, donc voici comment lire stdin tout en faisant tout sur la ligne de commande:

grep special_string -r | sort | python3 <(cat <<EOF
import sys
for line in sys.stdin:
    tokens = line.split()
    if len(tokens) == 4:
        print("%-45s %7.3f    %s    %s" % (tokens[0], float(tokens[1]), tokens[2], tokens[3]))
EOF
)

OriginalL'auteur Nick

Si vous ne voulez pas toucher stdin et simuler comme si vous aviez passé "python cmdfile.py", vous pouvez effectuer les opérations suivantes à partir d'un shell bash:

$ python  <(printf "word=raw_input('Enter word: ')\nimport sys\nfor i in range(5):\n    print(word)")

Comme vous pouvez le voir, il vous permet d'utiliser l'entrée standard stdin pour la lecture des données d'entrée. En interne, le shell crée un fichier temporaire pour l'entrée de commande de contenu.

OriginalL'auteur Thava