Quiero llenar una cadena con espacios. Sé que lo siguiente funciona para cero:

>>> print  "'%06d'"%4
'000004'

Pero, ¿qué debo hacer cuando quiero esto?:

'hi    '

por supuesto que puedo medir la longitud de la cuerda y hacerlo str+" "*leftover, pero me gustaría el camino más corto.

respuesta

Puedes hacer esto con str.ljust(width[, fillchar]):

Return the string left justified in a string of length width. Padding is done using the specified fillchar (default is a space). The original string is returned if width is less than len(s).

>>> 'hi'.ljust(10)
'hi        '

Para un método flexible que funcione incluso al formatear una cadena complicada, probablemente debería usar el mini-lenguaje de formato de cadena ,

usando cualquiera de las cuerdas f

>>> f'{"Hi": <16} StackOverflow!'  # Python >= 3.6
'Hi               StackOverflow!'

o el str.format()método

>>> '{0: <16} StackOverflow!'.format('Hi')  # Python >=2.6
'Hi               StackOverflow!'

El nuevo método de formato de cadena (ish) le permite hacer algunas cosas divertidas con argumentos de palabras clave anidados. El caso más simple:

>>> '{message: <16}'.format(message='Hi')
'Hi             '

Si desea pasar 16como una variable:

>>> '{message: <{width}}'.format(message='Hi', width=16)
'Hi              '

Si desea pasar variables para todo el kit y kaboodle :

'{message:{fill}{align}{width}}'.format(
   message='Hi',
   fill=' ',
   align='<',
   width=16,
)

Lo que resulta en (lo has adivinado):

'Hi              '

Y para todo esto, puede usar python 3.6+ f-strings :

message = 'Hi'
fill = ' '
align = '<'
width = 16
f'{message:{fill}{align}{width}}'

Y por supuesto el resultado:

'Hi              '

Puedes probar esto:

print "'%-100s'" % 'hi'

La forma correcta de hacer esto sería usar la sintaxis de formato de Python como se describe en la documentación oficial

Para este caso sería simplemente:
'{:10}'.format('hi')
which outputs:
'hi '

Explicación:

format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
fill        ::=  <any character>
align       ::=  "<" | ">" | "=" | "^"
sign        ::=  "+" | "-" | " "
width       ::=  integer
precision   ::=  integer
type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Prácticamente todo lo que necesitas saber está ahí ^.

Actualización: a partir de Python 3.6, ¡es aún más conveniente con la interpolación de cadenas literales!

foo = 'foobar'
print(f'{foo:10} is great!')
# foobar     is great!

Uso str.ljust():

>>> 'Hi'.ljust(6)
'Hi    '

También debe considerar string.zfill(), str.ljust()y str.center()para el formato de cadena. Estos se pueden encadenar y tener especificado el carácter ' relleno ', por lo tanto:

>>> ('3'.zfill(8) + 'blind'.rjust(8) + 'mice'.ljust(8, '.')).center(40)
'        00000003   blindmice....        '

Estas operaciones de formateo de cadenas tienen la ventaja de funcionar en Python v2 y v3.

Eche un vistazo a pydoc stralguna vez: hay una gran cantidad de cosas buenas allí.

A partir de Python 3.6 solo puedes hacer

>>> strng = 'hi'
>>> f'{strng: <10}'

con interpolación de cadenas literales .

O, si el tamaño de su relleno está en una variable, como esta (¡gracias @Matt M.!):

>>> to_pad = 10
>>> f'{strng: <{to_pad}}'

también puedes centrar tu cadena:

'{0: ^20}'.format('nice')

TL;RD

text = 'hi'
print(f'{text:10}') # 'hi        '

explicación más larga

Ya Python3.6que puede usar la interpolación literal de cadenas f .

espacio variables:

value = 4
space = 10

# move value to left
print(f'foo {value:<{space}} bar') # foo 4          bar
# move value to right
print(f'foo {value:>{space}} bar') # foo          4 bar
# center value
print(f'foo {value:^{space}} bar') # foo     4      bar

Espacio constante:

value = 4

# move value to left
print(f'foo {value:<10} bar') # foo 4          bar
# move value to right
print(f'foo {value:>10} bar') # foo          4 bar
# center value
print(f'foo {value:^10} bar') # foo     4      bar

Si desea rellenar con algún otro carácter y luego espacio, especifíquelo al principio:

value = 4
space = 10
padd = '_'

print(f'foo {value:{padd}^{space}} bar') # foo ____4_____ bar
print(f'foo {value:_^10} bar')           # foo ____4_____ bar

Use el formato mini de Python 2.7 para cadenas :

'{0: <8}'.format('123')

Esto alinea a la izquierda y rellena 8 caracteres con el carácter ' '.

Simplemente elimine el 0 y agregará espacio en su lugar:

>>> print  "'%6d'"%4

¿No sería más pitónico usar el corte?

Por ejemplo, para rellenar una cadena con espacios a la derecha hasta que tenga 10 caracteres:

>>> x = "string"    
>>> (x + " " * 10)[:10]   
'string    '

Para rellenarlo con espacios a la izquierda hasta que tenga 15 caracteres:

>>> (" " * 15 + x)[-15:]
'         string'

Por supuesto, requiere saber cuánto tiempo desea aumentar, pero no requiere medir la longitud de la cuerda con la que está comenzando.

Un buen truco para usar en lugar de los diversos formatos de impresión:

(1) Pad con espacios a la derecha:

('hi' + '        ')[:8]

(2) Pad con ceros a la izquierda a la izquierda:

('0000' + str(2))[-4:]

Podría hacerlo usando la comprensión de listas, esto también le daría una idea sobre la cantidad de espacios y sería una sola línea.

"hello" + " ".join([" " for x in range(1,10)])
output --> 'hello                 '