Эффективность и питоничность пространства пробелов для строки в Python

Question

От How can I fill out a Python string with spaces? принятым ответом на символ пробела в строке справа является использование str.ljust().

Но если мы хотим, чтобы символ пэда в строку слева, мы можем использовать str.rjust(), и для наложения на обоих мы можем использовать str.center(), например.

>>> 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 ' 

Но на внутреннем интерфейсе, является то, что на самом деле более эффективно, чем просто делать это?:

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

ли str.center()/str.ljust()/str.rjust() более читаемым, чем ' ' + s + ' '?

str В функции и ' ' + s + ' ' делать разные вещи на уровне сборки, как показано на:

>>> 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   

Существуют ли какие-либо другие методы, чтобы сделать то же самое, что является/более вещий/эффективным?

---

EDITED

С другой стороны, это, кажется, сохранить один шаг в дизассемблере:

>>> ' {} '.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  

Так является экономия дизассемблера улучшения эффективности? Или это ничем не отличается от ' ' + s + ' '?

Answer 1

Оправдание текста справа или слева, а также его центрирования имеет смысл только при печати строк по вертикали в одном столбце. Для того, чтобы получить эти выравнивания корректные по всей колонне, вы окончательно должны оценить длину каждой строки, чтобы правильно площадку каждый ВЗ их:

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

, который, как в моей среде Python 3.4, разбирает как:

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 

Итак, каково бы ни было повышение эффективности ассемблера для заполнения одной строки, , если мы вертикально выровняем по крайней мере две строки, позвоним нам любую библиотеку или встроенные функции/методы. Они будут гораздо быстрее :-)

Answer 2

Целью этих функций (str.ljust, str.rjust и str.center) не добавить определенное количество символов для начала и/или в конце строки, но добавить нужное количество, и в зависимости от длины строки.

Если вы просто хотите добавить фиксированное количество символов, вы не будете использовать их, поскольку они не сделаны для этого (это стоит вам чтение длины строки), и вы потеряете некоторую удобочитаемость.Вы, вероятно, использовать свое собственное предложение:

' ' * num + s + ' ' * num

или даже, если число фиксировано:

' ' + s + ' '

Это способ проще читать и понимать, и, вероятно, для вычисления слишком.