Equivalent de Backticks Bash en Python

Question

Quel est l'équivalent des backticks trouvés dans Ruby et Perl en Python? C'est-à-dire, dans Ruby, je peux faire ceci:

foo = `cat /tmp/baz` 

À quoi ressemble l'instruction équivalente en Python? J'ai essayé os.system("cat /tmp/baz") mais cela met le résultat à standard et me renvoie le code d'erreur de cette opération.

Answer 1

output = os.popen('cat /tmp/baz').read() 

Answer 2

La manière la plus flexible est d'utiliser le module subprocess:

import subprocess 

proc = subprocess.Popen(["cat", "/tmp/baz"], stdout=subprocess.PIPE) 
(out, err) = proc.communicate() 
print "program output:", out 

Si vous voulez passer l'appel à travers la coquille, par exemple pour obtenir l'expansion du nom de fichier avec *, vous pouvez utiliser le paramètre shell=True. Si vous faites cela, vous devez fournir la commande sous forme de chaîne, cité/... comme vous écriraient à une invite du shell:

proc = subprocess.Popen('cat /tmp/ba* "s p a c e.txt"', shell=True, ...) 

Answer 3

import os 
foo = os.popen('cat /tmp/baz', 'r').read() 

Answer 4

sth is right. Vous pouvez également utiliser os.popen(), mais lorsque le sous-processus disponible (Python 2.4+) est généralement préférable.

Cependant, contrairement à certaines langues qui l'encouragent, il est généralement considéré comme incorrect de générer un sous-processus dans lequel vous pouvez effectuer le même travail dans la langue. C'est plus lent, moins fiable et dépend de la plateforme. Votre exemple serait mieux que:

foo= open('/tmp/baz').read() 

eta:

baz est un répertoire et je suis en train de récupérer le contenu de tous les fichiers dans ce répertoire

? chat sur un répertoire me fait une erreur.

Si vous voulez une liste de fichiers:

import os 
foo= os.listdir('/tmp/baz') 

Si vous voulez le contenu de tous les fichiers dans un répertoire, quelque chose comme:

contents= [] 
for leaf in os.listdir('/tmp/baz'): 
    path= os.path.join('/tmp/baz', leaf) 
    if os.path.isfile(path): 
     contents.append(open(path, 'rb').read()) 
foo= ''.join(contents) 

ou, si vous pouvez être sûr qu'il ya pas de répertoires là-dedans, vous pouvez l'adapter dans un seul ligne:

path= '/tmp/baz' 
foo= ''.join(open(os.path.join(path, child), 'rb').read() for child in os.listdir(path)) 

Answer 5

Si vous utilisez subprocess.Popen, n'oubliez pas de spécifier bufsize. La valeur par défaut est 0, ce qui signifie "sans tampon", et non "choisir un défaut raisonnable".

Answer 6

J'utilise

(6: 0) $ python --version Python 2.7.1

L'un des exemples ci-dessus est:

import subprocess 
proc = subprocess.Popen(["cat", "/tmp/baz"], stdout=subprocess.PIPE, shell=True) 
(out, err) = proc.communicate() 
print "program output:", out 

Pour moi, cela n'a pas réussi à accéder au répertoire/tmp.Après avoir regardé la doc string pour subprocess j'ai remplacé

[ "prog", "arg"]

avec

"prog arg"

et obtenu le comportement de dilatation de la coque que l'on désirait (un «prog arg`» de la Perl)

subprocess.Popen d'impression ("ls -ld/tmp/v *", stdout = subprocess.PIPE, shell = True) .communicate() [0]

---

Je cesser d'utiliser un python tandis que de retour parce que j'étais ennuyé par la difficulté de faire l'équivalent de perl `cmd ...`. Je suis heureux de constater que Python a rendu cela raisonnable.

Answer 7

foo = subprocess.check_output(["cat", "/tmp/baz"]) 

Answer 8

Le moyen le plus simple consiste à utiliser le package de commandes.

import commands 

commands.getoutput("whoami") 

Sortie:

'bganesan'

Answer 9

Cela ne fonctionnera pas dans python3, mais python2 vous pouvez étendre str avec une méthode personnalisée __repr__ qui appelle votre commande shell et retourne comme ça:

#!/usr/bin/env python 

import os 

class Command(str): 
    """Call system commands""" 

    def __repr__(cmd): 
     return os.popen(cmd).read() 

Whic h vous pouvez utiliser comme

#!/usr/bin/env python 
from command import Command 

who_i_am = `Command('whoami')` 

# Or predeclare your shell command strings 
whoami = Command('whoami') 
who_i_am = `whoami` 

Answer 10

A partir de Python 3.5 en avant, la méthode recommandée est d'utiliser subprocess.run. Pour obtenir le même comportement que vous décrivez, vous utiliseriez:

output = subprocess.run("ls", shell=True, stdout=subprocess.PIPE).stdout 

Cela renverra un objet bytes. Vous pouvez ajouter .decode("ascii") ou .decode("utf-8") à la fin pour obtenir un str.