EDITED

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

还有其他任何方法可以做同样的事情，这些方法是更加pythonic /有效吗？

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

这些函数（str.rjust，str.center和' ' * num + s + ' ' * num）的目的不是为字符串的开头和/或结尾添加固定数量的字符，而是添加< em>适量的，取决于字符串的长度。

如果您只想添加固定数量的字符，则不会使用这些字符，因为它们不是为此而制作的（它会让您阅读字符串的长度）并且您需要这样做。会失去一些可读性。您可能会使用自己的提案：

' ' + s + ' '

或者甚至，如果数字是固定的：

The following database has a duplicate instance ID: 08c5382e... The host name is Tfs_SQA. The following database has a duplicate instance ID: 08c5382e... The host name is Tfs_SQA_Archive.

这种阅读和理解更简单，也可能是计算。

Answer 2

在右侧或左侧对齐文本以及居中对齐仅在将字符串打印为在某列中垂直对齐时才有意义。为了使这些对齐在整个列上正确，您最终需要评估每个字符串的长度以正确填充每个字符串：

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

因此，无论填充器填充一个字符串的效率如何提高，如果我们垂直对齐至少两个字符串，让我们调用任何库或内置函数/方法。它们会快得多： - ）

Python中

EDITED

2 个答案: