shJ'ai essayé une bibliothèque qui peut être utilisée en important la commande externe comme s'il s'agissait d'une fonction.
>>> from sh import echo
>>> echo('hello', 'world')
hello world
pipPeut être installé en utilisant.
$ pip install sh
Pour l'utiliser, importez simplement la commande que vous souhaitez utiliser depuis le module `` sh '' et exécutez-la.
>>> from sh import date
>>> date()
Dimanche 1 février 2015 22:50:13 JST
Vous pouvez également écrire:
>>> import sh
>>> sh.date()
Dimanche 1 février 2015 22:50:13 JST
Les arguments de commande peuvent être passés en tant qu'arguments de fonction.
>>> from sh import echo
>>> echo('hello', 'world')
hello world
Les options peuvent être passées en tant qu'arguments de mot-clé.
>>> from sh import curl
>>> curl('http://google.com/', o='out.html', silent=True, L=True)
Les options peuvent être passées comme arguments de fonction ainsi que comme arguments. Cela devrait être utilisé pour les commandes où l'option doit précéder l'argument.
>>> curl('-o', 'out.html', '--silent', '-L', 'http://google.com/')
Si vous spécifiez une chaîne de caractères dans l'argument de mot-clé _in```, vous pouvez la transmettre comme entrée standard à la commande.
>>> from sh import cat
>>> cat(_in='hello')
hello
_inIl est également possible de spécifier itérable pour.
>>> cat(_in=['hello\n', 'world\n'])
hello
world
Vous pouvez également transmettre un objet fichier.
>>> cat(_in=open('test.txt'))
hoge
fuga
piyo
En spécifiant le nom du fichier dans les arguments de mot-clé _out et `` _err, la sortie standard et l'erreur standard peuvent être redirigées vers le fichier.
>>> from sh import echo, cat
>>> echo('hello', 'world', _out='hello.txt')
>>> cat('hello.txt')
hello world
_out 、_errIl est également possible de passer une fonction de rappel à.
>>> echo('hello', 'world', _out=lambda s: sys.stdout.write(s.upper()))
HELLO WORLD
Si vous spécifiez l'argument mot-clé `` _iter, vous pouvez obtenir un itérateur qui renvoie le résultat ligne par ligne. tail -fDans le cas d'une commande qui continue à sortir indéfiniment, le processus ne se terminera pas._iter```Vous devez obtenir la sortie de l'itérateur à l'aide de.
>>> from sh import seq
>>> seq(1, 3)
1
2
3
>>> for n in seq(1, 3, _iter=True):
... print n.strip()
...
1
2
3
En imbriquant des fonctions, la sortie d'une fonction peut être acheminée vers l'entrée d'une autre fonction.
>>> from sh import echo, wc
>>> wc(echo('hello'), c=True)
6
Si vous l'emboitez trop, il sera difficile à comprendre, donc le ʻof toolz introduit dans Article précédent Il semble bon de l'utiliser en combinaison avec la fonction pipe```, thread_first```, etc.
>>> pipe('hello', echo, lambda x: wc(x, c=True))
6
>>> thread_first('hello', echo, (wc, '-c'))
6
shPar défaut, le tube fonctionne en passant le résultat à la commande suivante une fois la commande précédente terminée.
tail -fSi vous exécutez une commande qui ne se termine pas comme, elle ne reviendra pas, donc un argument mot-clé_pipeJ'ai besoin de vous dire ce qui se passe dans le pipeline.
>>> from sh import yes, tr
>>> it = tr(yes(), 'y','Y', _iter=True) #NG car la commande yes ne se termine pas
>>> it = tr(yes(_piped=True), 'y','Y', _iter=True) #C'est acceptable
>>> it.next()
u'Y\n'
Passer un astérisque comme argument de fonction ne le développe pas.
>>> from sh import ls
>>> ls('./*') #Parce qu'il ne sera pas déployé./*Les tentatives de recherche sont généralement infructueuses.
Utilisez sh.glob '' pour extraire. ** N'utilisez pas la bibliothèque standard `` glob.glob```. ** **
>>> from sh import ls, glob
>>> ls(glob('./*')) # sh.Développer à l'aide de glob
Par défaut, la fonction sh '' attend que le processus se termine. Si vous voulez l'exécuter en arrière-plan, ajoutez _bg = True``` à l'option. Vous pouvez attendre que le processus s'exécutant en arrière-plan se termine avec la méthode wait ''.
>>> from sh import sleep
>>> sleep(10) #Bloquer pendant 10 secondes
>>> p = sleep(10, _bg=True) #Reviendra bientôt
>>> p.wait() #Attendez la fin du processus
Le code de fin de la commande peut être obtenu avec exit_code. S'il se termine normalement, il devient généralement 0.
>>> from sh import ls
>>> output = ls('/tmp')
>>> output.exit_code
0
Une exception est déclenchée si la commande se termine anormalement. Un code de fin spécifique peut être capturé avec ErrorReturnCode_ <end code> `` `. ErrorReturnCode``` capture tous les codes de terminaison.
>>> from sh import ls, ErrorReturnCode_1
>>> try:
... output = ls('/hogehoge')
... except ErrorReturnCode_1:
... print "return code is 1"
...
return code is 1
>>> try:
... output = ls('/hogehoge')
... except ErrorReturnCode as e:
... print 'cmd:', e.full_cmd
... print 'returncode:', e.exit_code
... print 'stdout:', e.stdout
... print 'stderr:', e.stderr
...
cmd: /bin/ls /hogehoge
returncode: 1
stdout:
stderr: ls: /hogehoge: No such file or directory
Pour les commandes qui renvoient un code de fin différent de zéro même si la commande réussit, spécifiez une liste de codes de fin lorsque la commande réussit dans l'argument de mot-clé `` _ok_code```.
Vous pouvez signaler le processus avec les trois méthodes suivantes.
Si le processus se termine par un signal, SignalException_ <numéro de signal> se produira lorsque waitest exécuté. De plus,exit_code``` est le numéro de signal négatif.
>>> from sh import sleep
>>> p = sleep(10, _bg=True)
>>> p.kill()
>>> try:
... p.wait()
... except ErrorReturnCode as e:
... print 'cmd:', e.full_cmd
... print 'returncode:', e.exit_code
... print 'stdout:', e.stdout
... print 'stderr:', e.stderr
...
cmd: /bin/sleep 10
returncode: -9
stdout:
stderr:
Étant donné que les commandes externes pouvant être utilisées diffèrent en fonction de l'environnement, on peut voir que `` sh``` crée dynamiquement l'objet correspondant à la commande externe.
Le mécanisme d'importation de commandes arbitraires est à peu près implémenté dans le code suivant.
Le fait est que lors de l'importation de modules, sys.modules [__ name __] '' est remplacé par une classe qui hérite de `` ModuleType```.
mysh.py
import sys
import subprocess
from types import ModuleType
class MySh(ModuleType):
def __init__(self, self_module):
self.__name__ = self_module.__name__
def __getattr__(self, name):
def command(*args):
return subprocess.check_output([name] + list(args))
return command
mysh = sys.modules[__name__]
sys.modules[__name__] = MySh(mysh)
Vous pouvez utiliser ce module pour importer et exécuter echo comme suit:
>>> from mysh import echo
>>> echo('hello', 'world')
'hello world\n'