Effizienz und Pythonie von Füllraum (e) für die Zeichenfolge in Python

Question

Von How can I fill out a Python string with spaces?, die akzeptierte Antwort auf Pad-Zeichen zu Zeichenfolge auf der rechten Seite ist die Verwendung der str.ljust().

Aber wenn wir Zeichen auf links auffüllen wollen, können wir verwenden str.rjust() und auf beide auffüllen können wir str.center(), z.

>>> s = 'foobar' 
>>> s.ljust(len(s)+1) # pads one space to the right 
'foobar ' 
>>> s.rjust(len(s)+1) # pads one space to the left 
' foobar' 
>>> s.center(len(s)+2) # pads one space to both left and right 
' foobar ' 

Aber auf dem Back-End, ist dass wirklich effizienter als dies einfach tun?:

>>> ' ' + s + ' ' 
' foobar ' 
>>> ' '*10 + s + ' '*10 # pads ten spaces to both left and right 
'   foobar   ' 

Ist str.center()/str.ljust()/str.rjust() besser lesbar als die ' ' + s + ' '?

Die str Funktionen und die ' ' + s + ' ' die andere Sache auf Baugruppenebene zu tun, wie in gezeigt:

>>> import dis 
>>> dis.dis(lambda: ' ' + s + ' ') 
    1   0 LOAD_CONST    1 (' ') 
       3 LOAD_GLOBAL    0 (s) 
       6 BINARY_ADD   
       7 LOAD_CONST    1 (' ') 
      10 BINARY_ADD   
      11 RETURN_VALUE   
>>> dis.dis(lambda: s.center(len(s)+2)) 
    1   0 LOAD_GLOBAL    0 (s) 
       3 LOAD_ATTR    1 (center) 
       6 LOAD_GLOBAL    2 (len) 
       9 LOAD_GLOBAL    0 (s) 
      12 CALL_FUNCTION   1 
      15 LOAD_CONST    1 (2) 
      18 BINARY_ADD   
      19 CALL_FUNCTION   1 
      22 RETURN_VALUE   

andere Methoden gibt es die gleiche Sache zu tun, das ist/sind mehr pythonic/leistungsfähig?

---

EDITED

Alternativ scheint dies einen Schritt in den Disassembler zu speichern:

>>> ' {} '.format(s) 
' foobar ' 
>>> dis.dis(lambda: ' {} '.format(s)) 
    1   0 LOAD_CONST    1 (' {} ') 
       3 LOAD_ATTR    0 (format) 
       6 LOAD_GLOBAL    1 (s) 
       9 CALL_FUNCTION   1 
      12 RETURN_VALUE  

So ist die Einsparung in dem Disassembler eine Verbesserung der Effizienz? Oder unterscheidet es sich nicht von der ' ' + s + ' '?

Answer 1

Die Rechtfertigung von Text auf der rechten Seite oder auf der linken Seite sowie die Zentrierung erhalten nur die wahre Bedeutung, wenn Zeichenfolgen in einer Spalte vertikal ausgerichtet werden. Um diese Ausrichtungen korrekt über die gesamte Spalte zu bekommen, Sie endgültig die Länge jeder Zeichenfolge auswerten müssen, um richtig Pad jeder ot ihnen:

def my_centering(s, width): 
    padding = width - len(s) 
    left = padding // 2 
    right = padding - left 
    return ' '*left + s + ' '*right 

die, wie pro meine Python 3.4-Umgebung, zerlegt, mit:

2   0 LOAD_FAST    1 (width) 
      3 LOAD_GLOBAL    0 (len) 
      6 LOAD_FAST    0 (s) 
      9 CALL_FUNCTION   1 (1 positional, 0 keyword pair) 
      12 BINARY_SUBTRACT 
      13 STORE_FAST    2 (padding) 

3   16 LOAD_FAST    2 (padding) 
      19 LOAD_CONST    1 (2) 
      22 BINARY_FLOOR_DIVIDE 
      23 STORE_FAST    3 (left) 

4   26 LOAD_FAST    2 (padding) 
      29 LOAD_FAST    3 (left) 
      32 BINARY_SUBTRACT 
      33 STORE_FAST    4 (right) 

5   36 LOAD_CONST    2 (' ') 
      39 LOAD_FAST    3 (left) 
      42 BINARY_MULTIPLY 
      43 LOAD_FAST    0 (s) 
      46 BINARY_ADD 
      47 LOAD_CONST    2 (' ') 
      50 LOAD_FAST    4 (right) 
      53 BINARY_MULTIPLY 
      54 BINARY_ADD 
      55 RETURN_VALUE 

Also, was auch immer einige Verbesserung der Effizienz in Assembler zum Auffüllen einer Zeichenfolge, Wenn wir mindestens zwei Zeichenfolgen vertikal ausrichten Lassen Sie uns jede Bibliothek oder integrierte Funktionen/Methoden aufrufen. Sie werden :-)

weit schneller

Answer 2

Der Zweck dieser Funktionen (str.ljust, str.rjust und str.center) ist nicht eine feste Anzahl von Zeichen hinzufügen zu starten und/oder Ende eines Strings, aber die richtige Menge hinzufügen davon, und abhängig von der Länge der Zeichenfolge.

Wenn Sie nur eine feste Anzahl von Zeichen hinzufügen möchten, werden Sie diese nicht verwenden, da sie nicht dafür gemacht werden (es kostet Sie, die Länge der Zeichenfolge zu lesen), und Sie verlieren eine gewisse Lesbarkeit.Sie würden wahrscheinlich Ihren eigenen Vorschlag verwenden:

' ' * num + s + ' ' * num

oder sogar, wenn die Zahl festgelegt ist:

' ' + s + ' '

Das ist viel einfacher zu lesen und zu verstehen, und vermutlich auch zu berechnen.