Explosive Geschwindigkeit Python-Feuer

python-fire/guide.md at master · google/python-fire · GitHub

Eine Google-Bibliothek, die es einfach macht, CLI mit Python zu erstellen ――Es ist so einfach, Argparser oder ähnliches zu verwenden

Basic

Übergeben Sie die Funktion zum Feuern und rufen Sie sie auf, und Sie sind fertig.

import fire

def hello(name="World"):
  return "Hello %s!" % name

if __name__ == '__main__':
  fire.Fire(hello)

Der obige Code wird wie unten gezeigt zu einem cli-Befehl.

python hello.py  # Hello World!
python hello.py --name=David  # Hello David!

Sie können die Methode von cli aus aufrufen, indem Sie die Klasse übergeben.

import fire

class Calculator(object):
  """A simple calculator class."""

  def double(self, number):
    return 2 * number

if __name__ == '__main__':
  fire.Fire(Calculator)

python calculator.py double 10  # 20
python calculator.py double --number=15  # 30

Erstellen Sie mehrere Befehle

Zunächst geschieht Folgendes mit dem Befehl cli.

$ python example.py add 10 20
30
$ python example.py multiply 10 20
200

Es gibt mehrere Möglichkeiten, dies zu erreichen:

Nennen Sie einfach nur Feuer

Alle Funktionen in der Datei werden in CLI-Befehle konvertiert
Auch wenn es eine Funktion gibt, die einfach, aber unnötig ist, wird sie zu einem Befehl

import fire

def add(x, y):
  return x + y

def multiply(x, y):
  return x * y

if __name__ == '__main__':
  fire.Fire()

Auch wenn die Datei eine Variable enthält, kann sie auch mit einem Befehl aufgerufen werden

import fire
english = 'Hello World'
spanish = 'Hola Mundo'
fire.Fire()

$ python example.py english
Hello World
$ python example.py spanish
Hola Mundo

Pass Diktat und Feuer

Sie können die gewünschte Funktion aus der Datei auswählen und zu einem CLI-Befehl machen.

import fire

def add(x, y):
  return x + y

def multiply(x, y):
  return x * y

if __name__ == '__main__':
  fire.Fire({
      'add': add,
      'multiply': multiply,
  })

Übergeben Sie eine Instanz einer Nur-Befehl-Klasse

import fire

class Calculator(object):

  def add(self, x, y):
    return x + y

  def multiply(self, x, y):
    return x * y

if __name__ == '__main__':
  calculator = Calculator()
  fire.Fire(calculator)

Übergeben Sie die Nur-Befehl-Klasse selbst

Es ist bequemer als das Übergeben einer Instanz, da sogar die beim Instanziieren übergebene Instanzvariable als Argument für cli verwendet werden kann.

import fire

class BrokenCalculator(object):

  def __init__(self, offset=1):
      self._offset = offset

  def add(self, x, y):
    return x + y + self._offset

  def multiply(self, x, y):
    return x * y + self._offset

if __name__ == '__main__':
  fire.Fire(BrokenCalculator)

$ python example.py add 10 20 --offset=0
30
$ python example.py multiply 10 20 --offset=0
200

Befehlsgruppierung

--Komplexe Befehle können realisiert werden, indem mehrere Befehlsklassen erstellt und über Instanzvariablen verschachtelt werden.

class IngestionStage(object):

  def run(self):
    return 'Ingesting! Nom nom nom...'

class DigestionStage(object):

  def run(self, volume=1):
    return ' '.join(['Burp!'] * volume)

  def status(self):
    return 'Satiated.'

class Pipeline(object):

  def __init__(self):
    self.ingestion = IngestionStage()
    self.digestion = DigestionStage()

  def run(self):
    self.ingestion.run()
    self.digestion.run()

if __name__ == '__main__':
  fire.Fire(Pipeline)

$ python example.py run
Ingesting! Nom nom nom...
Burp!
$ python example.py ingestion run
Ingesting! Nom nom nom...
$ python example.py digestion run
Burp!
$ python example.py digestion status
Satiated.

Zugriff auf Klasseneigenschaften

Wenn Sie eine Klasse zum Feuern übergeben, können Sie Instanzvariablen anstelle von Methoden aufrufen.

from airports import airports

import fire

class Airport(object):

  def __init__(self, code):
    self.code = code
    self.name = dict(airports).get(self.code)
    self.city = self.name.split(',')[0] if self.name else None

if __name__ == '__main__':
  fire.Fire(Airport)

$ python example.py --code=JFK code
JFK
$ python example.py --code=SJC name
San Jose-Sunnyvale-Santa Clara, CA - Norman Y. Mineta San Jose International (SJC)
$ python example.py --code=ALB city
Albany-Schenectady-Troy

Wenden Sie die Funktion auf den Rückgabewert des Befehls an

Sie können Befehle verketten, um eine Methode für den Rückgabewert aufzurufen
Im folgenden Beispiel wird die Methode "str.upper" aufgerufen

#Der Code selbst ist das obige Flughafenbeispiel
$ python example.py --code=ALB city upper
ALBANY-SCHENECTADY-TROY

Es ist praktisch, weil Sie Methoden nacheinander verketten können, wenn alle Methoden der Befehlsklasse sich selbst zurückgeben.

import fire

class BinaryCanvas(object):
  """A canvas with which to make binary art, one bit at a time."""

  def __init__(self, size=10):
    self.pixels = [[0] * size for _ in range(size)]
    self._size = size
    self._row = 0  # The row of the cursor.
    self._col = 0  # The column of the cursor.

  def __str__(self):
    return '\n'.join(' '.join(str(pixel) for pixel in row) for row in self.pixels)

  def show(self):
    print(self)
    return self

  def move(self, row, col):
    self._row = row % self._size
    self._col = col % self._size
    return self

  def on(self):
    return self.set(1)

  def off(self):
    return self.set(0)

  def set(self, value):
    self.pixels[self._row][self._col] = value
    return self

if __name__ == '__main__':
  fire.Fire(BinaryCanvas)

$ python example.py move 3 3 on move 3 6 on move 6 3 on move 6 6 on move 7 4 on move 7 5 on
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 0 0 0
0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

Passen Sie die Befehlsklasse für die Anzeige an

Wenn der Rückgabewert der aufgerufenen Methode eine Klasse ist, wird diese str- Methode aufgerufen.

Verschiedene Funktionsaufrufe von cli

Es gibt mehrere Optionen zum Aufrufen, wenn Sie eine Datei wie die folgende haben --Hyphen und Unterstrich können ersetzt werden
Das Argument kann entweder position oder benannt sein
Benannte Argumente und ihr Wert = können vorhanden sein oder nicht

import fire

class Building(object):

  def __init__(self, name, stories=1):
    self.name = name
    self.stories = stories

  def climb_stairs(self, stairs_per_story=10):
    for story in range(self.stories):
      for stair in range(1, stairs_per_story):
        yield stair
      yield 'Phew!'
    yield 'Done!'

if __name__ == '__main__':
  fire.Fire(Building)

$ python example.py --name="Sherrerd Hall" --stories=3 climb_stairs 10
$ python example.py --name="Sherrerd Hall" climb_stairs --stairs_per_story=10
$ python example.py --name="Sherrerd Hall" climb_stairs --stairs-per-story 10
$ python example.py climb-stairs --stairs-per-story 10 --name="Sherrerd Hall"

Andere

Machen Sie eine CLI, ohne Feuer in den Code selbst einzubetten

def hello(name):
  return 'Hello {name}!'.format(name=name)

python -m fire example hello --name=World
# => Hello World!

Angabe des Namens des Arguments in cli

--Method Argumente werden als Argumente in dieser Reihenfolge angewendet, ohne einen Namen in cli anzugeben --Aber wenn Sie mit - <arg-name> angeben, können Sie sich nach Namen bewerben

def say(name, content):
	print(name + ", " + content)

fire.Fire(say)

python say.py taro hello # taro, hello
python say.py --content=hello --name=taro # taro, hello

Ob das von cli übergebene Argument erforderlich oder optional ist

Grundsätzlich sind alle Argumente erforderlich. Wenn Sie die Argumente nicht mit cli übergeben, tritt ein Fehler auf. --Aber wenn Sie einen Standardwert für das Argument in der Methode angeben, wird dieser optional

def say(name, content="hello"):
	print(name + ", " + content)

fire.Fire(say)

python say.py taro # => taro, hello
python say.py # => error!

Wie man eine Liste als Argument von cli übergibt

python some.py "[test, test1]”

Hilfemeldung zu arg hinzufügen

Wenn Sie eine Beschreibung des Arguments in docstring schreiben, ist dies hilfreich
Wenn Sie im Folgenden "Python some.py -h" ausführen, wird "a" als "hogehoge" erklärt.

def main(a):
	"""
	a: hogehoge
	"""